@ybotok/loam 0.1.0-beta.3 → 0.2.0-alpha.13

package/dist/core/brief/map/owed.js

@@ -0,0 +1,266 @@
+/**
+ * The write one service still owes `architecture/landscape.likec4`: the
+ * target the brief hands over (`landscapeArtifact` — its shape rules and the
+ * example block or edges) and the instruction in prose (`instructionFor` —
+ * the file, the block, and the consequence, in the four states a landscape
+ * can be in). Both exist to stop an agent inventing a parallel model: the
+ * fleet has already drawn some of these boxes and edges, and a baseline has to
+ * attach.
+ *
+ * A sub-package of `core/brief/` because that package sits at its five-file
+ * cap and `landscape.ts` — which READS what the map already says about the
+ * service and decides which state it is in — had parked at the file ceiling
+ * with its object literals collapsed onto single lines to fit. The two halves
+ * are distinct subjects: one is the derivation over a parsed document, the
+ * other is all of the prose plus the vocabulary that prose reads (`BrokenMap`
+ * and its builder live here for that reason — beside the arm that spends them,
+ * not in the caller that fills them). The only tie back to the parent is
+ * `import type { BriefTarget }`, which `verbatimModuleSyntax` erases, so this
+ * package value-imports nothing from `../` and the package graph stays acyclic.
+ */
+import { brokenDocumentPaths } from "../../c4/likec4.js";
+import { spellCall, edgeTemplates } from "../../c4/resolve/attested.js";
+import { serviceElementId } from "../../c4/seed/template.js";
+/**
+ * The write this service still owes `architecture/landscape.likec4`.
+ *
+ * `expects` is what the fleet ALREADY calls on the service — those edges exist
+ * in the map today, so the example draws the outbound side as a comment rather
+ * than telling an agent to duplicate an edge that is already there. With
+ * `elementId` set the example is EDGES ONLY, on the element that exists: a
+ * block here would be the second box the edgeless state exists to refuse, and
+ * the attested calls are listed as comments the agent turns into edges by
+ * naming the other party as the map spells it.
+ */
+function landscapeBlock(req) {
+    const { service, expects, present } = req;
+    if (req.elementId !== undefined) {
+        const id = req.elementId;
+        return [
+            "model {",
+            `  // ... every element stays exactly as it is — ${id} already resolves to ${req.servicePath}/ ...`,
+            "",
+            "  // every call in or out of it, one edge each, on the existing element:",
+            `  //   ${id} -> <callee> 'Calls <operationId>' { metadata { op '<operationId>' } }`,
+            `  //   <caller> -> ${id} 'Calls <operationId>' { metadata { op '<operationId>' } }`,
+            ...(req.attested.length > 0
+                ? [
+                    `  // the calls ${req.servicePath}/model.likec4 already attests, as the model spells the other party:`,
+                    ...req.attested.map((c) => `  //   ${id} ${spellCall(c)}`),
+                ]
+                : []),
+            "}",
+        ].join("\n");
+    }
+    const id = serviceElementId(service);
+    const calls = expects.length > 0
+        ? expects.map((op) => `//   <caller> -> ${id} 'Calls ${op}' { metadata { op '${op}' } }`)
+        : [`//   <caller> -> ${id} 'Calls <operationId>' { metadata { op '<operationId>' } }`];
+    const model = [
+        "model {",
+        ...(present ? ["  // ... the fleet's other services stay exactly as they are ...", ""] : []),
+        `  ${id} = softwareSystem '${service}' {`,
+        "    description '<one line: what this service is responsible for>'",
+        `    metadata { service '${service}' }`,
+        "  }",
+        "",
+        "  // every call in or out of it, one edge each:",
+        ...calls.map((line) => `  ${line}`),
+        "}",
+    ];
+    // When the file does not exist the example is the WHOLE file, so it carries
+    // the `specification` block a bare `model` would be rejected without: the
+    // brief must never hand over a document `loam validate` refuses. When the file
+    // does exist the example is a fragment to splice, and repeating a
+    // `specification` block there would invite a second one.
+    return present
+        ? model.join("\n")
+        : ["specification {", "  element softwareSystem", "}", "", ...model].join("\n");
+}
+const OP_EDGE_RULE = "Draw every cross-service call as an edge carrying the operation it uses: `a -> b 'Calls createSplit' { metadata { op 'createSplit' } }`. The `op` must be an operationId the TARGET's openapi.yaml defines, or `spine.op-undefined` (error) — a broken contract between services.";
+/** What the edgeless state costs when a check is watching — the ordinary case. */
+const ISOLATED_RULE = (servicePath) => `\`loam validate --all\` reports \`landscape.service-isolated\` (warn) while this element has no edge and ` +
+    `\`${servicePath}/model.likec4\` declares a call across its boundary; with no such call it stays silent, so ` +
+    `an edgeless service that truly calls nothing is correct, and this brief says so.`;
+/**
+ * The same state under `#external`, where NO check is watching.
+ *
+ * `landscape.service-isolated` removes every `#external` element from its
+ * subject set — the fix that stopped a foreign box answering for one of our
+ * directories — so on this tree the warning the brief used to promise cannot
+ * fire, measured: `validate --all` reports `landscape.matched` and the full
+ * `--json` findings walk holds no isolation finding at all. A brief that names
+ * a warning nothing will raise is worse than one that says nothing, because the
+ * agent budgets against the check instead of against the sentence.
+ */
+const EXTERNAL_RULE = (elementId, servicePath) => `\`${elementId}\` carries \`#external\`, so \`landscape.service-isolated\` will NOT fire here whatever this ` +
+    `element's edges are — the check skips every element the map marks as somebody else's, exactly as the two ` +
+    `binding checks do. Nothing in \`loam validate --all\` names this state; this brief is the only place it is ` +
+    `said. If \`${servicePath}/\` is ours, drop \`#external\` from the element and the check applies again; if it ` +
+    `is genuinely somebody else's, the calls belong on the element of the service that makes them.`;
+/** The fleet map's own brief — assembled per service, because the write it owes names the service. */
+export function landscapeArtifact(req) {
+    const { service, servicePath, elementId } = req;
+    const whole = "This file is the WHOLE FLEET's, not this service's. Add to it; never rewrite it. Everything already in `model { ... }` belongs to the other services, and replacing the file destroys their map along with their edges.";
+    return {
+        artifact: "landscape.likec4",
+        required: true,
+        purpose: `the fleet map — ${elementId === undefined
+            ? "until an element here resolves to this directory, the service is documented"
+            : "an element here resolves to this directory and no edge touches it, so the service is drawn"} and invisible to every cross-service check`,
+        shape: elementId === undefined
+            ? [
+                whole,
+                `Add one top-level element for the service, bound to its directory: \`metadata { service '${service}' }\`. Until an element resolves to \`${servicePath}/\`, \`loam validate --all\` reports \`landscape.service-unmodelled\` (error).`,
+                "Bind rather than rename: a binding whose id names no directory is `landscape.binding-unknown` (error), and two elements binding the SAME directory is `landscape.binding-duplicate` (warn) — every element→service join then picks one of them arbitrarily.",
+                OP_EDGE_RULE,
+                "If the file does not exist yet, create it with a `specification { ... }` block declaring the kinds you use, then the `model { ... }` block. A landscape that does not parse is `landscape.invalid` (error) and blinds every cross-service check at once.",
+            ]
+            : [
+                whole,
+                `An element already resolves to \`${servicePath}/\` (\`${elementId}\`). Do NOT add a second one — two elements resolving to one directory is \`landscape.binding-duplicate\` (warn) and every element→service join then picks one of them arbitrarily. What the map lacks is every call in or out of it.`,
+                OP_EDGE_RULE,
+                req.external === true ? EXTERNAL_RULE(elementId, servicePath) : ISOLATED_RULE(servicePath),
+            ],
+        example: landscapeBlock(req),
+    };
+}
+/**
+ * That record, built from a project's diagnostics — beside the type it fills and
+ * the arm that reads it, rather than in the caller.
+ *
+ * Spelled exactly as `commands/validate/fleet/landscape.ts` spells it for
+ * `landscape.invalid` — deduped, relative to the docs root, `/`-joined — because
+ * the two surfaces are read one after the other on the same tree and an agent
+ * has to be able to tell that they name the same file: both go through
+ * `c4/likec4.ts`'s `brokenDocumentPaths`.
+ */
+export function brokenDocuments(docsDir, land) {
+    return { paths: brokenDocumentPaths(docsDir, land.errors), errors: land.errors.length };
+}
+/**
+ * The fleet-map instruction, in the four states a landscape can be in. It says
+ * the file, the block, and the consequence, in that order. The consequence is
+ * the part agents acted on: "add an element" reads as tidiness, "until you do,
+ * `loam validate --all` fails and no cross-service check can see this service"
+ * reads as work.
+ */
+export function instructionFor(req) {
+    const { service, state, expects, servicePath } = req;
+    const id = serviceElementId(service);
+    const bind = `an element bound with \`metadata { service '${service}' }\``;
+    const consequence = `Until one resolves, \`loam validate --all\` reports \`landscape.service-unmodelled\` (error) for ` +
+        `${servicePath}/: the service is documented and invisible — no edge into it can be checked ` +
+        `against its openapi.yaml, and no feature can draw a call to it.`;
+    // `expects` is reachable only through inbound edges, so it is empty in every
+    // state that ASKS for an element — the edgeless one by definition. (The
+    // unparseable state can carry it, off the landscape-file fallback, and that
+    // arm deliberately does not append this sentence: it asks for no element, so
+    // "your element is what they will resolve to" would name one loam has not
+    // read.) It is threaded through anyway rather than dropped: the caller
+    // computes it once, and the day an unmodelled service can inherit an edge (a
+    // container-level binding, say) the sentence is already here.
+    const owed = expects.length > 0
+        ? ` The fleet already calls ${expects.map((o) => `'${o}'`).join(", ")} on this service, so those edges exist; your element is what they will resolve to.`
+        : "";
+    if (state === "absent") {
+        return (`architecture/landscape.likec4 does not exist yet. Create it with a \`specification { ... }\` block ` +
+            `declaring the kinds you use and a \`model { ... }\` block containing ${bind} ` +
+            `(conventionally \`${id} = softwareSystem '${service}'\`), plus one edge per cross-service call, each ` +
+            `carrying \`metadata { op '<operationId>' }\`. ${consequence}${owed}`);
+    }
+    if (state === "unparseable") {
+        // The map is the whole `architecture/` project, so the document that broke
+        // is usually a SIBLING of the landscape — a use case, a palette. This arm
+        // named `architecture/landscape.likec4` regardless and told an agent to go
+        // and fix parse errors in a file that has none, contradicting the
+        // `landscape.invalid` that `validate --all` prints on the same tree one
+        // second later. The EDGELESS arm below carries the same rule in its own WHY:
+        // never name bytes loam did not read.
+        const b = req.broken;
+        const named = b === undefined || b.paths.length === 0
+            ? "The fleet map (architecture/) does not parse"
+            : `${b.paths.join(", ")} ${b.paths.length === 1 ? "does" : "do"} not parse (${String(b.errors)} error(s)` +
+                `${b.paths.length === 1 ? "" : " between them"}), so the fleet map (architecture/) cannot be read`;
+        return (`${named} (\`landscape.invalid\`). Nothing can be said about what the map already models — not that it ` +
+            `lacks an element for ${servicePath}/, and not that it holds one — so this brief asks for no edit to it. ` +
+            `Fix the parse errors first (they blind every cross-service check at once, and \`loam validate --all\` ` +
+            `names the same file), then re-run \`loam adopt --service ${service}\`: it will say whether the map already ` +
+            `holds ${bind}, and adding one before then risks a second box for a service the map already draws ` +
+            `(\`landscape.binding-duplicate\`).`);
+    }
+    if (state === "edgeless")
+        return edgelessInstruction(req);
+    return (`Nothing in architecture/landscape.likec4 resolves to ${servicePath}/. ADD to that file — do not rewrite ` +
+        `it, every other service's map is in there — ${bind}, conventionally ` +
+        `\`${id} = softwareSystem '${service}'\`, inside the existing \`model { ... }\` block, and draw each ` +
+        `cross-service call as an edge carrying \`metadata { op '<operationId>' }\`. ${consequence}${owed}`);
+}
+/**
+ * The fourth state, in two arms: with attested calls it names each and says to
+ * carry it up as ONE edge on the existing element; without, it points at the
+ * walk stops that produce the evidence and otherwise says draw NOTHING — an
+ * invented edge is a dependency the fleet then plans against. Neither arm asks
+ * for a second element, and both name the tags loam does not read.
+ */
+/**
+ * Which sentence the attested arm may end on: what will hold the agent to this
+ * edit, or the admission that nothing will.
+ *
+ * `landscape.service-isolated` skips every `#external` element, so on such a
+ * tree the promise "reports it until an edge lands" is one the check cannot
+ * keep — and the brief was making it on exactly the tree that fix was written
+ * for (verification 2026-09-04). The `#external` arm says so instead, and says
+ * how to make the check apply.
+ */
+function accountability(req, id) {
+    if (req.external === true) {
+        return (`\`${id}\` carries \`#external\`, so \`landscape.service-isolated\` will NOT fire here whatever you draw — ` +
+            `the check skips every element the map marks as somebody else's. Nothing in \`loam validate --all\` names ` +
+            `this state; this brief is the only place it is said. Drop \`#external\` from the element if ` +
+            `${req.servicePath}/ is ours, and the check applies again.`);
+    }
+    return ("`loam validate --all` reports `landscape.service-isolated` (warn) until an edge lands — ONE edge, on any " +
+        "of them: the check is touched/untouched, not a set difference, so nothing will name the calls you leave " +
+        "undrawn.");
+}
+function edgelessInstruction(req) {
+    const { servicePath, attested, foreignTags } = req;
+    const id = req.elementId ?? serviceElementId(req.service);
+    // "the fleet map (architecture/)" rather than the landscape FILE: the map is
+    // the whole project, an element may be declared in any document of it, and
+    // LikeC4 hands back no source document for an element — so naming a file
+    // here would be a claim about bytes loam did not read. The write still lands
+    // in `architecture/landscape.likec4`; the target's `path` says so.
+    const opening = `\`${id}\` in the fleet map (architecture/) resolves to ${servicePath}/ and no edge in the map touches it — ` +
+        `the service is drawn and invisible to every cross-service check.`;
+    const tags = foreignTags.length === 0
+        ? ""
+        : ` The element carries ${foreignTags.map((t) => `#${t}`).join(", ")} — tags loam does not read; if one marks a ` +
+            `placeholder drawn ahead of adoption, clearing it is part of this edit, because a view written ` +
+            `\`exclude element.tag = #<that>\` keeps an adopted service hidden.`;
+    if (attested.length > 0) {
+        // The edge form follows the calls' direction (`edgeTemplates`): this arm
+        // used to spell the outbound form alone, so an inbound call was carried
+        // up backwards.
+        const forms = edgeTemplates(id, attested)
+            .map((t) => `\`${t}\``)
+            .join(" or ");
+        return (`${opening} ${servicePath}/model.likec4 already declares ${attested.length} call(s) across its boundary: ` +
+            `${attested.map(spellCall).join(", ")}. Carry each one up as ONE edge on \`${id}\`, collapsed to the ` +
+            `service — ${forms} for a call, \`publishes\`/\`consumes\` ` +
+            `for an event — naming the other party as the map already spells it; where the model's word names a ` +
+            `different thing in the map, say so in the hand-back instead of drawing it. Do not add a second element: ` +
+            `one already resolves. ${accountability(req, id)} Carry all of them up now, or say in the hand-back which ` +
+            `you did not and why.${tags}`);
+    }
+    return (`${opening} Nothing in ${servicePath}/model.likec4 attests a call across its boundary — absent, unparseable ` +
+        `and internal-only read alike here, because this brief may only name calls already attested. Draw the ones ` +
+        `the walk's outbound and message stops (stops 4 and 7) find, each as one edge on \`${id}\` carrying ` +
+        `\`metadata { op '<operationId>' }\` for a call or \`publishes\`/\`consumes\` for an event; if the service ` +
+        `genuinely makes and receives no call, draw NOTHING — an invented edge is a dependency the fleet then plans ` +
+        `against, and an edgeless element that is TRUE is a fact. Do not add a second element: one already resolves. ` +
+        `Nothing in \`loam validate --all\` names this state while the model attests no call; this brief is the only ` +
+        `place it is said.${tags}`);
+}
+//# sourceMappingURL=owed.js.map

