@milehimikey/em 1.7.2 → 1.8.1

package/dist/cli/conformScope.js

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: MIT
+// `em conform-scope` (MIL-100): mechanizes the mechanical half of reference/conform.md step 1
+// ("Scope") — everything that was previously prose telling the agent to shell out to git and
+// eyeball `implementedIn:` links by hand.
+//
+// Three pieces, each reusing an existing module rather than re-deriving it:
+//  - `Last conformance:` comes from `stateFile.ts`'s `parseState` (MIL-99) — this module never
+//    parses the state file's bullets itself.
+//  - Changed paths come from `git diff --name-only <revision>..HEAD` in the target repo, via
+//    the same injectable `GitRunner`/`realGit` convention diff-inputs.ts/changelog-git.ts use
+//    (so every failure branch — no repo, unknown revision — is unit-testable without a real
+//    repository).
+//  - A changed path maps to a slice only when its doc's `implementedIn` (from
+//    catalog/docJoin.ts's join — the same one `em export`/`em slice index` use, never a second
+//    parse) is textually, deterministically a repo-relative path that's a prefix of (or equal
+//    to) that changed path. A URL (PR/commit link) carries no path information we can trust, so
+//    it deterministically matches nothing. Anything left over is `unmappedPaths` — the agent's
+//    judgment queue (grep fallback, evidence walks); this module never guesses.
+//
+// `--seed-asis` mechanizes the OTHER mechanical convention step 1 describes: seeding
+// `<model>-asis.em` as a byte copy of the canonical model, and making sure `*-asis.em` is
+// gitignored (idempotent).
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { resolveSliceDocJoin } from "../catalog/docJoin.js";
+import { realGit } from "./diff-inputs.js";
+const URL_LIKE = /^[a-z][a-z0-9+.-]*:\/\//i; // scheme://... (http, https, git, ssh, ...)
+const SCP_LIKE = /^[\w.-]+@[\w.-]+:/; // git@host:owner/repo.git style — also carries no path
+/** `implementedIn` -> the repo-relative path text worth prefix-matching against changed paths,
+ *  or null when it's a URL/SCP-style link (a PR/commit/host reference) that carries no path
+ *  information we can trust. Deliberately conservative — see this module's header comment. */
+function pathCandidate(implementedIn) {
+    const trimmed = implementedIn.trim();
+    if (!trimmed || URL_LIKE.test(trimmed) || SCP_LIKE.test(trimmed))
+        return null;
+    return trimmed.replace(/^\.\//, "").replace(/\/+$/, "");
+}
+/** The changed paths one slice's `implementedIn` textually, deterministically names: equal to
+ *  the candidate path, or nested under it (the candidate names a directory). No fuzzy matching,
+ *  no grep — that judgment call stays with the agent (reference/conform.md step 1). */
+export function matchImplementedInToPaths(implementedIn, changedPaths) {
+    if (!implementedIn)
+        return [];
+    const candidate = pathCandidate(implementedIn);
+    if (!candidate)
+        return [];
+    return changedPaths.filter((p) => p === candidate || p.startsWith(`${candidate}/`));
+}
+/**
+ * Build the `em conform-scope` JSON body — pure, no fs/git. `full` covers `--full`; a `null`
+ * `lastConformance` (the state file's `never` marker, first run) forces the same behavior
+ * regardless of `full`, matching reference/conform.md step 1 ("If it's `null` (first run) or
+ * the user passes `--full`, scope is every `implemented` slice"). In that mode `changedPaths`
+ * is `[]` (documented choice, not omitted — keeps the JSON shape stable across modes) and every
+ * `implemented`-status slice is a candidate with `matchedBy: "full"` and empty `paths`.
+ */
+export function buildConformScope(slices, lastConformance, changedPaths, full) {
+    const lastConformanceOut = lastConformance ? { date: lastConformance.date, revision: lastConformance.revision } : null;
+    if (full || lastConformance === null) {
+        const candidateSlices = slices
+            .filter((s) => s.status === "implemented")
+            .map((s) => ({ key: s.key, matchedBy: "full", paths: [] }));
+        return { lastConformance: lastConformanceOut, changedPaths: [], candidateSlices, unmappedPaths: [] };
+    }
+    const matched = new Set();
+    const candidateSlices = [];
+    for (const s of slices) {
+        const paths = matchImplementedInToPaths(s.implementedIn, changedPaths);
+        if (paths.length === 0)
+            continue;
+        candidateSlices.push({ key: s.key, matchedBy: "implementedIn", paths });
+        for (const p of paths)
+            matched.add(p);
+    }
+    const unmappedPaths = changedPaths.filter((p) => !matched.has(p));
+    return { lastConformance: lastConformanceOut, changedPaths, candidateSlices, unmappedPaths };
+}
+/** Resolve every slice's doc-join facts in declaration order — exactly the two inputs
+ *  `buildConformScope` needs (`status`, `implementedIn`), via the same `resolveSliceDocJoin`
+ *  call `em export`/`em slice index` make, never a second doc parse. `diagnostics` carries any
+ *  `binding-missing-file`/`frontmatter-invalid` warnings, for the caller to print the same way
+ *  `em slice index` does. */
+export function resolveSliceDocFacts(model, refs, baseDir) {
+    const diagnostics = [];
+    const facts = model.slices.map((slice, i) => {
+        const key = refs.sliceKeys[i];
+        const { doc, diagnostics: docDiags } = resolveSliceDocJoin(slice, key, baseDir, (id) => refs.refById.get(id));
+        diagnostics.push(...docDiags);
+        return { key, status: doc.status, implementedIn: doc.implementedIn };
+    });
+    return { facts, diagnostics };
+}
+/**
+ * `git diff --name-only <revision>..HEAD`, run from `repo` (any directory inside the target
+ * repo, not necessarily its root — same "anchor dir, resolve toplevel" convention
+ * diff-inputs.ts/changelog-git.ts use). Paths come back repo-root-relative — git's own default
+ * for `--name-only` without `--relative`.
+ */
+export function changedPathsSince(repo, revision, runGit = realGit) {
+    const toplevel = runGit(["-C", repo, "rev-parse", "--show-toplevel"]);
+    if (toplevel.status !== 0) {
+        return { ok: false, message: `em conform-scope: ${repo} is not a git repository` };
+    }
+    const repoRoot = toplevel.stdout.trim();
+    const diff = runGit(["-C", repoRoot, "diff", "--name-only", `${revision}..HEAD`]);
+    if (diff.status !== 0) {
+        return {
+            ok: false,
+            message: `em conform-scope: git diff failed: ${(diff.stderr || "").trim() || `unknown revision "${revision}"`}`,
+        };
+    }
+    return {
+        ok: true,
+        paths: diff.stdout
+            .split("\n")
+            .map((s) => s.trim())
+            .filter(Boolean),
+    };
+}
+const ASIS_GITIGNORE_PATTERN = "*-asis.em";
+/**
+ * `--seed-asis`: byte-copy `modelFile` to `<dirname(modelFile)>/<stem>-asis.em`, and make sure
+ * `*-asis.em` is gitignored. reference/conform.md's Conventions section says to add the pattern
+ * to "the repository's `.gitignore`" — read here as the git repo the model itself lives in
+ * (resolved the same "anchor dir, `rev-parse --show-toplevel`" way as `changedPathsSince`
+ * above, from the model's own directory — a different repo entirely from the `--repo` target
+ * codebase conform is checking), so the entry lands once, at that repo's root, covering every
+ * model the repo holds. Falls back to a `.gitignore` right next to the model when the model
+ * isn't inside a git repo at all. Idempotent: never appends a second `*-asis.em` line if one
+ * (exactly, on its own line) is already present anywhere in the file.
+ */
+export function seedAsisModel(modelFile, runGit = realGit) {
+    const dir = dirname(modelFile);
+    const stem = basename(modelFile, extname(modelFile));
+    const asisPath = join(dir, `${stem}-asis.em`);
+    copyFileSync(modelFile, asisPath);
+    const toplevel = runGit(["-C", resolve(dir), "rev-parse", "--show-toplevel"]);
+    const gitignoreDir = toplevel.status === 0 ? toplevel.stdout.trim() : dir;
+    const gitignorePath = join(gitignoreDir, ".gitignore");
+    let gitignoreUpdated = false;
+    if (existsSync(gitignorePath)) {
+        const text = readFileSync(gitignorePath, "utf8");
+        const hasLine = text.split(/\r?\n/).some((l) => l.trim() === ASIS_GITIGNORE_PATTERN);
+        if (!hasLine) {
+            const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n";
+            writeFileSync(gitignorePath, `${text}${sep}${ASIS_GITIGNORE_PATTERN}\n`);
+            gitignoreUpdated = true;
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, `${ASIS_GITIGNORE_PATTERN}\n`);
+        gitignoreUpdated = true;
+    }
+    return { asisPath, gitignoreUpdated };
+}
+//# sourceMappingURL=conformScope.js.map

package/dist/cli/conformScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformScope.js","sourceRoot":"","sources":["../../src/cli/conformScope.ts"],"names":[],"mappings":"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"}

package/dist/cli/contract.d.ts

@@ -0,0 +1,7 @@
+/** Path to the packaged contract inside `packagedSkillDir` — the same directory `em skill
+ *  install`/`sync`/`check` read from (src/cli.ts's packagedSkillDir()). */
+export declare function contractPath(packagedSkillDir: string): string;
+/** Pure: reads the packaged contract's exact bytes. No process.exit/console — src/cli.ts's
+ *  action wraps fs errors (a corrupt/incomplete package install) the same way every other
+ *  command's file reads do. */
+export declare function readContract(packagedSkillDir: string): string;

package/dist/cli/contract.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// `em contract` (MIL-129): prints the packaged implementation contract — reference/implement.md
+// inside the skill directory bundled with whatever em package is actually running (see
+// src/cli.ts's packagedSkillDir) — to stdout, verbatim.
+//
+// Why this exists: reference/implement.md opens by claiming the contract applies to "any
+// implementing agent, whether or not the session started from `/event-modeling`" — but until
+// this command, its only distribution channel was `em skill install` copying it into
+// `.claude/skills/event-modeling/`, a path only Claude Code discovers. An agent that can run a
+// shell but has no `.claude/` awareness had no route to the contract at all (Slicewright story
+// gap G5). `em contract` needs no vendored skill copy, no repo scaffolding, nothing but the em
+// binary itself — the file always comes from the installed package, not from any project's
+// working tree.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Path to the packaged contract inside `packagedSkillDir` — the same directory `em skill
+ *  install`/`sync`/`check` read from (src/cli.ts's packagedSkillDir()). */
+export function contractPath(packagedSkillDir) {
+    return join(packagedSkillDir, "reference", "implement.md");
+}
+/** Pure: reads the packaged contract's exact bytes. No process.exit/console — src/cli.ts's
+ *  action wraps fs errors (a corrupt/incomplete package install) the same way every other
+ *  command's file reads do. */
+export function readContract(packagedSkillDir) {
+    return readFileSync(contractPath(packagedSkillDir), "utf8");
+}
+//# sourceMappingURL=contract.js.map

package/dist/cli/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/cli/contract.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,gGAAgG;AAChG,uFAAuF;AACvF,wDAAwD;AACxD,EAAE;AACF,yFAAyF;AACzF,6FAA6F;AAC7F,qFAAqF;AACrF,+FAA+F;AAC/F,+FAA+F;AAC/F,+FAA+F;AAC/F,2FAA2F;AAC3F,gBAAgB;AAEhB,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;2EAC2E;AAC3E,MAAM,UAAU,YAAY,CAAC,gBAAwB;IACnD,OAAO,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC7D,CAAC;AAED;;+BAE+B;AAC/B,MAAM,UAAU,YAAY,CAAC,gBAAwB;IACnD,OAAO,YAAY,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,CAAC;AAC9D,CAAC"}

package/dist/cli/coverage.d.ts

@@ -0,0 +1,71 @@
+import { NormalizedModel } from "../model/model.js";
+import { RefsResult } from "../model/refs.js";
+/** The stable INV token format. `INV-` then one or more alphanumeric/hyphen segments — matches
+ *  both `INV-1`/`INV-2` (the template's bare numbering) and `INV-CHK-4`/`INV-CHK-3a` (the
+ *  per-slice mnemonic style reference/conform.md's own example uses). Exported so tests can
+ *  assert against the exact grammar. */
+export declare const INV_TOKEN_RE: RegExp;
+/**
+ * Extract every distinct `INV-*` token this slice doc *defines*, in first-occurrence order (a
+ * rule stated once in `## Invariants` and re-declared in a later `## Delta` section dedupes to
+ * its first appearance — order is for stable, readable output, not a claim about which mention is
+ * canonical). Scoped to `OWNERSHIP_HEADING_RE`'s sections only, so a doc's prose narratively
+ * citing another slice's ID elsewhere (Dependencies, Open Questions, ...) doesn't cross-credit
+ * that ID as this slice's own (MIL-149) — the section ends at the next `#`/`##` heading or EOF,
+ * same boundary rule sliceDoc.ts's countOpenQuestions() uses, so a `### Added`/`#### Requirement`
+ * subheading under `## Delta` stays in scope while a sibling `## Scenarios` does not.
+ */
+export declare function extractInvariantIds(body: string): string[];
+export interface Citation {
+    /** Path relative to the `--tests <dir>` root, POSIX forward slashes — same convention
+     *  walkDir() already returns. */
+    file: string;
+    /** 1-based line number within `file`. */
+    line: number;
+}
+/**
+ * Scan every text file under `testsDir` for lines citing any of `ids`, word-boundary-anchored so
+ * `INV-KEY-1` doesn't match inside `INV-KEY-12` (both boundary sides land on a hyphen/alnum
+ * transition since the ID alphabet is exactly `[A-Za-z0-9-]`, so no escaping is needed to build
+ * the per-ID regex). Returns every citing `{file, line}`, in walk order — a line citing more than
+ * one ID is recorded under each. `ids` with zero test-dir mentions still get a `[]` entry, never
+ * an absent map key, so a caller never has to guard a lookup with `?? []`.
+ */
+export declare function scanTestCitations(testsDir: string, ids: readonly string[]): Map<string, Citation[]>;
+export interface InvariantCoverage {
+    id: string;
+    cited: boolean;
+    citations: Citation[];
+}
+export interface SliceCoverage {
+    key: string;
+    /** The joined doc's `status`, or null when no usable doc was found — carried even for an
+     *  out-of-scope slice, for transparency (a reader can see *why* it was skipped). */
+    status: string | null;
+    /** The resolveSliceDocJoin() `DocReason` behind `status: null` — `"no-doc-bound"`,
+     *  `"binding-missing-file"`, or `"frontmatter-invalid"` — or null when the doc joined cleanly
+     *  (whether or not the slice ended up in scope; a draft slice with a perfectly good doc still
+     *  has `docReason: null`). Lets an out-of-scope reader tell "nothing bound yet" apart from
+     *  "bound but broken" without re-running the join themselves. */
+    docReason: string | null;
+    /** True when this slice's doc was found, its frontmatter usable, and `status` is
+     *  `ready-to-implement` or `implemented` — the only slices `invariants` is populated for. */
+    inScope: boolean;
+    invariants: InvariantCoverage[];
+}
+export interface CoverageReport {
+    slices: SliceCoverage[];
+    /** Total invariant IDs across every in-scope slice (sum of `slices[*].invariants.length`). */
+    totalInvariants: number;
+    /** Of `totalInvariants`, how many have zero citations. */
+    uncoveredCount: number;
+}
+/**
+ * Assemble the full coverage report: for every slice in the model, resolve its doc via the same
+ * note-binding join `em export`/`--slice-ready` use (resolveSliceDocJoin), decide in-scope status,
+ * extract invariant IDs for in-scope slices, then scan `testsDir` once for every ID across the
+ * whole model (cheaper than one scan per slice, and citations are looked up per-slice from the
+ * single resulting map). `baseDir` is the `.em` file's directory, same convention every doc/note
+ * path in `em` uses.
+ */
+export declare function buildCoverageReport(model: NormalizedModel, refs: RefsResult, baseDir: string, testsDir: string): CoverageReport;

