@ybotok/loam 0.2.0-alpha.1 → 0.2.0-alpha.13

package/dist/core/agent/agents-md/cycle.js

@@ -1,165 +0,0 @@
-/**
- * What an agent DOES: the cycle step by step, adopting a service, what is
- * authored versus derived, and the rules the validator enforces.
- *
- * The done-check itself is no longer here — it is `loam instructions
- * loam-done-check` (../workflows/reference/done-check.ts). Steps 4 and 7 used
- * to end `See "The requirement baseline"` and `See "The done-check"`, naming
- * headings that were further down this same file; they now name the COMMAND
- * that prints them. That is not a rewording for its own sake: a section
- * reference to a section that left is a pointer at nothing, and a reader who
- * scrolls looking for it concludes the file is truncated — which, on the two
- * hosts that truncate silently, is a conclusion they cannot check.
- *
- * One section of the AGENTS.md template. ../agents-md.ts assembles the
- * document by PLAIN CONCATENATION — no join separator — so every section
- * starts at the first character of its opening line and ends with the newline
- * that closes its last one. Keep that shape when editing, or two sections glue
- * onto one line in every docs repo loam scaffolds from now on.
- */
-export const CYCLE = `## The cycle
-
-0. **Wire the repo** — \`loam init --docs <path-to-docs-repo> --service <id>\` in
-   each service repo, then \`loam doctor\`. Once per repository, before anything
-   else; see "\`loam.json\` — the wiring" above. Every step below runs in a repo
-   that has been through this one.
-1. **Adopt** — a service with no documentation at all starts at
-   \`loam adopt --service <id> --json\`, which briefs you on the baseline to write.
-   See "Adopting a service" below. Once per service, not once per feature.
-2. **Understand** — \`loam status --json\` first if you joined halfway or lost the
-   session: it says what is in flight and what the next step is, for the fleet or
-   for one feature (\`loam status FEAT-101 --json\`). Then \`loam list --json\` and
-   \`loam show <service> --json\`.
-   Then \`loam explore <service> --json\` around the services you believe are
-   involved — it writes nothing and answers the one question the next step takes
-   as an argument: which services this change actually touches. It reports the
-   ring one hop out in the fleet map (\`neighbours\`), how far each service's
-   documentation has got (\`maturity\`), what each already exposes, the features
-   already in flight over the same ground (\`overlaps\`), and the \`loam new\` line
-   the seeds imply (\`scaffold\`). \`--op <operationId>\` seeds from an operation
-   when you know the call but not who owns it.
-   Never propose a change to a service you have not read.
-3. **Scaffold** — \`loam new FEAT-101 --title "..." --touches <existing> --new-service <new>\`.
-   The scaffold leaves a \`delta.likec4\` whose context elements are commented out —
-   a requirements-only feature should DELETE that file rather than ship an empty
-   one — and gives every \`--new-service\` a \`specs/<svc>/arch.spec.md\` alongside.
-   \`--capability <id>\` (repeatable, and it composes with \`--touches\`) scaffolds a
-   capability delta instead of a service one — the inversion of this step, for a
-   change whose BUSINESS side is what is known: open the promise that changes and
-   derive the service work from it. An id the fleet has never named is scaffolded
-   rather than refused, with the close spellings printed beside it; the archive
-   is what creates the living \`capabilities/<id>/spec.md\`.
-4. **Author** the four files the scaffold left as TODO: intent, delta.likec4,
-   a spec.md per service, an openapi.yaml per new service. Finish with
-   \`loam rebase FEAT-101\`: it pins every MODIFIED/REMOVED requirement and every
-   operation in the contract delta to the living version you wrote it against.
-   On the contract axis run it even when you changed nothing but one endpoint —
-   that is exactly what marks the REST of the document as quotation the merge
-   must not write. See \`loam instructions loam-spine\` — "The requirement baseline".
-5. **Check** — \`loam validate FEAT-101 --json\`. Fix every error before writing code.
-   \`loam dependencies --json\` says whether another feature in flight has to
-   archive first.
-6. **Build** — \`loam delta FEAT-101 --service <svc> --json\` is the task for one service:
-   intent, its requirement delta with scenarios verbatim, and the edges around it.
-   In the service's own repo, \`loam gherkin FEAT-101\` then emits those scenarios as
-   \`.feature\` files under \`<gherkinDir>/loam/\` — write step definitions against them
-   **first**, outside \`loam/\`, and implement until they pass.
-   If \`architecture.errors\` is non-empty the payload keeps \`ok: true\` (the command
-   ran) but the exit code is 1: the C4 slice is empty because delta.likec4 did not
-   parse, not because the feature changes no architecture — do not build on it.
-7. **Verify** — \`loam verify FEAT-101 --json\` turns the feature's own promises into a
-   checklist. The scenario claims are answered by the cucumber report
-   (\`--results report.json\`); answer the rest with evidence and record them
-   (\`--record answers.json --service <id>\`), **from each affected service's own
-   repo**. See \`loam instructions loam-done-check\`.
-8. **Ship** — \`loam archive FEAT-101\` once the code is merged. \`--dry-run\` shows
-   every file the merge would write, and writes none of them.
-
-## Adopting a service
-
-\`loam adopt --service <id>\` does not read code and never will. Nothing
-deterministic can look at a legacy service and say what its architecture MEANS,
-and a guessed model is worse than none: everybody downstream has to re-derive it
-to know whether to believe it. So loam takes the half of the job that is
-mechanical — stating the work, and checking the result — and you do the reading.
-
-The brief names every file to write, the grammar each must be in, what the
-landscape already says about the service (bind to those elements, do not draw a
-parallel fleet), the frontmatter, and the checks that follow. It also lists what
-**no** check will ever catch. Read that list: everything on it is a way to be
-wrong quietly, and \`loam validate\` passing means nothing about any of it.
-
-One of the targets is not under \`services/<id>/\`: \`architecture/landscape.likec4\`,
-the fleet map, carried with \`action: "edit"\` and a \`landscape.instruction\`
-spelling out the block this service owes it. That target appears only while
-nothing in the map resolves to the service. **Add to that file; never rewrite
-it** — every other service's elements and edges are in there. A service that is
-fully documented and undrawn is \`landscape.service-unmodelled\` (error) and is
-invisible to every cross-service check: no edge into it can be graded against
-its openapi.yaml, and no feature can draw a call to it.
-
-An adoption ends with two runs, not one: \`loam validate --service <id> --json\`
-for the baseline, then \`loam validate --all --json\` in the docs repo — the
-fleet cross-check the first invocation does not perform is exactly where a
-landscape edit that did not land shows up. Done, stated once: \`--service\`
-clean when run from inside the service's own repo, and \`--all\` reporting no
-\`landscape.*\` finding. The fleet run is never SILENT — \`sources.unverifiable-from-here\`
-(severity ok) appears per service as a confirmation, not work — so "keep going
-until validation is quiet" is the wrong loop; the two runs above are the test.
-
-Two rules the brief repeats and this file will too. An artifact that already
-exists is reported as \`action: "diff"\` — read it and report what disagrees;
-never replace it, because a document somebody wrote is evidence. And everything
-you write is \`status: draft\`: promotion is \`loam vouch\`, run by a person in the
-service's own repo — \`loam vouch --pack --service <id>\` (read-only) preps that read.
-
-## What you author, what loam derives
-
-Authored by hand: \`intent.md\`, \`delta.likec4\`, \`specs/<svc>/spec.md\`,
-\`specs/<svc>/arch.spec.md\`, \`specs/<svc>/openapi.yaml\`, ADRs, runbooks, health.
-
-Written by loam: the merge into \`services/<svc>/spec.md\`, \`services/<svc>/arch.spec.md\`,
-\`services/<svc>/openapi.yaml\` and \`architecture/landscape.likec4\` at archive time.
-
-**Do not hand-edit the living landscape to add a feature's changes.** Put them in a
-delta and archive it — otherwise the change has no intent, no requirement and no
-history behind it.
-
-## Rules the validator enforces
-
-- every requirement has at least one \`#### Scenario:\` — scenarios are the acceptance
-  criteria and the source for tests;
-- every operationId a requirement governs exists in that service's OpenAPI;
-- every C4 edge's \`op\` resolves to an operation the target actually exposes;
-- every operation is governed by some requirement (warning);
-- a "Calls" edge with no \`metadata { op }\` is unlinked (warning);
-- **the map is complete**: every \`services/<svc>/\` has an element in the landscape,
-  and every element that looks like a service has a directory (warning) or is
-  tagged \`#external\`;
-- **the diff applies**: a \`MODIFIED\` or \`REMOVED\` requirement exists in the living
-  spec, an \`ADDED\` one does not, and a section heading matches the grammar exactly;
-- a \`Requirement-ID: <id>\` is optional, but when present it is valid and unique;
-  archive selects by it, so carry the same ID through \`MODIFIED\` to rename a heading;
-- **every requirement in a delta is under a delta section**: one under a prose heading
-  (\`## Behavior\`) is documentation as far as the merge is concerned and is dropped
-  (warning). \`## Requirements\` is exempt — quoting the living state is legal.
-
-That last pair of rules exists because each of its failures used to be silent.
-\`MODIFIED\` of a requirement that does not exist merged as a creation; \`ADDED\` of one
-that does exist REPLACED it, scenarios and all; a near-miss heading like
-\`## ADDED Requirement\` (singular) parses as plain prose, so archive merged nothing and
-said nothing; and a requirement under \`## Behavior\` vanished the same way.
-
-Write the delta section heading on its own line exactly as \`## ADDED Requirements\`.
-The heading is the only thing that gives a requirement its kind: without a matching
-one, archive merges the requirement as nothing.
-
-Severity and gating are two different questions. An ERROR means the document is
-invalid — \`loam validate\` fails. A finding with \`gates: true\` means \`loam archive\`
-will refuse — the merge is unsafe. They usually agree (errors gate, warnings do
-not), and where they diverge the \`--json\` output says so: \`delta.requirement-not-merged\`
-is a warning (the shape is legal OpenSpec) that gates (the merge would drop the
-requirement). Leave a warning standing only deliberately.
-
-`;
-//# sourceMappingURL=cycle.js.map