package/dist/core/brief/map/owed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"owed.js","sourceRoot":"","sources":["../../../../src/core/brief/map/owed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The write one service still owes `architecture/landscape.likec4`: the\n * target the brief hands over (`landscapeArtifact` — its shape rules and the\n * example block or edges) and the instruction in prose (`instructionFor` —\n * the file, the block, and the consequence, in the four states a landscape\n * can be in). Both exist to stop an agent inventing a parallel model: the\n * fleet has already drawn some of these boxes and edges, and a baseline has to\n * attach.\n *\n * A sub-package of `core/brief/` because that package sits at its five-file\n * cap and `landscape.ts` — which READS what the map already says about the\n * service and decides which state it is in — had parked at the file ceiling\n * with its object literals collapsed onto single lines to fit. The two halves\n * are distinct subjects: one is the derivation over a parsed document, the\n * other is all of the prose plus the vocabulary that prose reads (`BrokenMap`\n * and its builder live here for that reason — beside the arm that spends them,\n * not in the caller that fills them). The only tie back to the parent is\n * `import type { BriefTarget }`, which `verbatimModuleSyntax` erases, so this\n * package value-imports nothing from `../` and the package graph stays acyclic.\n */\nimport { brokenDocumentPaths, type LikeC4Error } from \"../../c4/likec4.js\";\nimport { spellCall, edgeTemplates, type AttestedCall } from \"../../c4/resolve/attested.js\";\nimport { serviceElementId } from \"../../c4/seed/template.js\";\nimport type { BriefTarget } from \"../targets.js\";\n\n/*\n * The identifier a brief suggests for an element the map does not draw yet is\n * `serviceElementId` — `loam seed`'s `svc_<id>`, never a convention of the\n * brief's own. It used to be the directory name camel-cased here, so on a\n * seeded fleet the brief handed an agent `paymentService` beside a map whose\n * every box was `svc_payment_service`. A suggestion and nothing more —\n * `metadata { service '<id>' }` is what joins the element to the directory —\n * but a brief handing over a concrete block gets followed, and one describing\n * a block in prose gets improvised on, so the spelling has to be the fleet's.\n * The `svc_` prefix also covers what the old helper special-cased by hand: a\n * service id may open with a digit, a LikeC4 identifier may not.\n */\n\n/* ------------------------------------------------------------------ */\n/* The target                                                          */\n/* ------------------------------------------------------------------ */\n\n/** What `landscapeArtifact` needs — one record, because the fields only ever travel together. */\nexport interface LandscapeArtifactRequest {\n  service: string;\n  expects: string[];\n  present: boolean;\n  servicePath: string;\n  /** The element that already resolves to the service — set only in the edgeless state — and the calls its model attests. */\n  elementId?: string;\n  /**\n   * Whether that element carries `#external`. It changes what the brief may\n   * PROMISE and nothing else: `landscape.service-isolated` removes every\n   * `#external` element from its subject set, so on such a tree no warning holds\n   * the agent accountable, and saying one will is the false promise this flag\n   * exists to stop (verification 2026-09-04).\n   */\n  external?: boolean;\n  attested: AttestedCall[];\n}\n\n/**\n * The write this service still owes `architecture/landscape.likec4`.\n *\n * `expects` is what the fleet ALREADY calls on the service — those edges exist\n * in the map today, so the example draws the outbound side as a comment rather\n * than telling an agent to duplicate an edge that is already there. With\n * `elementId` set the example is EDGES ONLY, on the element that exists: a\n * block here would be the second box the edgeless state exists to refuse, and\n * the attested calls are listed as comments the agent turns into edges by\n * naming the other party as the map spells it.\n */\nfunction landscapeBlock(req: LandscapeArtifactRequest): string {\n  const { service, expects, present } = req;\n  if (req.elementId !== undefined) {\n    const id = req.elementId;\n    return [\n      \"model {\",\n      `  // ... every element stays exactly as it is — ${id} already resolves to ${req.servicePath}/ ...`,\n      \"\",\n      \"  // every call in or out of it, one edge each, on the existing element:\",\n      `  //   ${id} -> <callee> 'Calls <operationId>' { metadata { op '<operationId>' } }`,\n      `  //   <caller> -> ${id} 'Calls <operationId>' { metadata { op '<operationId>' } }`,\n      ...(req.attested.length > 0\n        ? [\n            `  // the calls ${req.servicePath}/model.likec4 already attests, as the model spells the other party:`,\n            ...req.attested.map((c) => `  //   ${id} ${spellCall(c)}`),\n          ]\n        : []),\n      \"}\",\n    ].join(\"\\n\");\n  }\n  const id = serviceElementId(service);\n  const calls =\n    expects.length > 0\n      ? expects.map((op) => `//   <caller> -> ${id} 'Calls ${op}' { metadata { op '${op}' } }`)\n      : [`//   <caller> -> ${id} 'Calls <operationId>' { metadata { op '<operationId>' } }`];\n  const model = [\n    \"model {\",\n    ...(present ? [\"  // ... the fleet's other services stay exactly as they are ...\", \"\"] : []),\n    `  ${id} = softwareSystem '${service}' {`,\n    \"    description '<one line: what this service is responsible for>'\",\n    `    metadata { service '${service}' }`,\n    \"  }\",\n    \"\",\n    \"  // every call in or out of it, one edge each:\",\n    ...calls.map((line) => `  ${line}`),\n    \"}\",\n  ];\n  // When the file does not exist the example is the WHOLE file, so it carries\n  // the `specification` block a bare `model` would be rejected without: the\n  // brief must never hand over a document `loam validate` refuses. When the file\n  // does exist the example is a fragment to splice, and repeating a\n  // `specification` block there would invite a second one.\n  return present\n    ? model.join(\"\\n\")\n    : [\"specification {\", \"  element softwareSystem\", \"}\", \"\", ...model].join(\"\\n\");\n}\n\nconst OP_EDGE_RULE =\n  \"Draw every cross-service call as an edge carrying the operation it uses: `a -> b 'Calls createSplit' { metadata { op 'createSplit' } }`. The `op` must be an operationId the TARGET's openapi.yaml defines, or `spine.op-undefined` (error) — a broken contract between services.\";\n\n/** What the edgeless state costs when a check is watching — the ordinary case. */\nconst ISOLATED_RULE = (servicePath: string): string =>\n  `\\`loam validate --all\\` reports \\`landscape.service-isolated\\` (warn) while this element has no edge and ` +\n  `\\`${servicePath}/model.likec4\\` declares a call across its boundary; with no such call it stays silent, so ` +\n  `an edgeless service that truly calls nothing is correct, and this brief says so.`;\n\n/**\n * The same state under `#external`, where NO check is watching.\n *\n * `landscape.service-isolated` removes every `#external` element from its\n * subject set — the fix that stopped a foreign box answering for one of our\n * directories — so on this tree the warning the brief used to promise cannot\n * fire, measured: `validate --all` reports `landscape.matched` and the full\n * `--json` findings walk holds no isolation finding at all. A brief that names\n * a warning nothing will raise is worse than one that says nothing, because the\n * agent budgets against the check instead of against the sentence.\n */\nconst EXTERNAL_RULE = (elementId: string, servicePath: string): string =>\n  `\\`${elementId}\\` carries \\`#external\\`, so \\`landscape.service-isolated\\` will NOT fire here whatever this ` +\n  `element's edges are — the check skips every element the map marks as somebody else's, exactly as the two ` +\n  `binding checks do. Nothing in \\`loam validate --all\\` names this state; this brief is the only place it is ` +\n  `said. If \\`${servicePath}/\\` is ours, drop \\`#external\\` from the element and the check applies again; if it ` +\n  `is genuinely somebody else's, the calls belong on the element of the service that makes them.`;\n\n/** The fleet map's own brief — assembled per service, because the write it owes names the service. */\nexport function landscapeArtifact(req: LandscapeArtifactRequest): Omit<BriefTarget, \"path\" | \"exists\" | \"action\"> {\n  const { service, servicePath, elementId } = req;\n  const whole =\n    \"This file is the WHOLE FLEET's, not this service's. Add to it; never rewrite it. Everything already in `model { ... }` belongs to the other services, and replacing the file destroys their map along with their edges.\";\n  return {\n    artifact: \"landscape.likec4\",\n    required: true,\n    purpose: `the fleet map — ${\n      elementId === undefined\n        ? \"until an element here resolves to this directory, the service is documented\"\n        : \"an element here resolves to this directory and no edge touches it, so the service is drawn\"\n    } and invisible to every cross-service check`,\n    shape:\n      elementId === undefined\n        ? [\n            whole,\n            `Add one top-level element for the service, bound to its directory: \\`metadata { service '${service}' }\\`. Until an element resolves to \\`${servicePath}/\\`, \\`loam validate --all\\` reports \\`landscape.service-unmodelled\\` (error).`,\n            \"Bind rather than rename: a binding whose id names no directory is `landscape.binding-unknown` (error), and two elements binding the SAME directory is `landscape.binding-duplicate` (warn) — every element→service join then picks one of them arbitrarily.\",\n            OP_EDGE_RULE,\n            \"If the file does not exist yet, create it with a `specification { ... }` block declaring the kinds you use, then the `model { ... }` block. A landscape that does not parse is `landscape.invalid` (error) and blinds every cross-service check at once.\",\n          ]\n        : [\n            whole,\n            `An element already resolves to \\`${servicePath}/\\` (\\`${elementId}\\`). Do NOT add a second one — two elements resolving to one directory is \\`landscape.binding-duplicate\\` (warn) and every element→service join then picks one of them arbitrarily. What the map lacks is every call in or out of it.`,\n            OP_EDGE_RULE,\n            req.external === true ? EXTERNAL_RULE(elementId, servicePath) : ISOLATED_RULE(servicePath),\n          ],\n    example: landscapeBlock(req),\n  };\n}\n\n/* ------------------------------------------------------------------ */\n/* The instruction                                                     */\n/* ------------------------------------------------------------------ */\n\n/** Which documents of `architecture/` failed, and how many errors they carry between them. */\nexport interface BrokenMap {\n  /** Docs-relative POSIX paths, deduped and sorted — spelled as `landscape.invalid` spells them. */\n  paths: string[];\n  errors: number;\n}\n\n/**\n * That record, built from a project's diagnostics — beside the type it fills and\n * the arm that reads it, rather than in the caller.\n *\n * Spelled exactly as `commands/validate/fleet/landscape.ts` spells it for\n * `landscape.invalid` — deduped, relative to the docs root, `/`-joined — because\n * the two surfaces are read one after the other on the same tree and an agent\n * has to be able to tell that they name the same file: both go through\n * `c4/likec4.ts`'s `brokenDocumentPaths`.\n */\nexport function brokenDocuments(docsDir: string, land: { errors: readonly LikeC4Error[] }): BrokenMap {\n  return { paths: brokenDocumentPaths(docsDir, land.errors), errors: land.errors.length };\n}\n\n/** The inputs of `instructionFor` — a record, because the function sat at the parameter cap. */\nexport interface InstructionRequest {\n  service: string;\n  state: \"absent\" | \"unparseable\" | \"unmodelled\" | \"edgeless\";\n  expects: string[];\n  servicePath: string;\n  /**\n   * The documents that failed (`unparseable` state only). Optional so the other\n   * three arms need not carry it, and the arm degrades to naming the project\n   * rather than guessing a file when a caller has none.\n   */\n  broken?: BrokenMap;\n  /** The element that already resolves to the service (edgeless state only), and its tags loam does not read. */\n  elementId?: string;\n  /** Whether that element carries `#external` — see `LandscapeArtifactRequest.external`. */\n  external?: boolean;\n  attested: AttestedCall[];\n  foreignTags: string[];\n}\n\n/**\n * The fleet-map instruction, in the four states a landscape can be in. It says\n * the file, the block, and the consequence, in that order. The consequence is\n * the part agents acted on: \"add an element\" reads as tidiness, \"until you do,\n * `loam validate --all` fails and no cross-service check can see this service\"\n * reads as work.\n */\nexport function instructionFor(req: InstructionRequest): string {\n  const { service, state, expects, servicePath } = req;\n  const id = serviceElementId(service);\n  const bind = `an element bound with \\`metadata { service '${service}' }\\``;\n  const consequence =\n    `Until one resolves, \\`loam validate --all\\` reports \\`landscape.service-unmodelled\\` (error) for ` +\n    `${servicePath}/: the service is documented and invisible — no edge into it can be checked ` +\n    `against its openapi.yaml, and no feature can draw a call to it.`;\n  // `expects` is reachable only through inbound edges, so it is empty in every\n  // state that ASKS for an element — the edgeless one by definition. (The\n  // unparseable state can carry it, off the landscape-file fallback, and that\n  // arm deliberately does not append this sentence: it asks for no element, so\n  // \"your element is what they will resolve to\" would name one loam has not\n  // read.) It is threaded through anyway rather than dropped: the caller\n  // computes it once, and the day an unmodelled service can inherit an edge (a\n  // container-level binding, say) the sentence is already here.\n  const owed =\n    expects.length > 0\n      ? ` The fleet already calls ${expects.map((o) => `'${o}'`).join(\", \")} on this service, so those edges exist; your element is what they will resolve to.`\n      : \"\";\n\n  if (state === \"absent\") {\n    return (\n      `architecture/landscape.likec4 does not exist yet. Create it with a \\`specification { ... }\\` block ` +\n      `declaring the kinds you use and a \\`model { ... }\\` block containing ${bind} ` +\n      `(conventionally \\`${id} = softwareSystem '${service}'\\`), plus one edge per cross-service call, each ` +\n      `carrying \\`metadata { op '<operationId>' }\\`. ${consequence}${owed}`\n    );\n  }\n  if (state === \"unparseable\") {\n    // The map is the whole `architecture/` project, so the document that broke\n    // is usually a SIBLING of the landscape — a use case, a palette. This arm\n    // named `architecture/landscape.likec4` regardless and told an agent to go\n    // and fix parse errors in a file that has none, contradicting the\n    // `landscape.invalid` that `validate --all` prints on the same tree one\n    // second later. The EDGELESS arm below carries the same rule in its own WHY:\n    // never name bytes loam did not read.\n    const b = req.broken;\n    const named =\n      b === undefined || b.paths.length === 0\n        ? \"The fleet map (architecture/) does not parse\"\n        : `${b.paths.join(\", \")} ${b.paths.length === 1 ? \"does\" : \"do\"} not parse (${String(b.errors)} error(s)` +\n          `${b.paths.length === 1 ? \"\" : \" between them\"}), so the fleet map (architecture/) cannot be read`;\n    return (\n      `${named} (\\`landscape.invalid\\`). Nothing can be said about what the map already models — not that it ` +\n      `lacks an element for ${servicePath}/, and not that it holds one — so this brief asks for no edit to it. ` +\n      `Fix the parse errors first (they blind every cross-service check at once, and \\`loam validate --all\\` ` +\n      `names the same file), then re-run \\`loam adopt --service ${service}\\`: it will say whether the map already ` +\n      `holds ${bind}, and adding one before then risks a second box for a service the map already draws ` +\n      `(\\`landscape.binding-duplicate\\`).`\n    );\n  }\n  if (state === \"edgeless\") return edgelessInstruction(req);\n  return (\n    `Nothing in architecture/landscape.likec4 resolves to ${servicePath}/. ADD to that file — do not rewrite ` +\n    `it, every other service's map is in there — ${bind}, conventionally ` +\n    `\\`${id} = softwareSystem '${service}'\\`, inside the existing \\`model { ... }\\` block, and draw each ` +\n    `cross-service call as an edge carrying \\`metadata { op '<operationId>' }\\`. ${consequence}${owed}`\n  );\n}\n\n/**\n * The fourth state, in two arms: with attested calls it names each and says to\n * carry it up as ONE edge on the existing element; without, it points at the\n * walk stops that produce the evidence and otherwise says draw NOTHING — an\n * invented edge is a dependency the fleet then plans against. Neither arm asks\n * for a second element, and both name the tags loam does not read.\n */\n/**\n * Which sentence the attested arm may end on: what will hold the agent to this\n * edit, or the admission that nothing will.\n *\n * `landscape.service-isolated` skips every `#external` element, so on such a\n * tree the promise \"reports it until an edge lands\" is one the check cannot\n * keep — and the brief was making it on exactly the tree that fix was written\n * for (verification 2026-09-04). The `#external` arm says so instead, and says\n * how to make the check apply.\n */\nfunction accountability(req: InstructionRequest, id: string): string {\n  if (req.external === true) {\n    return (\n      `\\`${id}\\` carries \\`#external\\`, so \\`landscape.service-isolated\\` will NOT fire here whatever you draw — ` +\n      `the check skips every element the map marks as somebody else's. Nothing in \\`loam validate --all\\` names ` +\n      `this state; this brief is the only place it is said. Drop \\`#external\\` from the element if ` +\n      `${req.servicePath}/ is ours, and the check applies again.`\n    );\n  }\n  return (\n    \"`loam validate --all` reports `landscape.service-isolated` (warn) until an edge lands — ONE edge, on any \" +\n    \"of them: the check is touched/untouched, not a set difference, so nothing will name the calls you leave \" +\n    \"undrawn.\"\n  );\n}\n\nfunction edgelessInstruction(req: InstructionRequest): string {\n  const { servicePath, attested, foreignTags } = req;\n  const id = req.elementId ?? serviceElementId(req.service);\n  // \"the fleet map (architecture/)\" rather than the landscape FILE: the map is\n  // the whole project, an element may be declared in any document of it, and\n  // LikeC4 hands back no source document for an element — so naming a file\n  // here would be a claim about bytes loam did not read. The write still lands\n  // in `architecture/landscape.likec4`; the target's `path` says so.\n  const opening =\n    `\\`${id}\\` in the fleet map (architecture/) resolves to ${servicePath}/ and no edge in the map touches it — ` +\n    `the service is drawn and invisible to every cross-service check.`;\n  const tags =\n    foreignTags.length === 0\n      ? \"\"\n      : ` The element carries ${foreignTags.map((t) => `#${t}`).join(\", \")} — tags loam does not read; if one marks a ` +\n        `placeholder drawn ahead of adoption, clearing it is part of this edit, because a view written ` +\n        `\\`exclude element.tag = #<that>\\` keeps an adopted service hidden.`;\n  if (attested.length > 0) {\n    // The edge form follows the calls' direction (`edgeTemplates`): this arm\n    // used to spell the outbound form alone, so an inbound call was carried\n    // up backwards.\n    const forms = edgeTemplates(id, attested)\n      .map((t) => `\\`${t}\\``)\n      .join(\" or \");\n    return (\n      `${opening} ${servicePath}/model.likec4 already declares ${attested.length} call(s) across its boundary: ` +\n      `${attested.map(spellCall).join(\", \")}. Carry each one up as ONE edge on \\`${id}\\`, collapsed to the ` +\n      `service — ${forms} for a call, \\`publishes\\`/\\`consumes\\` ` +\n      `for an event — naming the other party as the map already spells it; where the model's word names a ` +\n      `different thing in the map, say so in the hand-back instead of drawing it. Do not add a second element: ` +\n      `one already resolves. ${accountability(req, id)} Carry all of them up now, or say in the hand-back which ` +\n      `you did not and why.${tags}`\n    );\n  }\n  return (\n    `${opening} Nothing in ${servicePath}/model.likec4 attests a call across its boundary — absent, unparseable ` +\n    `and internal-only read alike here, because this brief may only name calls already attested. Draw the ones ` +\n    `the walk's outbound and message stops (stops 4 and 7) find, each as one edge on \\`${id}\\` carrying ` +\n    `\\`metadata { op '<operationId>' }\\` for a call or \\`publishes\\`/\\`consumes\\` for an event; if the service ` +\n    `genuinely makes and receives no call, draw NOTHING — an invented edge is a dependency the fleet then plans ` +\n    `against, and an edgeless element that is TRUE is a fact. Do not add a second element: one already resolves. ` +\n    `Nothing in \\`loam validate --all\\` names this state while the model attests no call; this brief is the only ` +\n    `place it is said.${tags}`\n  );\n}\n"]}