package/dist/cli/coverage.js

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+// `em coverage` (MIL-130): a mechanical check for reference/implement.md's definition-of-done
+// line "every INV-n has a test that cites its ID" — until now a pure honor system, since no `em`
+// command related a slice doc's invariant IDs to a test suite. Both sides are stable strings
+// (the doc's `INV-*` tokens, a test file's source text), so the citation check is deterministic
+// and grep-shaped: extract every invariant ID a slice doc's own Invariants/Delta sections define
+// (MIL-149: not every ID its prose merely mentions — a doc narratively citing another slice's ID
+// doesn't own it), then scan a test tree for lines that cite it.
+//
+// Deliberately a *second*, independent reader of doc bodies, alongside `em export`'s doc join
+// (docJoin.ts, MIL-91) — not a change to it. `em export`'s frontmatter-only contract is
+// untouched: this module never adds a frontmatter field, and it reads `SliceDoc.body` (already
+// exposed for `em ledger`'s content comparison, catalog/sliceDoc.ts) rather than reshaping the
+// export document. Checks that an ID is *cited*, nothing about whether the citing test is good
+// or passing — that stays with review and CI respectively; no judgment mechanized here.
+//
+// Token format: `INV-<KEY>-n` where `<KEY>` is present in nothing textually — the actual convention
+// found in the codebase (templates/slice.md's own Invariants section, reference/conform.md's
+// worked example `INV-CHK-4`) uses either a bare running number (`INV-1`, `INV-2`) or a per-slice
+// mnemonic prefix (`INV-CHK-3`, `INV-CHK-3a` for a rename) — IDs are hand-authored per
+// docs/slice-doc-schema.md, "give each a stable ID", not machine-generated, so no single fixed
+// shape is enforced by any `em` command. INV_TOKEN_RE below matches both: `INV-` followed by a
+// greedy run of alphanumeric/hyphen segments. Greedy is what keeps `INV-KEY-1` from partially
+// matching inside `INV-KEY-12` during *extraction* (`\d+` inside the run always consumes the full
+// digit sequence); citation *scanning* below re-anchors with `\b` on the exact ID string for the
+// same reason, since that direction is a substring search rather than a token match.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveSliceDocJoin } from "../catalog/docJoin.js";
+import { readSliceDoc } from "../catalog/readSliceDoc.js";
+import { walkDir } from "../util/walkDir.js";
+/** The stable INV token format. `INV-` then one or more alphanumeric/hyphen segments — matches
+ *  both `INV-1`/`INV-2` (the template's bare numbering) and `INV-CHK-4`/`INV-CHK-3a` (the
+ *  per-slice mnemonic style reference/conform.md's own example uses). Exported so tests can
+ *  assert against the exact grammar. */
+export const INV_TOKEN_RE = /\bINV-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*\b/g;
+/** Headings whose content *defines* (or, for `## Delta`, legitimately re-declares) an invariant
+ *  ID for the slice doc it appears in — `## Invariants / Business Rules` itself, and `## Delta`'s
+ *  Added/Modified/Renamed requirement subsections, which introduce/rename IDs "from Invariants
+ *  below" on re-ratification (see templates/slice.md). Every other section — Intent, Scenarios,
+ *  Trigger & Actor, Dependencies & Read Models Affected, Open Questions, ... — is prose that may
+ *  narratively *cite* another slice's ID without this doc owning it (MIL-149: such a mention was
+ *  being cross-credited to the citing slice's own coverage ledger). */
+const OWNERSHIP_HEADING_RE = /^##\s+(?:Invariants(?:\s*\/\s*Business Rules)?|Delta)\s*$/i;
+/** Statuses `reference/implement.md`'s coverage gate applies to — a slice hasn't reached the
+ *  point of needing test citations before `ready-to-implement`, and stays in scope forever after
+ *  once `implemented` (tests shouldn't regress away from citing an invariant just because the
+ *  slice shipped). Anything else (`draft`, `reviewed`, or no doc at all) is out of scope. */
+const IN_SCOPE_STATUSES = new Set(["ready-to-implement", "implemented"]);
+/**
+ * Extract every distinct `INV-*` token this slice doc *defines*, in first-occurrence order (a
+ * rule stated once in `## Invariants` and re-declared in a later `## Delta` section dedupes to
+ * its first appearance — order is for stable, readable output, not a claim about which mention is
+ * canonical). Scoped to `OWNERSHIP_HEADING_RE`'s sections only, so a doc's prose narratively
+ * citing another slice's ID elsewhere (Dependencies, Open Questions, ...) doesn't cross-credit
+ * that ID as this slice's own (MIL-149) — the section ends at the next `#`/`##` heading or EOF,
+ * same boundary rule sliceDoc.ts's countOpenQuestions() uses, so a `### Added`/`#### Requirement`
+ * subheading under `## Delta` stays in scope while a sibling `## Scenarios` does not.
+ */
+export function extractInvariantIds(body) {
+    const seen = new Set();
+    const ids = [];
+    let inOwnershipSection = false;
+    for (const line of body.split(/\r?\n/)) {
+        if (/^#{1,2}\s/.test(line)) {
+            inOwnershipSection = OWNERSHIP_HEADING_RE.test(line);
+            continue;
+        }
+        if (!inOwnershipSection)
+            continue;
+        for (const m of line.matchAll(INV_TOKEN_RE)) {
+            if (!seen.has(m[0])) {
+                seen.add(m[0]);
+                ids.push(m[0]);
+            }
+        }
+    }
+    return ids;
+}
+// Directory segments never worth descending into for citations: dependency trees
+// (node_modules) and VCS metadata (.git) can be enormous and never contain a test file worth
+// scanning. Passed to walkDir() as a skipDir predicate so these subtrees are pruned during
+// descent rather than walked in full and filtered out afterward — the skill walkers
+// (skillSync.ts/skillCheck.ts) never encounter this problem in the first place, since the
+// bundled skill directory they walk never contains a node_modules or .git of its own.
+const SKIP_DIR_SEGMENTS = new Set(["node_modules", ".git"]);
+/** Cheap binary sniff: a NUL byte anywhere in the first few KB is not valid UTF-8/ASCII text —
+ *  every text source file this check cares about (and every test fixture worth citing an
+ *  invariant from) will fail this in exactly zero legitimate cases. */
+function isLikelyBinary(buf) {
+    const len = Math.min(buf.length, 8000);
+    for (let i = 0; i < len; i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Scan every text file under `testsDir` for lines citing any of `ids`, word-boundary-anchored so
+ * `INV-KEY-1` doesn't match inside `INV-KEY-12` (both boundary sides land on a hyphen/alnum
+ * transition since the ID alphabet is exactly `[A-Za-z0-9-]`, so no escaping is needed to build
+ * the per-ID regex). Returns every citing `{file, line}`, in walk order — a line citing more than
+ * one ID is recorded under each. `ids` with zero test-dir mentions still get a `[]` entry, never
+ * an absent map key, so a caller never has to guard a lookup with `?? []`.
+ */
+export function scanTestCitations(testsDir, ids) {
+    const citations = new Map(ids.map((id) => [id, []]));
+    if (ids.length === 0)
+        return citations;
+    const idPatterns = ids.map((id) => [id, new RegExp(`\\b${id}\\b`)]);
+    for (const rel of walkDir(testsDir, { skipDir: (name) => SKIP_DIR_SEGMENTS.has(name) })) {
+        let buf;
+        try {
+            buf = readFileSync(join(testsDir, rel));
+        }
+        catch {
+            continue; // unreadable (permissions, broken symlink target, ...) — not this check's job
+        }
+        if (isLikelyBinary(buf))
+            continue;
+        const lines = buf.toString("utf8").split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const [id, re] of idPatterns) {
+                if (re.test(line))
+                    citations.get(id).push({ file: rel, line: i + 1 });
+            }
+        }
+    }
+    return citations;
+}
+/**
+ * Assemble the full coverage report: for every slice in the model, resolve its doc via the same
+ * note-binding join `em export`/`--slice-ready` use (resolveSliceDocJoin), decide in-scope status,
+ * extract invariant IDs for in-scope slices, then scan `testsDir` once for every ID across the
+ * whole model (cheaper than one scan per slice, and citations are looked up per-slice from the
+ * single resulting map). `baseDir` is the `.em` file's directory, same convention every doc/note
+ * path in `em` uses.
+ */
+export function buildCoverageReport(model, refs, baseDir, testsDir) {
+    const scoped = [];
+    const allIds = new Set();
+    for (let i = 0; i < model.slices.length; i++) {
+        const slice = model.slices[i];
+        const key = refs.sliceKeys[i];
+        const { doc } = resolveSliceDocJoin(slice, key, baseDir, (id) => refs.refById.get(id));
+        const inScope = doc.reason === null && doc.status !== null && IN_SCOPE_STATUSES.has(doc.status);
+        let ids = [];
+        if (inScope) {
+            // Re-derive the bound doc's key from doc.path rather than assuming it's this slice's own
+            // — MIL-121's ratified cross-binding can resolve `doc` to a DIFFERENT slice's doc, same
+            // re-derivation sliceReadyValidate.ts uses for Open Questions.
+            const boundKey = doc.path.replace(/^slices\//, "").replace(/\.md$/, "");
+            const parsed = readSliceDoc(baseDir, boundKey);
+            if (parsed)
+                ids = extractInvariantIds(parsed.body);
+        }
+        scoped.push({ key, status: doc.status, docReason: doc.reason, inScope, ids });
+        for (const id of ids)
+            allIds.add(id);
+    }
+    const citations = scanTestCitations(testsDir, [...allIds]);
+    let totalInvariants = 0;
+    let uncoveredCount = 0;
+    const slices = scoped.map(({ key, status, docReason, inScope, ids }) => {
+        const invariants = ids.map((id) => {
+            const cs = citations.get(id) ?? [];
+            totalInvariants++;
+            if (cs.length === 0)
+                uncoveredCount++;
+            return { id, cited: cs.length > 0, citations: cs };
+        });
+        return { key, status, docReason, inScope, invariants };
+    });
+    return { slices, totalInvariants, uncoveredCount };
+}
+//# sourceMappingURL=coverage.js.map

package/dist/cli/coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.js","sourceRoot":"","sources":["../../src/cli/coverage.ts"],"names":[],"mappings":"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"}

package/dist/cli/markImplemented.d.ts

@@ -0,0 +1,34 @@
+import { NormalizedModel } from "../model/model.js";
+import { RefsResult } from "../model/refs.js";
+export type ApplyFrontmatterResult = {
+    ok: true;
+    content: string;
+    changed: boolean;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Pure text transform: flips `status:` to `implemented` and sets `implementedIn:` to `prUrl` in
+ * `raw`'s frontmatter block. Idempotent (re-applying the same URL is a no-op, `changed: false`,
+ * `content` returned byte-identical to `raw`); refuses (`ok: false`) rather than overwrite
+ * provenance when the doc is already `status: implemented` with a *different* `implementedIn`.
+ * No fs access — the caller reads/writes; see `runMarkImplemented` below.
+ */
+export declare function applyImplementedFrontmatter(raw: string, prUrl: string): ApplyFrontmatterResult;
+export type RunMarkImplementedResult = {
+    ok: true;
+    path: string;
+    changed: boolean;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Resolves `sliceKey` to its bound doc via the same note-binding join `--slice-ready`/`em
+ * export` use (MIL-121 cross-binding included — the doc actually edited is whichever one the
+ * join resolved to, exactly like `sliceReadyValidate.ts` re-deriving its own read from
+ * `doc.path`), then reads/applies/writes it. `baseDir` is the `.em` file's directory, same
+ * convention every doc/note path in `em` uses.
+ */
+export declare function runMarkImplemented(model: NormalizedModel, refs: RefsResult, baseDir: string, sliceKey: string, prUrl: string): RunMarkImplementedResult;