package/dist/core/agent/agents-md/cycle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cycle.js","sourceRoot":"","sources":["../../../../src/core/agent/agents-md/cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJpB,CAAC","sourcesContent":["/**\n * What an agent DOES: the cycle step by step, adopting a service, what is\n * authored versus derived, and the rules the validator enforces.\n *\n * The done-check itself is no longer here — it is `loam instructions\n * loam-done-check` (../workflows/reference/done-check.ts). Steps 4 and 7 used\n * to end `See \"The requirement baseline\"` and `See \"The done-check\"`, naming\n * headings that were further down this same file; they now name the COMMAND\n * that prints them. That is not a rewording for its own sake: a section\n * reference to a section that left is a pointer at nothing, and a reader who\n * scrolls looking for it concludes the file is truncated — which, on the two\n * hosts that truncate silently, is a conclusion they cannot check.\n *\n * One section of the AGENTS.md template. ../agents-md.ts assembles the\n * document by PLAIN CONCATENATION — no join separator — so every section\n * starts at the first character of its opening line and ends with the newline\n * that closes its last one. Keep that shape when editing, or two sections glue\n * onto one line in every docs repo loam scaffolds from now on.\n */\nexport const CYCLE = `## The cycle\n\n0. **Wire the repo** — \\`loam init --docs <path-to-docs-repo> --service <id>\\` in\n   each service repo, then \\`loam doctor\\`. Once per repository, before anything\n   else; see \"\\`loam.json\\` — the wiring\" above. Every step below runs in a repo\n   that has been through this one.\n1. **Adopt** — a service with no documentation at all starts at\n   \\`loam adopt --service <id> --json\\`, which briefs you on the baseline to write.\n   See \"Adopting a service\" below. Once per service, not once per feature.\n2. **Understand** — \\`loam status --json\\` first if you joined halfway or lost the\n   session: it says what is in flight and what the next step is, for the fleet or\n   for one feature (\\`loam status FEAT-101 --json\\`). Then \\`loam list --json\\` and\n   \\`loam show <service> --json\\`.\n   Then \\`loam explore <service> --json\\` around the services you believe are\n   involved — it writes nothing and answers the one question the next step takes\n   as an argument: which services this change actually touches. It reports the\n   ring one hop out in the fleet map (\\`neighbours\\`), how far each service's\n   documentation has got (\\`maturity\\`), what each already exposes, the features\n   already in flight over the same ground (\\`overlaps\\`), and the \\`loam new\\` line\n   the seeds imply (\\`scaffold\\`). \\`--op <operationId>\\` seeds from an operation\n   when you know the call but not who owns it.\n   Never propose a change to a service you have not read.\n3. **Scaffold** — \\`loam new FEAT-101 --title \"...\" --touches <existing> --new-service <new>\\`.\n   The scaffold leaves a \\`delta.likec4\\` whose context elements are commented out —\n   a requirements-only feature should DELETE that file rather than ship an empty\n   one — and gives every \\`--new-service\\` a \\`specs/<svc>/arch.spec.md\\` alongside.\n   \\`--capability <id>\\` (repeatable, and it composes with \\`--touches\\`) scaffolds a\n   capability delta instead of a service one — the inversion of this step, for a\n   change whose BUSINESS side is what is known: open the promise that changes and\n   derive the service work from it. An id the fleet has never named is scaffolded\n   rather than refused, with the close spellings printed beside it; the archive\n   is what creates the living \\`capabilities/<id>/spec.md\\`.\n4. **Author** the four files the scaffold left as TODO: intent, delta.likec4,\n   a spec.md per service, an openapi.yaml per new service. Finish with\n   \\`loam rebase FEAT-101\\`: it pins every MODIFIED/REMOVED requirement and every\n   operation in the contract delta to the living version you wrote it against.\n   On the contract axis run it even when you changed nothing but one endpoint —\n   that is exactly what marks the REST of the document as quotation the merge\n   must not write. See \\`loam instructions loam-spine\\` — \"The requirement baseline\".\n5. **Check** — \\`loam validate FEAT-101 --json\\`. Fix every error before writing code.\n   \\`loam dependencies --json\\` says whether another feature in flight has to\n   archive first.\n6. **Build** — \\`loam delta FEAT-101 --service <svc> --json\\` is the task for one service:\n   intent, its requirement delta with scenarios verbatim, and the edges around it.\n   In the service's own repo, \\`loam gherkin FEAT-101\\` then emits those scenarios as\n   \\`.feature\\` files under \\`<gherkinDir>/loam/\\` — write step definitions against them\n   **first**, outside \\`loam/\\`, and implement until they pass.\n   If \\`architecture.errors\\` is non-empty the payload keeps \\`ok: true\\` (the command\n   ran) but the exit code is 1: the C4 slice is empty because delta.likec4 did not\n   parse, not because the feature changes no architecture — do not build on it.\n7. **Verify** — \\`loam verify FEAT-101 --json\\` turns the feature's own promises into a\n   checklist. The scenario claims are answered by the cucumber report\n   (\\`--results report.json\\`); answer the rest with evidence and record them\n   (\\`--record answers.json --service <id>\\`), **from each affected service's own\n   repo**. See \\`loam instructions loam-done-check\\`.\n8. **Ship** — \\`loam archive FEAT-101\\` once the code is merged. \\`--dry-run\\` shows\n   every file the merge would write, and writes none of them.\n\n## Adopting a service\n\n\\`loam adopt --service <id>\\` does not read code and never will. Nothing\ndeterministic can look at a legacy service and say what its architecture MEANS,\nand a guessed model is worse than none: everybody downstream has to re-derive it\nto know whether to believe it. So loam takes the half of the job that is\nmechanical — stating the work, and checking the result — and you do the reading.\n\nThe brief names every file to write, the grammar each must be in, what the\nlandscape already says about the service (bind to those elements, do not draw a\nparallel fleet), the frontmatter, and the checks that follow. It also lists what\n**no** check will ever catch. Read that list: everything on it is a way to be\nwrong quietly, and \\`loam validate\\` passing means nothing about any of it.\n\nOne of the targets is not under \\`services/<id>/\\`: \\`architecture/landscape.likec4\\`,\nthe fleet map, carried with \\`action: \"edit\"\\` and a \\`landscape.instruction\\`\nspelling out the block this service owes it. That target appears only while\nnothing in the map resolves to the service. **Add to that file; never rewrite\nit** — every other service's elements and edges are in there. A service that is\nfully documented and undrawn is \\`landscape.service-unmodelled\\` (error) and is\ninvisible to every cross-service check: no edge into it can be graded against\nits openapi.yaml, and no feature can draw a call to it.\n\nAn adoption ends with two runs, not one: \\`loam validate --service <id> --json\\`\nfor the baseline, then \\`loam validate --all --json\\` in the docs repo — the\nfleet cross-check the first invocation does not perform is exactly where a\nlandscape edit that did not land shows up. Done, stated once: \\`--service\\`\nclean when run from inside the service's own repo, and \\`--all\\` reporting no\n\\`landscape.*\\` finding. The fleet run is never SILENT — \\`sources.unverifiable-from-here\\`\n(severity ok) appears per service as a confirmation, not work — so \"keep going\nuntil validation is quiet\" is the wrong loop; the two runs above are the test.\n\nTwo rules the brief repeats and this file will too. An artifact that already\nexists is reported as \\`action: \"diff\"\\` — read it and report what disagrees;\nnever replace it, because a document somebody wrote is evidence. And everything\nyou write is \\`status: draft\\`: promotion is \\`loam vouch\\`, run by a person in the\nservice's own repo — \\`loam vouch --pack --service <id>\\` (read-only) preps that read.\n\n## What you author, what loam derives\n\nAuthored by hand: \\`intent.md\\`, \\`delta.likec4\\`, \\`specs/<svc>/spec.md\\`,\n\\`specs/<svc>/arch.spec.md\\`, \\`specs/<svc>/openapi.yaml\\`, ADRs, runbooks, health.\n\nWritten by loam: the merge into \\`services/<svc>/spec.md\\`, \\`services/<svc>/arch.spec.md\\`,\n\\`services/<svc>/openapi.yaml\\` and \\`architecture/landscape.likec4\\` at archive time.\n\n**Do not hand-edit the living landscape to add a feature's changes.** Put them in a\ndelta and archive it — otherwise the change has no intent, no requirement and no\nhistory behind it.\n\n## Rules the validator enforces\n\n- every requirement has at least one \\`#### Scenario:\\` — scenarios are the acceptance\n  criteria and the source for tests;\n- every operationId a requirement governs exists in that service's OpenAPI;\n- every C4 edge's \\`op\\` resolves to an operation the target actually exposes;\n- every operation is governed by some requirement (warning);\n- a \"Calls\" edge with no \\`metadata { op }\\` is unlinked (warning);\n- **the map is complete**: every \\`services/<svc>/\\` has an element in the landscape,\n  and every element that looks like a service has a directory (warning) or is\n  tagged \\`#external\\`;\n- **the diff applies**: a \\`MODIFIED\\` or \\`REMOVED\\` requirement exists in the living\n  spec, an \\`ADDED\\` one does not, and a section heading matches the grammar exactly;\n- a \\`Requirement-ID: <id>\\` is optional, but when present it is valid and unique;\n  archive selects by it, so carry the same ID through \\`MODIFIED\\` to rename a heading;\n- **every requirement in a delta is under a delta section**: one under a prose heading\n  (\\`## Behavior\\`) is documentation as far as the merge is concerned and is dropped\n  (warning). \\`## Requirements\\` is exempt — quoting the living state is legal.\n\nThat last pair of rules exists because each of its failures used to be silent.\n\\`MODIFIED\\` of a requirement that does not exist merged as a creation; \\`ADDED\\` of one\nthat does exist REPLACED it, scenarios and all; a near-miss heading like\n\\`## ADDED Requirement\\` (singular) parses as plain prose, so archive merged nothing and\nsaid nothing; and a requirement under \\`## Behavior\\` vanished the same way.\n\nWrite the delta section heading on its own line exactly as \\`## ADDED Requirements\\`.\nThe heading is the only thing that gives a requirement its kind: without a matching\none, archive merges the requirement as nothing.\n\nSeverity and gating are two different questions. An ERROR means the document is\ninvalid — \\`loam validate\\` fails. A finding with \\`gates: true\\` means \\`loam archive\\`\nwill refuse — the merge is unsafe. They usually agree (errors gate, warnings do\nnot), and where they diverge the \\`--json\\` output says so: \\`delta.requirement-not-merged\\`\nis a warning (the shape is legal OpenSpec) that gates (the merge would drop the\nrequirement). Leave a warning standing only deliberately.\n\n`;\n"]}

