import {
    ADVERSARIAL_SECTION_ICON,
    READING_SECTION_ICON,
    STANCE_SECTION_ICON,
} from "#configuration/icons/methodology.start.icons";
import { ADVERSARIAL_SECTION_ID, READING_SECTION_ID, STANCE_SECTION_ID } from "#core/ids/methodology.start.ids";
import { nodeLink as node, stageLink as stage } from "#domain/converters/link.converter";
import type { Section } from "#types/document.types";

const CLAIM_DIAGRAM =
    'flowchart TB\n    claim["A claim about the tree"]\n    read{"Read in this session?"}\n    lead["A lead · follow it to the file"]\n    evidence["Evidence · the path and the line"]\n    act["Act on it"]\n    claim --> read\n    read -- no --> lead\n    read -- yes --> evidence\n    lead --> read\n    evidence --> act';

const SPREAD_DIAGRAM =
    'flowchart TB\n    claim["A claim is written"]\n    agree1["A peer agrees · one read of the sentence"]\n    agree2["A second peer agrees · one read of the agreement"]\n    plan["It becomes a plan row"]\n    open["Someone opens the file"]\n    refuted["Refuted · the file moved before the claim was written"]\n    claim --> agree1 --> agree2 --> plan\n    claim -. costs one read of the operand .-> open --> refuted';

const READING_DIAGRAM =
    'flowchart TB\n    message["A message arrives"]\n    subgraph readings["Read whole, in order"]\n        identity["What exists"]\n        composition["What it is made of"]\n        structure["How the parts are arranged"]\n        relation["What it connects to"]\n        space["Where it sits"]\n        time["When it happens"]\n        state["The condition it is in"]\n        change["How it is already moving"]\n        behaviour["What it does"]\n        function["The role that doing serves"]\n        cause["Why it happens"]\n        meaning["What it signifies"]\n        scale["The level it lives at"]\n        probability["How sure each reading is"]\n        novelty["What cuts against expectation"]\n    end\n    reply["The reply is that understanding, made explicit"]\n    message --> identity --> composition --> structure --> relation --> space --> time --> state --> change --> behaviour --> function --> cause --> meaning --> scale --> probability --> novelty --> reply';

const STANCE_SECTION: Section = {
    icon: STANCE_SECTION_ICON,
    id: STANCE_SECTION_ID,
    intro: "Four sentences carry the whole stance. Every claim stays unverified until someone reads it in the current tree, the read <cite>claim to evidence</cite> draws. Review is adversarial by default, because agreement is cheaper than verification, as <cite>agreement outruns</cite> shows. Every manual step is a failure of automation, and the ontology names the decay it leads to: manual runbook dependency and manual-only governance. Documents state current truth and carry no history of their own, which is single source of truth applied to prose. Everything else in this method is a mechanism that makes one of those four sentences hold without anyone remembering it.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "Open the file before you say what it contains. Run the command before you say what it prints. Quote the line, not the memory of it. Treat a claim about what a mechanism does as a claim about a file, and open that file, and where the claim is about what it does, run it, because a report about a mechanism, a rule describing it and a peer's account of it are all prose.",
                    cause: "A model recalls a plausible version of the file, and a person recalls the version they last edited. Neither is the file.",
                    decision: "Treat recollection as a lead, never as evidence.",
                    failureMode:
                        "The AI describes a function that someone renamed two sessions ago, edits against that description, and the edit lands in the wrong place.",
                    kind: "lesson",
                    principle: "A claim about the tree is a lie until someone reads the tree.",
                    problem: "A question about the code is answered without opening it.",
                    validation:
                        "Ask for the file path and line of anything the AI asserts. An assertion with no location is an assumption.",
                },
                {
                    kind: "text",
                    text: `The stance binds every input equally. My own messages, the AI's reasoning, its edits and their success reports, a prior turn's summary, a peer's account and a file's claim about itself are all unverified until observed now. Reasoning is not verification, and a success report is the failure it looked right is built on. Verified means read or executed in the current state, which is what the loop's ${node("ver-ground-truth", "ground truth")} node asks for, and a file is read whole, because a partial read destroys structure and structure is the object of analysis.`,
                },
                {
                    kind: "text",
                    text: "A claim spreads at the speed of agreement and its refutation at the speed of verification. Agreeing with a peer costs one read of what they wrote. Refuting them costs opening the thing they wrote about, and only a party with a reason to doubt pays that. So a wrong statement outruns its own correction by construction, and the more coherent the argument around it, the faster it spreads, because a claim that fits invites agreement rather than inspection. The discipline that follows is small: a statement resting on someone else's reading re-opens the thing they read, never their sentence, and a claim about a mechanism is settled by making the mechanism do the thing rather than by reading its source.",
                },
                {
                    kind: "text",
                    text: "The difference shows in one exchange. Asked whether the router uses the new name, the answer from memory is <em>the router already uses the new name, so nothing else needs to change</em>. The answer from the tree is <em>the handler in the router still calls the old name, here is the line</em>. Only the second one can be wrong in a way someone can see.",
                },
                { caption: "claim to evidence", kind: "mermaid", text: CLAIM_DIAGRAM },
                { caption: "agreement outruns", kind: "mermaid", text: SPREAD_DIAGRAM },
            ],
            title: "Read before you claim",
        },
    ],
    title: "The stance",
};

