@snag-run/core 0.3.0

package/dist/lint.js

@@ -0,0 +1,153 @@
+import { isCodeIntakeKind, scopePathsFromRef, sourceRefProblem, } from "./schema.js";
+/**
+ * Run the soft lint checks over a generation analysis. Returns warnings;
+ * an empty array means clean. Never throws on lint findings.
+ *
+ * `subject` is optional: when it is a code intake (`module`/`capability`), each
+ * failure node is additionally checked for a valid in-scope `file:line` sourceRef
+ * (#272) and an `uncited-code-failure` warning is emitted for any that lack one.
+ * Omitted/spec subjects skip that check entirely.
+ */
+export function lintGeneration(generation, subject) {
+    const { nodes, edges } = generation;
+    const warnings = [];
+    const incoming = new Map();
+    for (const node of nodes)
+        incoming.set(node.id, 0);
+    for (const edge of edges) {
+        incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+    }
+    // Orphan failure node: a failure mode with no incoming edge — it branches
+    // off nothing on the map.
+    for (const node of nodes) {
+        if (node.type === "failure" && (incoming.get(node.id) ?? 0) === 0) {
+            warnings.push({
+                code: "orphan-failure",
+                message: `failure node '${node.id}' has no incoming edge`,
+                nodeId: node.id,
+            });
+        }
+    }
+    // Happy-spine connectivity: following only `happy` edges from a root should
+    // reach a terminal node. If no terminal is reachable, warn.
+    const happyAdj = new Map();
+    for (const node of nodes)
+        happyAdj.set(node.id, []);
+    for (const edge of edges) {
+        if (edge.type === "happy")
+            happyAdj.get(edge.from)?.push(edge.to);
+    }
+    const hasHappyIncoming = new Set(edges.filter((e) => e.type === "happy").map((e) => e.to));
+    const spineRoots = nodes.filter((n) => n.type !== "failure" && !hasHappyIncoming.has(n.id));
+    const terminalIds = new Set(nodes.filter((n) => n.type === "terminal").map((n) => n.id));
+    const reachesTerminal = (startId) => {
+        const stack = [startId];
+        const visited = new Set();
+        while (stack.length > 0) {
+            const id = stack.pop();
+            if (visited.has(id))
+                continue;
+            visited.add(id);
+            if (terminalIds.has(id))
+                return true;
+            for (const next of happyAdj.get(id) ?? [])
+                stack.push(next);
+        }
+        return false;
+    };
+    if (terminalIds.size === 0 || !spineRoots.some((r) => reachesTerminal(r.id))) {
+        warnings.push({
+            code: "no-terminal-reach",
+            message: "the happy-path spine does not reach a terminal node",
+        });
+    }
+    // Unreachable node: a non-failure node not reachable (over any edge type)
+    // from a spine entry point. A spine entry is a flow node that *starts* the
+    // happy path — it has an outgoing happy edge but no incoming happy edge — so
+    // a wholly disconnected island is not itself treated as a root.
+    // (Failure nodes are covered by orphan-failure above.)
+    const hasHappyOutgoing = new Set(edges.filter((e) => e.type === "happy").map((e) => e.from));
+    const spineEntries = spineRoots.filter((r) => hasHappyOutgoing.has(r.id));
+    const adj = new Map();
+    for (const node of nodes)
+        adj.set(node.id, []);
+    for (const edge of edges)
+        adj.get(edge.from)?.push(edge.to);
+    const reachable = new Set();
+    const stack = spineEntries.map((r) => r.id);
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (reachable.has(id))
+            continue;
+        reachable.add(id);
+        for (const next of adj.get(id) ?? [])
+            stack.push(next);
+    }
+    for (const node of nodes) {
+        if (node.type === "failure")
+            continue;
+        if (!reachable.has(node.id)) {
+            warnings.push({
+                code: "unreachable-node",
+                message: `node '${node.id}' is unreachable from the spine`,
+                nodeId: node.id,
+            });
+        }
+    }
+    // Degenerate duplicates (#247): cluster the non-failure (spine) nodes by
+    // normalized type + label. A cluster of two or more is the signature of
+    // degenerate over-generation — the model emitting repeated `start` / `end` /
+    // `Flow End` nodes (distinct ids, identical meaning) instead of stopping. One
+    // warning per cluster, naming the type/label and count, so a junk map is
+    // flagged loudly rather than silently emitted. Failure nodes are deliberately
+    // excluded: an exhaustive FMEA is expected to carry many, varied failure modes.
+    const spineClusters = new Map();
+    for (const node of nodes) {
+        if (node.type === "failure")
+            continue;
+        const key = `${node.type} ${node.label.trim().toLowerCase()}`;
+        const cluster = spineClusters.get(key);
+        if (cluster)
+            cluster.ids.push(node.id);
+        else {
+            spineClusters.set(key, {
+                type: node.type,
+                label: node.label,
+                ids: [node.id],
+            });
+        }
+    }
+    for (const { type, label, ids } of spineClusters.values()) {
+        if (ids.length < 2)
+            continue;
+        warnings.push({
+            code: "degenerate-duplicate",
+            message: `${ids.length} '${type}' nodes share the label ` +
+                `'${label}' (ids: ${ids.join(", ")}) — likely degenerate ` +
+                `over-generation; the map may be junk`,
+            nodeId: ids[0],
+        });
+    }
+    // Ungrounded failure nodes on a code map (#272): for a `module`/`capability`
+    // intake, every failure node should cite the `file:line` that produces it.
+    // Flag any whose sourceRef is missing or not a valid in-scope citation — the
+    // speculative-garbage signal — using the discovered scope (`subject.ref`) as the
+    // path allow-list. Spec/absent subjects are skipped (no source to cite).
+    if (subject && isCodeIntakeKind(subject.kind)) {
+        const scopePaths = scopePathsFromRef(subject.ref);
+        for (const node of nodes) {
+            if (node.type !== "failure")
+                continue;
+            const problem = sourceRefProblem(node.sourceRef, scopePaths);
+            if (problem) {
+                warnings.push({
+                    code: "uncited-code-failure",
+                    message: `failure node '${node.id}': ${problem}`,
+                    nodeId: node.id,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+//# sourceMappingURL=lint.js.map

package/dist/lint.js.map

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

package/dist/log.d.ts

@@ -0,0 +1,81 @@
+/**
+ * One structured harness-log event emitted during a generation run. `phase`
+ * discriminates the event; the remaining fields are phase-specific and optional
+ * so the type stays small and forward-compatible. The engine emits these; the
+ * CLI decides what (if anything) to render based on the resolved `engine` level.
+ *
+ *   - `resolved`      — config resolution settled (opts > SNAG_* env > default),
+ *                       emitted BEFORE any LLM call so it survives a failed run;
+ *                       carries the resolved `adapter` + `model` ids (#120).
+ *   - `gather-start`  — phase-1 gather loop is about to run.
+ *   - `step`          — one agent step finished (a tool call); carries `step`
+ *                       (1-based index), `tool` (name), and a concise `args`
+ *                       string (e.g. the read path / grep pattern).
+ *   - `gather-done`   — phase-1 finished; carries the total `step` count, the
+ *                       discovered `files`, `finishReason`, and `stoppedAtCap`.
+ *   - `emit-start`    — phase-2 structured emit is about to run.
+ *   - `emit-done`     — phase-2 finished.
+ *   - `usage`         — token usage for one LLM call, or the per-run aggregate
+ *                       (#292). Carries `call` (which LLM call the counts are
+ *                       for: `"gather"` | `"emit"` | `"run"` for the aggregate)
+ *                       and `tokenUsage` (input/output/total). A run that fans
+ *                       out into a gather + an emit emits one `usage` per call
+ *                       plus a final `call: "run"` aggregate.
+ *   - `emit-failure`  — the phase-2 emit failed schema validation (#279). A
+ *                       verbose-tier diagnostic dump carrying the `gatherSummary`
+ *                       (the only context the emit had, on the agentic paths) and
+ *                       the `rejectedObject` (the malformed text the model
+ *                       produced), so a failed run is diagnosable without a paid
+ *                       re-run. Emitted just before the engine throws; the CLI
+ *                       gates it to the verbose `engine` level.
+ */
+export interface HarnessLogEvent {
+    phase: "resolved" | "gather-start" | "step" | "gather-done" | "emit-start" | "emit-done" | "usage" | "emit-failure";
+    /** Resolved adapter id for a `resolved` event (matches `meta.adapter`). */
+    adapter?: string;
+    /** Resolved model id for a `resolved` event (matches `meta.model`). */
+    model?: string;
+    /** 1-based step index for a `step` event; total step count for `gather-done`. */
+    step?: number;
+    /** Tool name for a `step` event (e.g. `"read"`, `"grep"`). */
+    tool?: string;
+    /** Concise tool-call argument summary for a `step` event (e.g. a path/pattern). */
+    args?: string;
+    /** Discovered file set for a `gather-done` event (the files read into context). */
+    files?: readonly string[];
+    /** AI SDK final finish reason for a `gather-done` event. */
+    finishReason?: string;
+    /** Whether the gather loop hit its hard step ceiling (`gather-done`). */
+    stoppedAtCap?: boolean;
+    /** Which LLM call a `usage` event reports: the phase-1 `"gather"` call, the
+     * phase-2 `"emit"` call, or `"run"` for the per-run aggregate (#292). */
+    call?: "gather" | "emit" | "run";
+    /** Token usage for a `usage` event (input/output/total). All non-negative
+     * integers; absent provider counts are coerced to 0 (#292). */
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    /** The gather summary that fed the failed emit (`emit-failure`, #279) — the
+     * only context the model had on the agentic paths. Absent on the doc path
+     * (no gather) and when no gather text was captured. */
+    gatherSummary?: string;
+    /** The rejected/partial object the model produced (`emit-failure`, #279) — the
+     * raw malformed text the AI SDK exposes on `NoObjectGeneratedError`, so the
+     * failure can be read directly. Absent when the SDK exposed no text. */
+    rejectedObject?: string;
+}
+/** The harness-log sink the engine calls. Default is a no-op (library stays silent). */
+export type OnLogFn = (event: HarnessLogEvent) => void;
+/** The no-op default sink — the engine emits nothing unless the caller wires one. */
+export declare const noopOnLog: OnLogFn;
+/**
+ * Build a concise, single-line argument summary for a step event from a tool
+ * call's input object. Defensive against the SDK step shape — an odd/missing
+ * input degrades to `undefined`, never a throw. Picks the most salient field per
+ * tool (path for read/glob, pattern for grep, ref for git) and falls back to a
+ * compact JSON of the input.
+ */
+export declare function summarizeToolArgs(tool: string | undefined, input: unknown): string | undefined;
+//# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EACD,UAAU,GACV,cAAc,GACd,MAAM,GACN,aAAa,GACb,YAAY,GACZ,WAAW,GACX,OAAO,GACP,cAAc,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;6EACyE;IACzE,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;IACjC;mEAC+D;IAC/D,UAAU,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9D;;2DAEuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;4EAEwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wFAAwF;AACxF,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEvD,qFAAqF;AACrF,eAAO,MAAM,SAAS,EAAE,OAAkB,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,KAAK,EAAE,OAAO,GACb,MAAM,GAAG,SAAS,CAwCpB"}

package/dist/log.js

@@ -0,0 +1,63 @@
+// Harness logging seam (#45) — a small, structured, side-channel event type the
+// engine emits during a generation run, and the no-op default sink.
+//
+// The engine library stays SILENT unless a caller passes `onLog`: the CLI is the
+// sink and does all level filtering + formatting (per the `engine` component
+// level). Logging is purely additive — it never touches map output, the schema,
+// or `meta`. All formatting/channel decisions (stderr, prefixes) live in the CLI.
+/** The no-op default sink — the engine emits nothing unless the caller wires one. */
+export const noopOnLog = () => { };
+/**
+ * Build a concise, single-line argument summary for a step event from a tool
+ * call's input object. Defensive against the SDK step shape — an odd/missing
+ * input degrades to `undefined`, never a throw. Picks the most salient field per
+ * tool (path for read/glob, pattern for grep, ref for git) and falls back to a
+ * compact JSON of the input.
+ */
+export function summarizeToolArgs(tool, input) {
+    if (input === null || typeof input !== "object")
+        return undefined;
+    const obj = input;
+    const pick = (key) => {
+        const v = obj[key];
+        return typeof v === "string" && v !== "" ? v : undefined;
+    };
+    switch (tool) {
+        case "read": {
+            const path = pick("path");
+            if (path === undefined)
+                return undefined;
+            // Surface a ranged read (#278) as `path:start-end` (whole-file reads stay
+            // bare `path`), so a verbose gather trace shows exactly which spans the
+            // agent paged — e.g. `worktree.go:200-299`.
+            const offset = typeof obj.offset === "number" ? obj.offset : undefined;
+            const limit = typeof obj.limit === "number" ? obj.limit : undefined;
+            if (offset === undefined && limit === undefined)
+                return path;
+            const start = offset !== undefined ? offset : 1;
+            return limit !== undefined ? `${path}:${start}-${start + limit - 1}` : `${path}:${start}+`;
+        }
+        case "glob":
+            return pick("pattern") ?? pick("glob");
+        case "grep": {
+            const p = pick("pattern");
+            return p === undefined ? undefined : `"${p}"`;
+        }
+        case "git_diff":
+        case "git_log":
+            return pick("ref") ?? pick("path");
+        default:
+            break;
+    }
+    // Fallback: a compact one-line JSON of the input, trimmed for log readability.
+    try {
+        const json = JSON.stringify(obj);
+        if (!json || json === "{}")
+            return undefined;
+        return json.length > 120 ? `${json.slice(0, 117)}...` : json;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=log.js.map

package/dist/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,oEAAoE;AACpE,EAAE;AACF,iFAAiF;AACjF,6EAA6E;AAC7E,gFAAgF;AAChF,kFAAkF;AA8ElF,qFAAqF;AACrF,MAAM,CAAC,MAAM,SAAS,GAAY,GAAG,EAAE,GAAE,CAAC,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAwB,EACxB,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAClE,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,MAAM,IAAI,GAAG,CAAC,GAAW,EAAsB,EAAE;QAC/C,MAAM,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QACnB,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3D,CAAC,CAAC;IACF,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;YAC1B,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,SAAS,CAAC;YACzC,0EAA0E;YAC1E,wEAAwE;YACxE,4CAA4C;YAC5C,MAAM,MAAM,GAAG,OAAO,GAAG,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;YACvE,MAAM,KAAK,GAAG,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;YACpE,IAAI,MAAM,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS;gBAAE,OAAO,IAAI,CAAC;YAC7D,MAAM,KAAK,GAAG,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAChD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,GAAG,CAAC;QAC7F,CAAC;QACD,KAAK,MAAM;YACT,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1B,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAChD,CAAC;QACD,KAAK,UAAU,CAAC;QAChB,KAAK,SAAS;YACZ,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC;YACE,MAAM;IACV,CAAC;IACD,+EAA+E;IAC/E,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,SAAS,CAAC;QAC7C,OAAO,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/reconcile.d.ts

@@ -0,0 +1,66 @@
+import { type FailureMap } from "./schema.js";
+import { type AnchorVocab } from "./anchor.js";
+/** A proposal node that reused a prior node's id. */
+export interface CarriedNode {
+    /** The prior id reused on the proposal node (the stable identity). */
+    readonly priorId: string;
+    /** The id the proposal originally minted for this node (replaced by `priorId`). */
+    readonly proposalId: string;
+    /** The normalized anchor the two matched on (`""` for a fingerprint fast-path
+     * match, which does not depend on an anchor). */
+    readonly anchor: string;
+    /** Which layer produced the match. */
+    readonly via: "fingerprint" | "anchor";
+}
+/** A "may continue" annotation for an ambiguous (multi-mode) anchor bucket: the
+ * exact-anchor spine cannot tell whether `proposalId` continues `priorId`, so both
+ * are surfaced (proposal as `new`, prior as `removed`) and this pair flags the
+ * possible continuation for the deferred embedding/human confirm step (#308).
+ * A candidate is NEVER an auto-carry — `proposalId` keeps its fresh id. */
+export interface CandidateContinuation {
+    /** The proposal node's freshly minted id (also present in {@link ReconcileDelta.new}). */
+    readonly proposalId: string;
+    /** The prior node it may continue (also present in {@link ReconcileDelta.removed}). */
+    readonly priorId: string;
+    /** The shared normalized anchor that put both in the same ambiguous bucket. */
+    readonly anchor: string;
+    /** A short human-readable reason the pair could not be auto-disambiguated. */
+    readonly reason: string;
+}
+/** The structured outcome of a reconcile pass over failure nodes. The
+ * carried/new/removed sets partition every failure node across the two maps;
+ * `candidates` is an ADVISORY overlay (its proposal ids are a subset of `new`
+ * and its prior ids a subset of `removed`) — it does not change the partition. */
+export interface ReconcileDelta {
+    /** Proposal nodes that reused a prior id (anchor- or fingerprint-matched). */
+    readonly carried: readonly CarriedNode[];
+    /** Proposal node ids with no prior match — kept as freshly minted. */
+    readonly new: readonly string[];
+    /** Prior node ids with no confident proposal match — removal candidates. A
+     * prior node in an ambiguous bucket lands here AND is flagged in `candidates`. */
+    readonly removed: readonly string[];
+    /** "May continue" pairs from ambiguous (multi-mode) anchor buckets that the
+     * exact-anchor spine could not auto-disambiguate — orphan-and-flag (#306). */
+    readonly candidates: readonly CandidateContinuation[];
+}
+export interface ReconcileOptions {
+    /** The closed source vocabulary the two maps' refs are normalized against. */
+    readonly anchors: AnchorVocab;
+}
+/**
+ * Reconcile a freshly generated `proposal` against the committed `prior` map,
+ * matching failure nodes so an unchanged mode keeps its prior id. Pure: it reads
+ * both maps + the supplied anchor vocabulary and returns a {@link ReconcileDelta}
+ * — it does not mutate either map (apply the delta with {@link applyReconcile}).
+ */
+export declare function reconcile(prior: FailureMap, proposal: FailureMap, options: ReconcileOptions): ReconcileDelta;
+/**
+ * Apply a {@link ReconcileDelta} to the proposal map: rewrite every carried
+ * node's id to the prior id it reused, and rewrite every edge endpoint with the
+ * same mapping so references stay intact. The result is re-validated through
+ * {@link failureMapSchema}, so an id collision or dangling edge introduced by the
+ * carry surfaces as a hard error rather than a corrupt map. This is the map that
+ * should be persisted — `proposal` is never mutated.
+ */
+export declare function applyReconcile(proposal: FailureMap, delta: ReconcileDelta): FailureMap;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../src/reconcile.ts"],"names":[],"mappings":"AA6BA,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE7D,qDAAqD;AACrD,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;qDACiD;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,QAAQ,CAAC;CACxC;AAED;;;;2EAI2E;AAC3E,MAAM,WAAW,qBAAqB;IACpC,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;kFAGkF;AAClF,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,sEAAsE;IACtE,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;sFACkF;IAClF,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;kFAC8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACvD;AAED,MAAM,WAAW,gBAAgB;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;CAC/B;AAgDD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,gBAAgB,GACxB,cAAc,CA6EhB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,cAAc,GACpB,UAAU,CAeZ"}

package/dist/reconcile.js

@@ -0,0 +1,173 @@
+// reconcile() — the OSS, embedding-free identity-carry pass (#305, ADR 0002).
+//
+// "Generation proposes, reconcile disposes": each `snag map` run mints fresh
+// LLM ids, so a regenerated map of an unchanged subject would churn every node
+// id (and, later, drop every carried verdict). reconcile() matches a freshly
+// generated PROPOSAL against the committed PRIOR map and carries the prior node's
+// id onto the matching proposal node, so the persisted artifact has a stable,
+// low-churn history that git records as a small delta.
+//
+// This is the spine: exact-anchor carry only. Two layers, cheapest first:
+//   0. byte-identical content fast-path — a prior/proposal pair whose semantic
+//      `fingerprint` is identical AND unique on both sides. Rarely fires (the
+//      model rewords every run) but free and certain when it does.
+//   1. exact source-anchor — bucket both sides by normalized source anchor
+//      (heading / symbol); a bucket holding exactly one mode on EACH side carries.
+//
+// Multi-mode / ambiguous buckets cannot be carried by the exact-anchor spine
+// alone — when an anchor holds ≥2 modes on either side, which prior id continues
+// which proposal node needs the embedding matcher, which is out of scope (the
+// embedding/verdict layer is the backend, #308). Rather than guess (a wrong carry
+// would corrupt a carried verdict) or silently drop, reconcile() orphan-and-flags
+// such a bucket (#306): every proposal node in it is emitted `new` (fresh id),
+// every prior node is emitted `removed` (a removal CANDIDATE, not a confirmed
+// drop), and each (proposal × prior) cross-pair is recorded in `candidates` as a
+// "may continue" annotation for the deferred human/embedding confirm step.
+// The append-only, id-keyed discipline (ADR 0002) is honored by construction: a
+// carry reuses a prior id, it never mutates one in place, and an uncertain match
+// is never silently merged.
+import { failureMapSchema, } from "./schema.js";
+import { anchorForRef } from "./anchor.js";
+function isFailure(node) {
+    return node.type === "failure";
+}
+/** Index nodes by `fingerprint`, keeping ONLY fingerprints that occur exactly
+ * once (a duplicate fingerprint is ambiguous — never use it to carry). Nodes
+ * without a fingerprint are skipped. */
+function uniqueByFingerprint(nodes) {
+    const counts = new Map();
+    for (const node of nodes) {
+        if (node.fingerprint)
+            counts.set(node.fingerprint, (counts.get(node.fingerprint) ?? 0) + 1);
+    }
+    const index = new Map();
+    for (const node of nodes) {
+        if (node.fingerprint && counts.get(node.fingerprint) === 1)
+            index.set(node.fingerprint, node);
+    }
+    return index;
+}
+/** Bucket failure nodes by their normalized source anchor. Nodes that anchor to
+ * nothing are dropped (they cannot carry — see anchor.ts). */
+function bucketByAnchor(nodes, vocab) {
+    const buckets = new Map();
+    for (const node of nodes) {
+        const anchor = anchorForRef(node.sourceRef, vocab);
+        if (anchor === null)
+            continue;
+        const bucket = buckets.get(anchor);
+        if (bucket)
+            bucket.push(node);
+        else
+            buckets.set(anchor, [node]);
+    }
+    return buckets;
+}
+/** A short, human-readable explanation of why an anchor bucket could not be
+ * auto-disambiguated, for {@link CandidateContinuation.reason}. */
+function ambiguityReason(anchor, priorCount, proposalCount) {
+    const modes = (n) => `${n} ${n === 1 ? "mode" : "modes"}`;
+    return (`shares anchor '${anchor}' with ${modes(priorCount)} prior / ` +
+        `${modes(proposalCount)} proposal — needs confirmation`);
+}
+/**
+ * Reconcile a freshly generated `proposal` against the committed `prior` map,
+ * matching failure nodes so an unchanged mode keeps its prior id. Pure: it reads
+ * both maps + the supplied anchor vocabulary and returns a {@link ReconcileDelta}
+ * — it does not mutate either map (apply the delta with {@link applyReconcile}).
+ */
+export function reconcile(prior, proposal, options) {
+    const priorFailures = prior.nodes.filter(isFailure);
+    const proposalFailures = proposal.nodes.filter(isFailure);
+    const carried = [];
+    const matchedPrior = new Set();
+    const matchedProposal = new Set();
+    // Layer 0: byte-identical fingerprint fast-path.
+    const priorByFingerprint = uniqueByFingerprint(priorFailures);
+    const proposalByFingerprint = uniqueByFingerprint(proposalFailures);
+    for (const [fingerprint, priorNode] of priorByFingerprint) {
+        const proposalNode = proposalByFingerprint.get(fingerprint);
+        if (!proposalNode)
+            continue;
+        carried.push({
+            priorId: priorNode.id,
+            proposalId: proposalNode.id,
+            anchor: "",
+            via: "fingerprint",
+        });
+        matchedPrior.add(priorNode.id);
+        matchedProposal.add(proposalNode.id);
+    }
+    // Layer 1: exact source-anchor, single mode on each side.
+    const priorBuckets = bucketByAnchor(priorFailures.filter((n) => !matchedPrior.has(n.id)), options.anchors);
+    const proposalBuckets = bucketByAnchor(proposalFailures.filter((n) => !matchedProposal.has(n.id)), options.anchors);
+    // Layer 2: orphan-and-flag ambiguous buckets (#306). An anchor present on both
+    // sides is either an unambiguous 1↔1 carry or a multi-mode bucket we cannot
+    // disambiguate without embeddings. We record `candidates` for the latter but do
+    // NOT mark its nodes matched, so they flow through to `new`/`removed` below: a
+    // multi-mode prior node is a removal CANDIDATE (the candidate pairs are its
+    // "might continue" signal), never a silent carry or silent drop.
+    const candidates = [];
+    for (const [anchor, priorBucket] of priorBuckets) {
+        const proposalBucket = proposalBuckets.get(anchor);
+        if (!proposalBucket)
+            continue;
+        if (priorBucket.length === 1 && proposalBucket.length === 1) {
+            // Unambiguous 1↔1 — the spine carries.
+            const priorNode = priorBucket[0];
+            const proposalNode = proposalBucket[0];
+            carried.push({
+                priorId: priorNode.id,
+                proposalId: proposalNode.id,
+                anchor,
+                via: "anchor",
+            });
+            matchedPrior.add(priorNode.id);
+            matchedProposal.add(proposalNode.id);
+        }
+        else {
+            // Multi-mode — orphan-and-flag every cross-pair instead of guessing.
+            const reason = ambiguityReason(anchor, priorBucket.length, proposalBucket.length);
+            for (const proposalNode of proposalBucket) {
+                for (const priorNode of priorBucket) {
+                    candidates.push({
+                        proposalId: proposalNode.id,
+                        priorId: priorNode.id,
+                        anchor,
+                        reason,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        carried,
+        new: proposalFailures.filter((n) => !matchedProposal.has(n.id)).map((n) => n.id),
+        removed: priorFailures.filter((n) => !matchedPrior.has(n.id)).map((n) => n.id),
+        candidates,
+    };
+}
+/**
+ * Apply a {@link ReconcileDelta} to the proposal map: rewrite every carried
+ * node's id to the prior id it reused, and rewrite every edge endpoint with the
+ * same mapping so references stay intact. The result is re-validated through
+ * {@link failureMapSchema}, so an id collision or dangling edge introduced by the
+ * carry surfaces as a hard error rather than a corrupt map. This is the map that
+ * should be persisted — `proposal` is never mutated.
+ */
+export function applyReconcile(proposal, delta) {
+    const rename = new Map();
+    for (const carried of delta.carried)
+        rename.set(carried.proposalId, carried.priorId);
+    const nodes = proposal.nodes.map((node) => {
+        const renamed = rename.get(node.id);
+        return renamed ? { ...node, id: renamed } : node;
+    });
+    const edges = proposal.edges.map((edge) => ({
+        ...edge,
+        from: rename.get(edge.from) ?? edge.from,
+        to: rename.get(edge.to) ?? edge.to,
+    }));
+    return failureMapSchema.parse({ ...proposal, nodes, edges });
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/reconcile.js.map

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