package/dist/core/agent/agents-md/shipped/archive-gate.js

@@ -1,98 +0,0 @@
-/**
- * How a SHIPPED change is gated, undone or dropped: the archive gate,
- * unarchive, and dropping a feature. The continuation of ../refusals.ts —
- * that module holds what loam refuses and the error-envelope codes; this one
- * holds what happens to a feature once the merge is on the table. Split
- * there because the two subjects were one 300-plus-line file, and the file's
- * own header already named them separately.
- *
- * One section of the AGENTS.md template. ../../agents-md.ts assembles the
- * document by PLAIN CONCATENATION — no join separator — so this section
- * starts at the first character of its opening heading and ends with the
- * newline that closes its last line. Keep that shape when editing, or two
- * sections glue onto one line in every docs repo loam scaffolds from now on.
- */
-export const ARCHIVE_GATE = `## The archive gate
-
-The three axes agreeing is called **coherence**, and \`loam validate --feature\` reports
-it as such. \`loam archive\` runs the same coherence check first and refuses a feature
-with GATING issues — every error, plus the rare warning marked \`gates: true\` because
-the merge would silently drop authored content even though the document is legal.
-Advisory warnings never block: archive prints them and proceeds. Each one still names
-something real — usually something the merge will drop or overwrite — so read them
-before the merge runs, not after.
-
-\`--approve\` overrides the gating issues — only those, and archive prints exactly which
-ones it overrode. It is a human decision, not an agent's: if archive refuses, fix the
-breach or hand it back. Two refusals sit outside its reach, because the damage is
-mechanical rather than a judgment about the feature: \`delta.service-id-invalid\` — a
-\`specs/<svc>/\` directory whose name is not a legal service id, which the merge
-would materialise as a \`services/<svc>/\` every loam command then refuses to
-address — and \`c4.service-binding-invalid\` — an explicit \`metadata { service }\`
-binding that breaks the same grammar, on a tagged element or anything nested
-inside its block (the merge splices the whole authored block into the living
-landscape verbatim, untagged children included, and a \`../\` in the binding even
-collapses the archive's \`services/\` probe out of the docs repo). There is
-nothing a judgment call could accept: rename the directory, or fix the binding,
-instead.
-
-Breaches only the merge computation itself can see are reported at plan time,
-after the gate. \`living.requirement-outside-requirements\` (error): the LIVING spec
-holds a requirement outside \`## Requirements\`, and the merge rewrites only that
-section, so the requirement would land in the file twice — \`--approve\` does not
-override it, because the duplication is mechanical, not a judgment call; re-home the
-requirement first. \`openapi.op-modified\` (warn): the feature redefines an operation
-the living OpenAPI already has, and the merge overwrites the living definition
-wholesale.
-
-The OpenAPI merge also carries a \`$ref\` closure rooted in what it actually WROTE
-— the merged operations and the components this delta declares alike: every
-\`#/components/<kind>/<name>\` they reference, recursively with a component's own
-refs included, is copied from the feature document into the living one, so nothing
-lands pointing at a schema that stayed behind. A delta whose whole change is a
-shared schema, with no \`paths\` at all, is merged the same way and by the same
-rules. \`openapi.component-modified\` (warn): a carried component overwrites a
-living one that differs, wholesale, same discipline as an operation.
-\`openapi.ref-unresolved\` (error, \`--approve\` overrides): a ref reachable from the
-merged operations or a merged component resolves in neither document, so merging
-would write a dangling reference. External refs — URLs, file paths, anything not
-starting \`#/\` — are out of scope: left untouched, never gated.
-
-## Taking an archive back
-
-\`loam unarchive <FEAT>\` restores the living docs and re-opens the feature. It works
-by putting bytes back, not by inverting the merge — archive copies every file it is
-about to overwrite into \`features/archive/<FEAT>/.loam-before/\` first, because the
-previous text of a \`MODIFIED\` requirement is written down nowhere else. Do not edit
-or delete that directory, and never reconstruct an old living spec by hand from an
-archived delta: what the requirement said BEFORE is not in there, and a plausible
-reconstruction is a lie the next reader has no way to catch.
-
-Every pre-image is digested when the archive writes it, and re-checked before the
-restore stages anything: \`snapshot-corrupt\` means a pre-image's bytes no longer
-match the digest archive recorded for them, so restoring it would write text
-nobody authored. \`--force\` does NOT override that one — the damage is to the
-undo itself, not to the living docs — and the fix is version control.
-
-It refuses rather than guesses, under codes you can branch on: \`feature-active\` (a
-feature of that id is in flight again), \`snapshot-missing\` (archived before loam
-recorded this — the docs have to come back from version control), \`snapshot-stale\`
-(a merged file changed after the archive, so restoring would revert someone else's
-work). \`--force\` overrides the last one, and like \`--approve\` it is a human's call.
-
-A restore that fails outright splits the same way archive's does: \`restore-failed\`
-means nothing was restored or everything was rolled back — the living docs are
-unchanged, fix the reported cause and re-run; \`rollback-incomplete\` means the
-restore failed AND some files could not be put back — stop and hand it to a human,
-the message lists the files to check.
-
-## Dropping a feature
-
-A feature that was never archived is one directory and nothing else: no living doc
-references it until \`loam archive\` merges it. To abandon it, delete the directory —
-\`git rm -r features/<FEAT-dir>\` — and version control keeps the record of the
-attempt. An ARCHIVED feature is the opposite, its content folded into the living
-docs: run \`loam unarchive <FEAT>\` first, then delete. There is no \`loam abandon\`,
-deliberately — a removal that computes nothing is what version control is for.
-`;
-//# sourceMappingURL=archive-gate.js.map

