# configuration/strings/collaboration.strings.ts

> 64 lines of code and 4 definitions.

Tree: Site tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/tree#file-configuration-strings-collaboration-strings-ts
Source text: https://banes-lab.com/assets/sources/source.54ce2a5c2d7fad13f627a17ab0d963df7cc941f8feb02ffe00fbfa082014591a.generated.txt

## Definitions

- `METHOD_LINKS` (lexical_declaration, line 10)
- `INSTRUMENT_DIAGRAM` (lexical_declaration, line 26)
- `ADDS_DIAGRAM` (lexical_declaration, line 29)
- `METHOD_SECTION` (lexical_declaration, line 32, exported)

## Source

```typescript
import { ARCHITECTURE_ICON, METHODOLOGY_ICON } from "#configuration/icons/page.icons";
import { ARCHITECTURE_PAGE, GRAMMAR_PAGE, METHODOLOGY_PAGE } from "#core/ids/page.ids";
import { ARCHITECTURE_TITLE, METHODOLOGY_TITLE } from "#configuration/strings/page.strings";
import { GRAMMAR_VALIDATION_TAB, LIMITATION_SECTION_ID, METHOD_SECTION_ID } from "#core/ids/grammar.ids";
import { pagePath, tabLink } from "#assets/link.assets";
import type { LinkEntry } from "#types/block.types";
import { METHOD_SECTION_ICON } from "#configuration/icons/grammar.icons";
import type { Section } from "#types/document.types";

const METHOD_LINKS: readonly LinkEntry[] = [
    {
        description:
            "The loop, who does what, the stance, the gates and the coordination the grammar is written inside.",
        href: pagePath(METHODOLOGY_PAGE),
        icon: METHODOLOGY_ICON,
        text: METHODOLOGY_TITLE,
    },
    {
        description: "The principle canon, the tensions and the decay paths a document's constraints are drawn from.",
        href: pagePath(ARCHITECTURE_PAGE),
        icon: ARCHITECTURE_ICON,
        text: ARCHITECTURE_TITLE,
    },
];

const INSTRUMENT_DIAGRAM =
    'flowchart TB\n    subgraph method["The method · holds the work"]\n        worth["Worth before work"]\n        gates["Checks that hold the rules"]\n        evidence["Evidence, never a claim"]\n        seats["Coordination between parties"]\n    end\n    subgraph grammar["The grammar · shapes one input"]\n        doc["A document · typed, contracted, gated, bounded"]\n    end\n    worth --> doc\n    doc --> gates\n    gates --> evidence\n    seats -. every party reads the same document .-> doc';

const ADDS_DIAGRAM =
    'flowchart LR\n    subgraph adds["What the grammar adds"]\n        tokens["Tokens the model weights"]\n        order["A processing order"]\n        exits["Explicit exit criteria"]\n        bounds["Boundaries the model can quote"]\n    end\n    narrow["A narrower completion set · never a promise about the completion"]\n    tokens --> narrow\n    order --> narrow\n    exits --> narrow\n    bounds --> narrow';

export const METHOD_SECTION: Section = {
    icon: METHOD_SECTION_ICON,
    id: METHOD_SECTION_ID,
    intro: "A PAG document is one instrument, a single input inside the loop the method owns, as shown in <cite>one input</cite>. It shapes what a model reads, but nothing about it decides whether the work was worth doing, whether the result is true, or how several parties share one tree. Those questions are handled on the methodology page, in worth before work, it looked right and coordination is software. Where a section of this page touches them, it shows how a document expresses them and leaves the reasoning where it lives.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, a document shapes one input: the instruction a party reads before it acts. Everything around that input is held by the method. Worth is decided before the document is written, the output is checked by a gate the document did not run, and parties coordinate through surfaces the document only reads.",
                    boundary:
                        "A collaboration with no tools and no shared tree is a conversation, and a document there is a well-shaped message. The instrument does its work where an adapter can perform what the document names.",
                    cause: "A well-shaped input reads as a guarantee because the output usually matches it, and the failures live in the runs where it does not.",
                    decision:
                        "The checks sit outside the document, in a gate the method runs, rather than inside it as sentences the model completes.",
                    failureMode:
                        "A team writes careful documents, skips the checks because the documents read as complete, and discovers in production that a gate the model reported as passed was never evaluated by anything.",
                    kind: "lesson",
                    principle: "For this reason the grammar shapes an input, and the method holds the work around it.",
                    problem:
                        "A document that reads well invites the belief that it did what it says, and a document cannot verify itself.",
                    validation:
                        "To check this, take a document that reported every gate as passed and run the checks the method names over its output. A gate the checks contradict was a sentence the model completed, and the document could not have known.",
                },
                {
                    kind: "text",
                    text: `What a document adds to a collaboration is concrete, as listed in <cite>what it adds</cite>, and each addition narrows the set of completions without promising what the model will do with them. What a document cannot add is stated under <a href="${tabLink(GRAMMAR_PAGE, GRAMMAR_VALIDATION_TAB, LIMITATION_SECTION_ID)}">limits</a>; those absences are real, and the methodology page covers them in it looked right, verify the verifier and a report, not a checkbox.`,
                },
                { kind: "link", links: METHOD_LINKS },
                { caption: "one input", kind: "mermaid", text: INSTRUMENT_DIAGRAM },
                { caption: "what it adds", kind: "mermaid", text: ADDS_DIAGRAM },
            ],
            title: "One instrument inside a method",
        },
    ],
    title: "PAG and the method",
};
```