const ADVERSARIAL_SECTION: Section = {
    icon: ADVERSARIAL_SECTION_ICON,
    id: ADVERSARIAL_SECTION_ID,
    intro: "The second sentence of the stance is that review is adversarial by default. It follows from the first: a claim about the work is unverified until someone tries to break it, and a review that starts from approval has nothing to verify.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "Open a review by listing what is wrong. Let approval be what remains when the list is empty. Reject any reply that opens with praise, and attack your own output before presenting it, because a deliverable nobody has tried to break is unfinished.",
                    cause: "Training rewards the model for agreement, so agreement is its cheapest answer.",
                    decision:
                        "Make the list of findings the deliverable of a review, rather than a verdict with reasons attached.",
                    failureMode:
                        "A review reads well, approves the change, and the regression ships because nobody was looking for it.",
                    kind: "lesson",
                    principle: "Affirmation is a conclusion of verification, never a starting stance.",
                    problem: "An AI asked to review will tend to affirm, and affirmation feels like a review.",
                    validation:
                        "Count the findings in the review. A review with none either checked nothing or checked the wrong thing.",
                },
                {
                    kind: "text",
                    text: "The other two sentences follow from the first two. A step a person performs is a step nobody checks, so it is performed differently the next time, and the repair is that tools live in the tree. A document with history in it is a document whose current truth a reader has to reconstruct, and a reader reconstructing truth is a reader guessing, and the repair is derived state.",
                },
            ],
            title: "The list before the verdict",
        },
    ],
    title: "Adversarial by default",
};

const READING_SECTION: Section = {
    icon: READING_SECTION_ICON,
    id: READING_SECTION_ID,
    intro: `A message is never merely answered. It is resolved, and resolving it means seeing it whole in one pass before a word of reply forms, the readings <cite>the readings</cite> orders. This is the ${stage("orient")} node of the loop applied to a request, walked along the ontology axis the reasoning face publishes, and it is where most drift starts, because a request answered at its surface is a request whose architecture nobody read.`,
    subsections: [
        {
            blocks: [
                {
                    application:
                        "Read a request along the fifteen readings of the ontology axis, in their order, before replying, and let the reply be that understanding made explicit, carried in connected phrases rather than headings.",
                    boundary:
                        "A one-line request that resolves to one file and one edit still passes through the readings, but they take a second and most of them read as empty. The readings scale with the request, and an empty reading is a real answer rather than a skipped one.",
                    cause: "A reply forms from the first plausible reading, and the first reading is the surface.",
                    decision: "Resolve the message before answering it.",
                    failureMode:
                        "A request to rename a function is answered by renaming the function, and the three collectors that resolved it by pattern go quietly empty because nobody asked what the name connected to.",
                    kind: "lesson",
                    principle:
                        "Architecture is the target, and wording is evidence about it rather than the subject of it.",
                    problem:
                        "A message answered at its surface is answered wrong in the details that only the structure reveals.",
                    validation:
                        "Take a reply and ask which of the readings it rests on. A reply that skipped a reading is incomplete, not concise, and the reading it skipped is where the defect lands.",
                },
                {
                    kind: "text",
                    text: `The readings are an axis, and the axis is what turns judgement into something a check can hold. Each reading is a node of the ontology axis with a question and a mathematical shape behind it. ${node("ont-identity", "Identity")} asks what exists and answers with a set, ${node("ont-structure", "structure")} asks how the parts are arranged and answers with an ordering. ${node("ont-relation", "Relation")} asks what it connects to and answers with a graph, and ${node("ont-probability", "probability")} asks how sure each reading is and answers with a number between zero and one. The others, ${node("ont-composition", "composition")}, ${node("ont-space", "space")}, ${node("ont-time", "time")}, ${node("ont-state", "state")}, ${node("ont-change", "change")}, ${node("ont-behaviour", "behaviour")}, ${node("ont-function", "function")}, ${node("ont-cause", "cause")}, ${node("ont-meaning", "meaning")}, ${node("ont-scale", "scale")} and ${node("ont-novelty", "novelty")}, each carry a shape of their own.`,
                },
                {
                    kind: "text",
                    text: "A question that resolves to a shape resolves to a predicate, and an architecture is its predicate set on the architecture page carries what a predicate does with that, so the reading a person did once becomes the check a machine does every time.",
                },
                {
                    kind: "text",
                    text: "Introspection goes one level below the abstraction a thing presents. A document's section list is surface, and the rule that decides what may enter a section is the architecture. A function's signature is surface, and its state ownership and lifecycle are the architecture. A count is surface, and the scope it was taken over is the architecture. Reading at that level is what makes the first reading of a request agree with the last verification of its result, because both are looking at the same thing.",
                },
                { caption: "the readings", kind: "mermaid", text: READING_DIAGRAM },
            ],
            title: "Fifteen readings, one pass",
        },
    ],
    title: "Resolving a message",
};

export const STANCE_SECTIONS: readonly Section[] = [STANCE_SECTION, ADVERSARIAL_SECTION, READING_SECTION];