package/dist/core/agent/agents-md/shipped/archive-gate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"archive-gate.js","sourceRoot":"","sources":["../../../../../src/core/agent/agents-md/shipped/archive-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF3B,CAAC","sourcesContent":["/**\n * How a SHIPPED change is gated, undone or dropped: the archive gate,\n * unarchive, and dropping a feature. The continuation of ../refusals.ts —\n * that module holds what loam refuses and the error-envelope codes; this one\n * holds what happens to a feature once the merge is on the table. Split\n * there because the two subjects were one 300-plus-line file, and the file's\n * own header already named them separately.\n *\n * One section of the AGENTS.md template. ../../agents-md.ts assembles the\n * document by PLAIN CONCATENATION — no join separator — so this section\n * starts at the first character of its opening heading and ends with the\n * newline that closes its last line. Keep that shape when editing, or two\n * sections glue onto one line in every docs repo loam scaffolds from now on.\n */\nexport const ARCHIVE_GATE = `## The archive gate\n\nThe three axes agreeing is called **coherence**, and \\`loam validate --feature\\` reports\nit as such. \\`loam archive\\` runs the same coherence check first and refuses a feature\nwith GATING issues — every error, plus the rare warning marked \\`gates: true\\` because\nthe merge would silently drop authored content even though the document is legal.\nAdvisory warnings never block: archive prints them and proceeds. Each one still names\nsomething real — usually something the merge will drop or overwrite — so read them\nbefore the merge runs, not after.\n\n\\`--approve\\` overrides the gating issues — only those, and archive prints exactly which\nones it overrode. It is a human decision, not an agent's: if archive refuses, fix the\nbreach or hand it back. Two refusals sit outside its reach, because the damage is\nmechanical rather than a judgment about the feature: \\`delta.service-id-invalid\\` — a\n\\`specs/<svc>/\\` directory whose name is not a legal service id, which the merge\nwould materialise as a \\`services/<svc>/\\` every loam command then refuses to\naddress — and \\`c4.service-binding-invalid\\` — an explicit \\`metadata { service }\\`\nbinding that breaks the same grammar, on a tagged element or anything nested\ninside its block (the merge splices the whole authored block into the living\nlandscape verbatim, untagged children included, and a \\`../\\` in the binding even\ncollapses the archive's \\`services/\\` probe out of the docs repo). There is\nnothing a judgment call could accept: rename the directory, or fix the binding,\ninstead.\n\nBreaches only the merge computation itself can see are reported at plan time,\nafter the gate. \\`living.requirement-outside-requirements\\` (error): the LIVING spec\nholds a requirement outside \\`## Requirements\\`, and the merge rewrites only that\nsection, so the requirement would land in the file twice — \\`--approve\\` does not\noverride it, because the duplication is mechanical, not a judgment call; re-home the\nrequirement first. \\`openapi.op-modified\\` (warn): the feature redefines an operation\nthe living OpenAPI already has, and the merge overwrites the living definition\nwholesale.\n\nThe OpenAPI merge also carries a \\`$ref\\` closure rooted in what it actually WROTE\n— the merged operations and the components this delta declares alike: every\n\\`#/components/<kind>/<name>\\` they reference, recursively with a component's own\nrefs included, is copied from the feature document into the living one, so nothing\nlands pointing at a schema that stayed behind. A delta whose whole change is a\nshared schema, with no \\`paths\\` at all, is merged the same way and by the same\nrules. \\`openapi.component-modified\\` (warn): a carried component overwrites a\nliving one that differs, wholesale, same discipline as an operation.\n\\`openapi.ref-unresolved\\` (error, \\`--approve\\` overrides): a ref reachable from the\nmerged operations or a merged component resolves in neither document, so merging\nwould write a dangling reference. External refs — URLs, file paths, anything not\nstarting \\`#/\\` — are out of scope: left untouched, never gated.\n\n## Taking an archive back\n\n\\`loam unarchive <FEAT>\\` restores the living docs and re-opens the feature. It works\nby putting bytes back, not by inverting the merge — archive copies every file it is\nabout to overwrite into \\`features/archive/<FEAT>/.loam-before/\\` first, because the\nprevious text of a \\`MODIFIED\\` requirement is written down nowhere else. Do not edit\nor delete that directory, and never reconstruct an old living spec by hand from an\narchived delta: what the requirement said BEFORE is not in there, and a plausible\nreconstruction is a lie the next reader has no way to catch.\n\nEvery pre-image is digested when the archive writes it, and re-checked before the\nrestore stages anything: \\`snapshot-corrupt\\` means a pre-image's bytes no longer\nmatch the digest archive recorded for them, so restoring it would write text\nnobody authored. \\`--force\\` does NOT override that one — the damage is to the\nundo itself, not to the living docs — and the fix is version control.\n\nIt refuses rather than guesses, under codes you can branch on: \\`feature-active\\` (a\nfeature of that id is in flight again), \\`snapshot-missing\\` (archived before loam\nrecorded this — the docs have to come back from version control), \\`snapshot-stale\\`\n(a merged file changed after the archive, so restoring would revert someone else's\nwork). \\`--force\\` overrides the last one, and like \\`--approve\\` it is a human's call.\n\nA restore that fails outright splits the same way archive's does: \\`restore-failed\\`\nmeans nothing was restored or everything was rolled back — the living docs are\nunchanged, fix the reported cause and re-run; \\`rollback-incomplete\\` means the\nrestore failed AND some files could not be put back — stop and hand it to a human,\nthe message lists the files to check.\n\n## Dropping a feature\n\nA feature that was never archived is one directory and nothing else: no living doc\nreferences it until \\`loam archive\\` merges it. To abandon it, delete the directory —\n\\`git rm -r features/<FEAT-dir>\\` — and version control keeps the record of the\nattempt. An ARCHIVED feature is the opposite, its content folded into the living\ndocs: run \\`loam unarchive <FEAT>\\` first, then delete. There is no \\`loam abandon\\`,\ndeliberately — a removal that computes nothing is what version control is for.\n`;\n"]}

package/dist/core/agent/agents-md/spine.js

@@ -1,40 +0,0 @@
-/**
- * Which element in the C4 model IS which service — the binding rule, and the
- * two-way completeness check `loam validate --all` runs over `services/`.
- *
- * This module used to carry the whole ID spine: every join between the
- * artifacts, the `Based-On:` baseline pins, how to draw a shared broker, and
- * how to declare a message produced outside the fleet. Those are now the
- * `loam-spine` reference page (../workflows/reference/spine.ts), printed by
- * `loam instructions loam-spine` — grammars a reader consults while writing one
- * document, in a file that was being truncated by two hosts before it reached
- * them (./command-map.ts's header has the measurement).
- *
- * THIS section stayed, and the line between it and the page it lost is worth
- * saying: an agent cannot read the landscape at all without knowing that a box's
- * title is its service id unless `metadata { service }` says otherwise. It is
- * orientation, not reference — it is needed to form the question, not to answer
- * it.
- *
- * One section of the AGENTS.md template. ../agents-md.ts assembles the
- * document by PLAIN CONCATENATION — no join separator — so every section
- * starts at the first character of its opening line and ends with the newline
- * that closes its last one. Keep that shape when editing, or two sections glue
- * onto one line in every docs repo loam scaffolds from now on.
- */
-export const SPINE = `## Which element IS which service
-
-An element says which service it is with \`metadata { service 'payment-service' }\`.
-Without one, its **title** is used instead — which is what most of this repo relies
-on, and also the trap: rename a box in a diagram and every check joining it to
-\`services/<svc>/\` silently stops matching. Bind an element whenever its title is
-not exactly the directory name, and prefer binding over renaming a directory.
-
-\`services/\` is the list of services — there is no manifest, and none should be
-added. \`loam validate --all\` compares that list to the landscape both ways: a
-directory nothing draws is an error, and an element with no directory is a warning.
-Systems that are not ours — kafka, a payment gateway — carry \`#external\`, which
-says so once and stops the warning for good.
-
-`;
-//# sourceMappingURL=spine.js.map

package/dist/core/agent/agents-md/spine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"spine.js","sourceRoot":"","sources":["../../../../src/core/agent/agents-md/spine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;;;;;;;;;;;;;;CAcpB,CAAC","sourcesContent":["/**\n * Which element in the C4 model IS which service — the binding rule, and the\n * two-way completeness check `loam validate --all` runs over `services/`.\n *\n * This module used to carry the whole ID spine: every join between the\n * artifacts, the `Based-On:` baseline pins, how to draw a shared broker, and\n * how to declare a message produced outside the fleet. Those are now the\n * `loam-spine` reference page (../workflows/reference/spine.ts), printed by\n * `loam instructions loam-spine` — grammars a reader consults while writing one\n * document, in a file that was being truncated by two hosts before it reached\n * them (./command-map.ts's header has the measurement).\n *\n * THIS section stayed, and the line between it and the page it lost is worth\n * saying: an agent cannot read the landscape at all without knowing that a box's\n * title is its service id unless `metadata { service }` says otherwise. It is\n * orientation, not reference — it is needed to form the question, not to answer\n * it.\n *\n * One section of the AGENTS.md template. ../agents-md.ts assembles the\n * document by PLAIN CONCATENATION — no join separator — so every section\n * starts at the first character of its opening line and ends with the newline\n * that closes its last one. Keep that shape when editing, or two sections glue\n * onto one line in every docs repo loam scaffolds from now on.\n */\nexport const SPINE = `## Which element IS which service\n\nAn element says which service it is with \\`metadata { service 'payment-service' }\\`.\nWithout one, its **title** is used instead — which is what most of this repo relies\non, and also the trap: rename a box in a diagram and every check joining it to\n\\`services/<svc>/\\` silently stops matching. Bind an element whenever its title is\nnot exactly the directory name, and prefer binding over renaming a directory.\n\n\\`services/\\` is the list of services — there is no manifest, and none should be\nadded. \\`loam validate --all\\` compares that list to the landscape both ways: a\ndirectory nothing draws is an error, and an element with no directory is a warning.\nSystems that are not ours — kafka, a payment gateway — carry \\`#external\\`, which\nsays so once and stops the warning for good.\n\n`;\n"]}

package/dist/core/coherence/events/merged.js

@@ -1,40 +0,0 @@
-/**
- * The contract as the feature would leave it: the REAL merge
- * (core/asyncapi/merge/merge.ts) run over the two texts and read back,
- * nothing written. One simulation feeds two gate questions — the
- * `declares()` join in ./events.ts (a retired or edited-away send must stop
- * answering "the service declares this" BEFORE archive, or a leftover
- * `Publishes:` line passes the gate and breaks the post-archive fleet) and
- * the consumer gate's wire half (a channel or operation removal that stops
- * the service SENDING a message the fleet still consumes).
- *
- * Calling the merge rather than re-deriving its verdicts is the point: a
- * second spelling of quote/edit/removal here would eventually disagree with
- * the merge about what archive actually writes, and the gate would be
- * promising a contract the archive does not produce.
- */
-import { parse } from "yaml";
-import { asyncapiDocOf } from "../../asyncapi/read.js";
-import { AsyncapiMergeError } from "../../asyncapi/merge/error.js";
-import { mergeAsyncapiSlots } from "../../asyncapi/merge/merge.js";
-/**
- * Simulate the archive-time merge, or stand down. Both documents are known
- * readable here (the walk in ./declared.ts checked), so the only refusals
- * left are the merge's own judgement calls — an aliased section, a section
- * spelling one slot key twice. `undefined` on those rather than a throw: the
- * caller falls back to the feature ∪ living union view, which can only be
- * too lenient, and the archive's own plan will surface the refusal by name.
- */
-export function mergedAsyncapiDoc(input) {
-    const { livingText, livingDoc, featureText, service } = input;
-    try {
-        const out = mergeAsyncapiSlots(livingText, featureText, service);
-        return out.text === null ? livingDoc : asyncapiDocOf(parse(out.text));
-    }
-    catch (error) {
-        if (error instanceof AsyncapiMergeError)
-            return undefined;
-        throw error;
-    }
-}
-//# sourceMappingURL=merged.js.map

package/dist/core/coherence/events/merged.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merged.js","sourceRoot":"","sources":["../../../../src/core/coherence/events/merged.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAWnE;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAA2B;IAC3D,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAC9D,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,kBAAkB,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QACjE,OAAO,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACxE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,kBAAkB;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["/**\n * The contract as the feature would leave it: the REAL merge\n * (core/asyncapi/merge/merge.ts) run over the two texts and read back,\n * nothing written. One simulation feeds two gate questions — the\n * `declares()` join in ./events.ts (a retired or edited-away send must stop\n * answering \"the service declares this\" BEFORE archive, or a leftover\n * `Publishes:` line passes the gate and breaks the post-archive fleet) and\n * the consumer gate's wire half (a channel or operation removal that stops\n * the service SENDING a message the fleet still consumes).\n *\n * Calling the merge rather than re-deriving its verdicts is the point: a\n * second spelling of quote/edit/removal here would eventually disagree with\n * the merge about what archive actually writes, and the gate would be\n * promising a contract the archive does not produce.\n */\nimport { parse } from \"yaml\";\nimport { asyncapiDocOf } from \"../../asyncapi/read.js\";\nimport type { AsyncapiDoc } from \"../../asyncapi/model.js\";\nimport { AsyncapiMergeError } from \"../../asyncapi/merge/error.js\";\nimport { mergeAsyncapiSlots } from \"../../asyncapi/merge/merge.js\";\n\n/** The two texts the simulation merges, plus the living side's existing parse. */\nexport interface MergeSimulationInput {\n  livingText: string;\n  /** `readAsyncapi` of livingText — reused verbatim when the merge writes nothing. */\n  livingDoc: AsyncapiDoc;\n  featureText: string;\n  service: string;\n}\n\n/**\n * Simulate the archive-time merge, or stand down. Both documents are known\n * readable here (the walk in ./declared.ts checked), so the only refusals\n * left are the merge's own judgement calls — an aliased section, a section\n * spelling one slot key twice. `undefined` on those rather than a throw: the\n * caller falls back to the feature ∪ living union view, which can only be\n * too lenient, and the archive's own plan will surface the refusal by name.\n */\nexport function mergedAsyncapiDoc(input: MergeSimulationInput): AsyncapiDoc | undefined {\n  const { livingText, livingDoc, featureText, service } = input;\n  try {\n    const out = mergeAsyncapiSlots(livingText, featureText, service);\n    return out.text === null ? livingDoc : asyncapiDocOf(parse(out.text));\n  } catch (error) {\n    if (error instanceof AsyncapiMergeError) return undefined;\n    throw error;\n  }\n}\n"]}

package/dist/core/diff/current-state.js

@@ -1,96 +0,0 @@
-/**
- * The working-tree side of `loam diff`: the fleet as it stands on disk, read
- * through the invocation's `FleetContext` into the SAME `ServiceState` shape
- * `./base-state.ts` builds from git — one shape, so `./semantic.ts` joins the
- * two sides without caring which one came from the object store.
- *
- * Containment discipline, per subject and per axis: an artifact that EXISTS
- * but cannot be read (non-UTF-8 spec bytes, a directory sitting where a file
- * belongs, broken contract YAML) degrades that one axis to `unreadable` with
- * its path — never a thrown enumeration, never an empty list a diff would
- * read as "everything was removed". Absence stays absence: a file deleted
- * between the existence probe and the read is classified by its errno
- * (ENOENT), the same TOCTOU discipline `loadConfig` documents.
- */
-import { existsSync } from "node:fs";
-import { repoPath } from "../envelope/json.js";
-import { servicePathsAt } from "../repo/paths.js";
-import { inOrder } from "../kernel/concurrency.js";
-function readFailure(e, rel) {
-    const errno = e;
-    if (errno.code === "ENOENT")
-        return { kind: "absent" };
-    return { kind: "unreadable", path: rel, error: e instanceof Error ? e.message : String(e) };
-}
-/** One spec-axis file (`spec.md` / `arch.spec.md`) as parsed requirements. */
-async function requirementsAxis(context, abs, rel) {
-    if (!existsSync(abs))
-        return { kind: "absent" };
-    try {
-        return { kind: "read", value: await context.readRequirements(abs) };
-    }
-    catch (e) {
-        // decodeDocument's non-UTF-8 refusal lands here too: bytes that would
-        // parse as zero requirements must suspend the axis, not empty it.
-        return readFailure(e, rel);
-    }
-}
-async function openapiAxis(context, abs, rel) {
-    if (!existsSync(abs))
-        return { kind: "absent" };
-    try {
-        const doc = await context.readOpenapi(abs);
-        return doc.unreadable
-            ? { kind: "unreadable", path: rel, error: doc.error ?? "not a readable OpenAPI document" }
-            : { kind: "read", value: doc.ops.filter((op) => !op.remove) };
-    }
-    catch (e) {
-        return readFailure(e, rel);
-    }
-}
-async function asyncapiAxis(context, abs, rel) {
-    if (!existsSync(abs))
-        return { kind: "absent" };
-    try {
-        const doc = await context.readAsyncapi(abs);
-        return doc.unreadable
-            ? { kind: "unreadable", path: rel, error: doc.error ?? "not a readable AsyncAPI document" }
-            : { kind: "read", value: doc.messages.filter((m) => m.remove !== true) };
-    }
-    catch (e) {
-        return readFailure(e, rel);
-    }
-}
-/**
- * The current fleet, one `ServiceState` per enumerated service. The
- * enumeration itself (the tree walk) may throw `DocsRepoUnavailableError` —
- * that is the whole-repo refusal `docsRepoReady` fronts, not a per-subject
- * degradation, and it stays a throw for the command layer to map.
- */
-export async function readCurrentFleet(docsDir, context) {
-    const entries = await context.listServices(docsDir);
-    const states = await inOrder(entries, async (entry) => {
-        const paths = servicePathsAt(entry.dir);
-        return {
-            id: entry.id,
-            dir: repoPath(docsDir, entry.dir),
-            spec: await requirementsAxis(context, paths.spec, repoPath(docsDir, paths.spec)),
-            archSpec: await requirementsAxis(context, paths.archSpec, repoPath(docsDir, paths.archSpec)),
-            openapi: await openapiAxis(context, paths.openapi, repoPath(docsDir, paths.openapi)),
-            asyncapi: await asyncapiAxis(context, paths.asyncapi, repoPath(docsDir, paths.asyncapi)),
-        };
-    });
-    const ambiguous = currentCollisions(states);
-    return {
-        services: new Map(states.filter((s) => !ambiguous.has(s.id)).map((s) => [s.id, s])),
-        ambiguous,
-    };
-}
-/** Ids claimed by more than one enumerated directory, with every claimant named. */
-function currentCollisions(states) {
-    const byId = new Map();
-    for (const s of states)
-        byId.set(s.id, [...(byId.get(s.id) ?? []), s.dir]);
-    return new Map([...byId].filter(([, dirs]) => dirs.length > 1));
-}
-//# sourceMappingURL=current-state.js.map

package/dist/core/diff/current-state.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"current-state.js","sourceRoot":"","sources":["../../../src/core/diff/current-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAkBnD,SAAS,WAAW,CAAC,CAAU,EAAE,GAAW;IAC1C,MAAM,KAAK,GAAG,CAA0B,CAAC;IACzC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IACvD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AAC9F,CAAC;AAED,8EAA8E;AAC9E,KAAK,UAAU,gBAAgB,CAAC,OAAqB,EAAE,GAAW,EAAE,GAAW;IAC7E,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAChD,IAAI,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;IACtE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,sEAAsE;QACtE,kEAAkE;QAClE,OAAO,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,KAAK,UAAU,WAAW,CAAC,OAAqB,EAAE,GAAW,EAAE,GAAW;IACxE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAChD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAC3C,OAAO,GAAG,CAAC,UAAU;YACnB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,IAAI,iCAAiC,EAAE;YAC1F,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;IAClE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,KAAK,UAAU,YAAY,CAAC,OAAqB,EAAE,GAAW,EAAE,GAAW;IACzE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAChD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAC5C,OAAO,GAAG,CAAC,UAAU;YACnB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,IAAI,kCAAkC,EAAE;YAC3F,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,EAAE,CAAC;IAC7E,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7B,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,OAAgB,EAAE,OAAqB;IAC5E,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAyB,EAAE;QAC3E,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,OAAO;YACL,EAAE,EAAE,KAAK,CAAC,EAAE;YACZ,GAAG,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC;YACjC,IAAI,EAAE,MAAM,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YAChF,QAAQ,EAAE,MAAM,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC5F,OAAO,EAAE,MAAM,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YACpF,QAAQ,EAAE,MAAM,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;SACzF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC5C,OAAO;QACL,QAAQ,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACnF,SAAS;KACV,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,SAAS,iBAAiB,CAAC,MAA+B;IACxD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAoB,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,MAAM;QAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3E,OAAO,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * The working-tree side of `loam diff`: the fleet as it stands on disk, read\n * through the invocation's `FleetContext` into the SAME `ServiceState` shape\n * `./base-state.ts` builds from git — one shape, so `./semantic.ts` joins the\n * two sides without caring which one came from the object store.\n *\n * Containment discipline, per subject and per axis: an artifact that EXISTS\n * but cannot be read (non-UTF-8 spec bytes, a directory sitting where a file\n * belongs, broken contract YAML) degrades that one axis to `unreadable` with\n * its path — never a thrown enumeration, never an empty list a diff would\n * read as \"everything was removed\". Absence stays absence: a file deleted\n * between the existence probe and the read is classified by its errno\n * (ENOENT), the same TOCTOU discipline `loadConfig` documents.\n */\nimport { existsSync } from \"node:fs\";\nimport type { Requirement } from \"../document/spec.js\";\nimport type { Operation } from \"../openapi/doc.js\";\nimport type { EventMessage } from \"../asyncapi/model.js\";\nimport { repoPath } from \"../envelope/json.js\";\nimport { servicePathsAt } from \"../repo/paths.js\";\nimport { inOrder } from \"../kernel/concurrency.js\";\nimport type { DocsDir } from \"../kernel/ids/dirs.js\";\nimport type { FleetContext } from \"../fleet-context.js\";\nimport type { AxisState, ServiceState } from \"./base-state.js\";\n\nexport interface CurrentFleet {\n  /** By service id, in the enumeration's (sorted-walk) order. Ids the `ambiguous` map claims are excluded. */\n  services: Map<string, ServiceState>;\n  /**\n   * Ids more than one working-tree directory claims — `subsystem.name-collision`'s\n   * live shape, which validate diagnoses. Diffing either claimant would pick a\n   * winner nobody chose (a `new Map` collapse here used to keep the LAST one and\n   * fabricate a whole change story about a service that never moved), so the\n   * subject is suspended exactly as the base side's `ambiguous` map suspends it.\n   */\n  ambiguous: Map<string, string[]>;\n}\n\nfunction readFailure(e: unknown, rel: string): { kind: \"absent\" } | { kind: \"unreadable\"; path: string; error: string } {\n  const errno = e as NodeJS.ErrnoException;\n  if (errno.code === \"ENOENT\") return { kind: \"absent\" };\n  return { kind: \"unreadable\", path: rel, error: e instanceof Error ? e.message : String(e) };\n}\n\n/** One spec-axis file (`spec.md` / `arch.spec.md`) as parsed requirements. */\nasync function requirementsAxis(context: FleetContext, abs: string, rel: string): Promise<AxisState<Requirement[]>> {\n  if (!existsSync(abs)) return { kind: \"absent\" };\n  try {\n    return { kind: \"read\", value: await context.readRequirements(abs) };\n  } catch (e) {\n    // decodeDocument's non-UTF-8 refusal lands here too: bytes that would\n    // parse as zero requirements must suspend the axis, not empty it.\n    return readFailure(e, rel);\n  }\n}\n\nasync function openapiAxis(context: FleetContext, abs: string, rel: string): Promise<AxisState<Operation[]>> {\n  if (!existsSync(abs)) return { kind: \"absent\" };\n  try {\n    const doc = await context.readOpenapi(abs);\n    return doc.unreadable\n      ? { kind: \"unreadable\", path: rel, error: doc.error ?? \"not a readable OpenAPI document\" }\n      : { kind: \"read\", value: doc.ops.filter((op) => !op.remove) };\n  } catch (e) {\n    return readFailure(e, rel);\n  }\n}\n\nasync function asyncapiAxis(context: FleetContext, abs: string, rel: string): Promise<AxisState<EventMessage[]>> {\n  if (!existsSync(abs)) return { kind: \"absent\" };\n  try {\n    const doc = await context.readAsyncapi(abs);\n    return doc.unreadable\n      ? { kind: \"unreadable\", path: rel, error: doc.error ?? \"not a readable AsyncAPI document\" }\n      : { kind: \"read\", value: doc.messages.filter((m) => m.remove !== true) };\n  } catch (e) {\n    return readFailure(e, rel);\n  }\n}\n\n/**\n * The current fleet, one `ServiceState` per enumerated service. The\n * enumeration itself (the tree walk) may throw `DocsRepoUnavailableError` —\n * that is the whole-repo refusal `docsRepoReady` fronts, not a per-subject\n * degradation, and it stays a throw for the command layer to map.\n */\nexport async function readCurrentFleet(docsDir: DocsDir, context: FleetContext): Promise<CurrentFleet> {\n  const entries = await context.listServices(docsDir);\n  const states = await inOrder(entries, async (entry): Promise<ServiceState> => {\n    const paths = servicePathsAt(entry.dir);\n    return {\n      id: entry.id,\n      dir: repoPath(docsDir, entry.dir),\n      spec: await requirementsAxis(context, paths.spec, repoPath(docsDir, paths.spec)),\n      archSpec: await requirementsAxis(context, paths.archSpec, repoPath(docsDir, paths.archSpec)),\n      openapi: await openapiAxis(context, paths.openapi, repoPath(docsDir, paths.openapi)),\n      asyncapi: await asyncapiAxis(context, paths.asyncapi, repoPath(docsDir, paths.asyncapi)),\n    };\n  });\n  const ambiguous = currentCollisions(states);\n  return {\n    services: new Map(states.filter((s) => !ambiguous.has(s.id)).map((s) => [s.id, s])),\n    ambiguous,\n  };\n}\n\n/** Ids claimed by more than one enumerated directory, with every claimant named. */\nfunction currentCollisions(states: readonly ServiceState[]): Map<string, string[]> {\n  const byId = new Map<string, string[]>();\n  for (const s of states) byId.set(s.id, [...(byId.get(s.id) ?? []), s.dir]);\n  return new Map([...byId].filter(([, dirs]) => dirs.length > 1));\n}\n"]}