@holmes-lab/holmes-kit 0.19.6 → 0.20.1

package/dist/holmes/governance/provenance-ledger.d.ts

@@ -25,6 +25,28 @@ export interface LedgerEvent extends ProvenanceEvent {
     /** Which chain this came from; `null` for the pre-split legacy file. */
     replicaId: string | null;
 }
+/** A-SPEC-642 — one single-use nonce consumed by several events (any replicas), not yet reconciled. */
+export interface DoubleSpend {
+    nonce: string;
+    events: {
+        replicaId: string | null;
+        seq: number;
+        hash: string;
+        ts: string;
+    }[];
+}
+/** A-SPEC-642 — the event kind an operator's reconciliation appends. */
+export declare const DOUBLE_SPEND_RECONCILED = "nonce-double-spend-reconciled";
+/**
+ * @implements A-SPEC-642
+ * Single-use nonces consumed by two or more `nonce-consumed` events (on any replicas) that no
+ * `nonce-double-spend-reconciled` event has covered. Pure and hash-free on purpose: the gate and
+ * the approval channel ask this on every guarded act, at the cost `isNonceConsumed` already pays;
+ * chain integrity stays with `verifyAll`. A reconciliation covers a group only when it names the
+ * nonce input AND `event:<hash>` for every member — a later consumption of the same nonce is a new
+ * event the old reconciliation never saw, so the group is open again.
+ */
+export declare function unreconciledDoubleSpends(events: LedgerEvent[]): DoubleSpend[];
 export interface LedgerVerifyResult {
     ok: boolean;
     /** Per-chain failures, naming the replica so a report is actionable rather than merely alarming. */
@@ -33,6 +55,9 @@ export interface LedgerVerifyResult {
         file: string;
         detail?: string;
         brokenAt?: number;
+        kind?: 'chain' | 'double-spend';
+        nonce?: string;
+        events?: DoubleSpend['events'];
     }[];
 }
 /**
@@ -72,6 +97,7 @@ export declare class ProvenanceLedger {
      * `.ax/state/`, which is the REQ-148 footprint defect returning through a new door.
      */
     replicaIdOf(): string;
+    executionContext(): import("../project/execution-context").ExecutionContext | undefined;
     /** Every chain file present, legacy first. `replicaId` is null for the legacy chain. */
     chains(): {
         replicaId: string | null;
@@ -89,6 +115,8 @@ export declare class ProvenanceLedger {
      * ordering exists so output is stable and readable, not so it can be read as "this happened first".
      */
     loadAll(): LedgerEvent[];
+    /** @implements A-SPEC-642 — unreconciled cross-replica double-spends, structured. */
+    doubleSpends(): DoubleSpend[];
     /** Each chain verified on its own; one bad chain fails the whole ledger, and is named. */
     verifyAll(): LedgerVerifyResult;
     /**

package/dist/holmes/governance/provenance-ledger.js

@@ -33,14 +33,50 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProvenanceLedger = void 0;
+exports.ProvenanceLedger = exports.DOUBLE_SPEND_RECONCILED = void 0;
+exports.unreconciledDoubleSpends = unreconciledDoubleSpends;
 exports.isLedgerFilename = isLedgerFilename;
-// @implements A-SPEC-206
+// @implements A-SPEC-206, A-SPEC-624
+// @implements A-SPEC-642
+const execution_context_1 = require("../project/execution-context");
 // @implements A-SPEC-148
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const provenance_chain_1 = require("./provenance-chain");
 const replica_id_1 = require("./replica-id");
+/** A-SPEC-642 — the event kind an operator's reconciliation appends. */
+exports.DOUBLE_SPEND_RECONCILED = 'nonce-double-spend-reconciled';
+/**
+ * @implements A-SPEC-642
+ * Single-use nonces consumed by two or more `nonce-consumed` events (on any replicas) that no
+ * `nonce-double-spend-reconciled` event has covered. Pure and hash-free on purpose: the gate and
+ * the approval channel ask this on every guarded act, at the cost `isNonceConsumed` already pays;
+ * chain integrity stays with `verifyAll`. A reconciliation covers a group only when it names the
+ * nonce input AND `event:<hash>` for every member — a later consumption of the same nonce is a new
+ * event the old reconciliation never saw, so the group is open again.
+ */
+function unreconciledDoubleSpends(events) {
+    const groups = new Map();
+    for (const e of events) {
+        if (e.kind !== 'nonce-consumed')
+            continue;
+        for (const input of e.inputs ?? []) {
+            const list = groups.get(input) ?? [];
+            list.push({ replicaId: e.replicaId, seq: e.seq, hash: e.hash, ts: e.ts });
+            groups.set(input, list);
+        }
+    }
+    const reconciliations = events.filter((e) => e.kind === exports.DOUBLE_SPEND_RECONCILED).map((e) => new Set(e.inputs ?? []));
+    const out = [];
+    for (const [nonce, list] of groups) {
+        if (list.length < 2)
+            continue;
+        const covered = reconciliations.some((inputs) => inputs.has(nonce) && list.every((ev) => inputs.has('event:' + ev.hash)));
+        if (!covered)
+            out.push({ nonce, events: list });
+    }
+    return out.sort((a, b) => (a.nonce < b.nonce ? -1 : a.nonce > b.nonce ? 1 : 0));
+}
 const LEGACY = 'provenance.jsonl';
 const REPLICA_FILE = /^provenance\.([^.]+)\.jsonl$/;
 /**
@@ -85,6 +121,9 @@ class ProvenanceLedger {
     }
     cachedId;
     get replicaId() {
+        const execution = this.executionContext();
+        if (execution)
+            return execution.replicaId;
         if (this.cachedId === undefined)
             this.cachedId = this.replicaIdFn();
         return this.cachedId;
@@ -107,8 +146,12 @@ class ProvenanceLedger {
      * `.ax/state/`, which is the REQ-148 footprint defect returning through a new door.
      */
     replicaIdOf() {
+        const execution = this.executionContext();
+        if (execution)
+            return execution.replicaId;
         return this.cachedId ?? (0, replica_id_1.resolveReplicaId)(rootForLedgerDir(this.dir), process.env, { persist: false });
     }
+    executionContext() { return (0, execution_context_1.executionForRoot)(rootForLedgerDir(this.dir)); }
     /** Every chain file present, legacy first. `replicaId` is null for the legacy chain. */
     chains() {
         let names;
@@ -149,6 +192,7 @@ class ProvenanceLedger {
         return events.map((e) => ({
             ...e,
             inputs: e.inputs ? [...e.inputs] : undefined,
+            ...(e.execution ? { execution: { ...e.execution } } : {}),
         }));
     }
     /**
@@ -175,13 +219,20 @@ class ProvenanceLedger {
         this.indexCache = { key, events: out };
         return this.cloneEvents(out);
     }
+    /** @implements A-SPEC-642 — unreconciled cross-replica double-spends, structured. */
+    doubleSpends() { return unreconciledDoubleSpends(this.loadAll()); }
     /** Each chain verified on its own; one bad chain fails the whole ledger, and is named. */
     verifyAll() {
         const broken = [];
         for (const c of this.chains()) {
             const r = new provenance_chain_1.ProvenanceChain(c.file).verify();
             if (!r.ok)
-                broken.push({ replicaId: c.replicaId, file: c.file, detail: r.detail, brokenAt: r.brokenAt });
+                broken.push({ replicaId: c.replicaId, file: c.file, kind: 'chain', detail: r.detail, brokenAt: r.brokenAt });
+            if (r.ok) {
+                const mismatch = new provenance_chain_1.ProvenanceChain(c.file).load().find(e => e.execution && e.execution.replicaId !== c.replicaId);
+                if (mismatch)
+                    broken.push({ replicaId: c.replicaId, file: c.file, kind: 'chain', detail: 'execution replica differs from chain partition', brokenAt: mismatch.seq });
+            }
         }
         // @implements A-SPEC-458
         // Cross-replica double-spend. consumeNonceExclusively's lock is per-file, so two machines can
@@ -191,18 +242,14 @@ class ProvenanceLedger {
         // records is always a violation (REQ-141): there is no legitimate re-spend. Counted by the raw
         // input value, the same rule isNonceConsumed matches on — one consume path writes one form, so
         // a real double-spend records the same value twice.
-        const counts = new Map();
-        for (const e of this.loadAll()) {
-            if (e.kind !== 'nonce-consumed')
-                continue;
-            for (const inp of e.inputs ?? [])
-                counts.set(inp, (counts.get(inp) ?? 0) + 1);
-        }
-        for (const [nonce, n] of counts) {
-            if (n > 1) {
-                broken.push({ replicaId: null, file: '(cross-replica)',
-                    detail: `single-use nonce ${nonce.slice(0, 16)}… spent ${n} times across replicas — REQ-141 double-spend` });
-            }
+        // @implements A-SPEC-642 — structured, and RECONCILABLE: an operator's `nonce-double-spend-reconciled`
+        // event naming the nonce and every consuming event's hash retires the group; a later consumption
+        // reopens it. Measured 2026-09-14: the prose-only entry left the Stop hook blocking every turn
+        // end "at seq undefined" with no act that could ever clear it.
+        for (const d of unreconciledDoubleSpends(this.loadAll())) {
+            const replicas = [...new Set(d.events.map((e) => e.replicaId ?? 'legacy'))].join(', ');
+            broken.push({ replicaId: null, file: '(cross-replica)', kind: 'double-spend', nonce: d.nonce, events: d.events,
+                detail: `single-use nonce ${d.nonce} spent ${d.events.length} times across replicas (${replicas}) — REQ-141 double-spend; reconcile with ledger_reconcile` });
         }
         return { ok: broken.length === 0, broken };
     }
@@ -213,8 +260,14 @@ class ProvenanceLedger {
      * which is the defect this class exists to remove.
      */
     append(body) {
+        const execution = this.executionContext();
+        if ('execution' in body) {
+            const supplied = (0, execution_context_1.validateExecution)(body.execution);
+            if (execution && JSON.stringify(supplied) !== JSON.stringify(execution))
+                throw new Error('Supplied execution differs from the owned run');
+        }
         this.indexCache = undefined;
-        return new provenance_chain_1.ProvenanceChain(this.currentFile()).append(body);
+        return new provenance_chain_1.ProvenanceChain(this.currentFile()).append(execution ? { ...body, execution } : body);
     }
     /**
      * Has this nonce been spent on ANY replica?

package/dist/holmes/governance/session-context.d.ts

@@ -1,3 +1,4 @@
+import { ExecutionContext } from '../project/execution-context';
 /**
  * The session-context ledger: WHO attached (agent name@version) and — where a harness exposes it —
  * WITH WHAT (model ids, token totals). REQ-564's whole point is that none of this existed anywhere
@@ -21,6 +22,7 @@ export interface UsageTotals {
     cacheCreation: number;
 }
 export interface ClientRecord {
+    execution?: ExecutionContext;
     kind: 'client';
     sessionKey: string;
     client: string;
@@ -29,6 +31,7 @@ export interface ClientRecord {
     replica?: string;
 }
 export interface UsageRecord {
+    execution?: ExecutionContext;
     kind: 'usage';
     sessionKey: string;
     models: string[];

package/dist/holmes/governance/session-context.js

@@ -39,7 +39,8 @@ exports.appendSessionContext = appendSessionContext;
 exports.readSessionContext = readSessionContext;
 exports.makeSessionStamper = makeSessionStamper;
 exports.summarizeTranscript = summarizeTranscript;
-// @implements A-SPEC-564.1
+// @implements A-SPEC-564.1, A-SPEC-625
+const execution_context_1 = require("../project/execution-context");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const replica_id_1 = require("./replica-id");
@@ -56,14 +57,19 @@ function appendSessionContext(root, rec) {
     try {
         if (!fs.existsSync(path.join(root, '.ax')))
             return false;
+        const execution = (0, execution_context_1.observationExecution)(root, rec);
         let replica = 'local';
-        try {
-            replica = (0, replica_id_1.resolveReplicaId)(root) || 'local';
+        if (execution)
+            replica = execution.replicaId;
+        else {
+            try {
+                replica = (0, replica_id_1.resolveReplicaId)(root) || 'local';
+            }
+            catch { /* keep the fallback */ }
         }
-        catch { /* keep the fallback */ }
         const file = path.join(root, '.ax', 'ledger', sessionContextFilename(replica));
         fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.appendFileSync(file, `${JSON.stringify({ ...rec, replica })}\n`);
+        fs.appendFileSync(file, `${JSON.stringify({ ...rec, replica, ...(execution ? { execution } : {}) })}\n`);
         return true;
     }
     catch {
@@ -98,6 +104,11 @@ function readSessionContext(root) {
                 const r = JSON.parse(s);
                 if (r && typeof r === 'object' && (r.kind === 'client' || r.kind === 'usage')
                     && typeof r.sessionKey === 'string' && typeof r.ts === 'string') {
+                    if ('execution' in r) {
+                        r.execution = (0, execution_context_1.validateExecution)(r.execution);
+                        if (name !== sessionContextFilename(r.execution.replicaId) || r.replica !== r.execution.replicaId)
+                            continue;
+                    }
                     out.push({ r: r, i: i++ });
                 }
             }
@@ -114,24 +125,31 @@ function readSessionContext(root) {
  * session has one identity; a root-less call defers rather than consumes the chance.
  */
 function makeSessionStamper(info, append = appendSessionContext, sessionKey = `mcp-${process.pid}`) {
-    let stamped = false;
+    const stamped = new Set();
     return (root) => {
-        if (stamped || typeof root !== 'string' || root === '')
+        if (typeof root !== 'string' || root === '')
             return;
         try {
+            const execution = (0, execution_context_1.executionForRoot)(root);
+            const key = execution ? JSON.stringify(execution) : 'legacy';
+            if (stamped.has(key))
+                return;
             const v = (() => { try {
                 return info();
             }
             catch {
                 return undefined;
             } })();
-            stamped = append(root, {
+            const success = append(root, {
                 kind: 'client',
                 sessionKey,
                 client: v?.name ?? 'unknown',
                 clientVersion: v?.version ?? 'unknown',
                 ts: new Date().toISOString(),
+                ...(execution ? { execution } : {}),
             });
+            if (success)
+                stamped.add(key);
         }
         catch { /* observation must never break the observed call */ }
     };

package/dist/holmes/guardrail/risk-classifier.js

@@ -8,7 +8,7 @@ exports.classifyArchitectureReversal = classifyArchitectureReversal;
 exports.classifySecret = classifySecret;
 exports.classifyBlastRadius = classifyBlastRadius;
 exports.assessRisk = assessRisk;
-// @implements A-SPEC-125.1
+// @implements A-SPEC-125.1, A-SPEC-627
 const risk_types_1 = require("./risk-types");
 const AWS_KEY_RE = /AKIA[0-9A-Z]{16}/;
 const PEM_KEY_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----/;
@@ -263,7 +263,7 @@ function scopeAxToProject(cmd, projectRoot) {
 // 'echo x > .ax/approvals/grants/forged.json' passed while the Write gate refused the same file —
 // the exact two-copies drift this repository has paid for with isTestFile and a restated section
 // splitter. The directories are now written once; each rule keeps its own shape around them.
-const PROTECTED_AX_ALT = 'specs|decisions|ledger|cpg_cache|state|roles|approvals';
+const PROTECTED_AX_ALT = 'specs|decisions|ledger|cpg_cache|state|roles|approvals|entities';
 const PROTECTED_AX_PATH_RE = new RegExp(String.raw `(^|/)\.ax/(${PROTECTED_AX_ALT})(/|$)`);
 // A removal verb + a protected .ax path anywhere in a shell command — the command form of
 // the governance-path delete, which the structured `kind:'delete'` branch alone would miss.

package/dist/holmes/guardrail/write-target.js

@@ -45,7 +45,7 @@ exports.protectedFileKindOf = protectedFileKindOf;
 exports.protectedKindOf = protectedKindOf;
 exports.shellSegments = shellSegments;
 exports.resolvesInside = resolvesInside;
-// @implements A-SPEC-163
+// @implements A-SPEC-163, A-SPEC-627
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
@@ -193,6 +193,7 @@ const PROTECTED_DIRS = [
     path.join('.ax', 'roles'),
     path.join('.ax', 'cpg_cache'),
     path.join('.ax', 'state'),
+    path.join('.ax', 'entities'),
     '.claude',
 ];
 /**

package/dist/holmes/hooks/pre-tool-use.js

@@ -46,6 +46,8 @@ exports.wiredSpecsDir = wiredSpecsDir;
 exports.evaluateHook = evaluateHook;
 exports.readSpecsSync = readSpecsSync;
 // @implements A-SPEC-278
+// @implements A-SPEC-643
+// @implements A-SPEC-642
 // @implements A-SPEC-194, A-SPEC-195
 const registry_1 = require("../messages/registry");
 const root_1 = require("../project/root");
@@ -410,7 +412,6 @@ exports.DEFAULT_SPECS_DIR = '.ax/specs';
 function evaluateHook(input, specsDir, opts) {
     // @implements A-SPEC-133 — resolved once so every gate in this call shares one timestamp.
     const nowTs = opts?.now ?? new Date().toISOString();
-    const ledgerFile = path.join(opts.projectRoot, '.ax', 'ledger', 'provenance.jsonl');
     // @implements A-SPEC-125.4
     // Bash/shell risk gate: this branch runs BEFORE the Write/Edit phaseCheck logic below and
     // is intentionally fail-CLOSED — a classifier throw on the Bash surface denies, never
@@ -483,6 +484,16 @@ function evaluateHook(input, specsDir, opts) {
             // creating `.ax/ledger` is the wiring working, not a plant. Refusing there would deny the
             // first legitimate use in every new project. The single-use guarantee still holds: the record
             // lands in the resolved root, which is the same file every later call resolves to.
+            // @implements A-SPEC-643 — the writer's replica chain, resolved only on this path so ordinary hook
+            // calls leave no footprint; the spent check below still spans every chain in the directory.
+            const ledgerFile = (0, ledger_store_2.writerChainFile)(path.join(opts.projectRoot, '.ax', 'ledger'));
+            // @implements A-SPEC-642 — a covered command is still denied, and no nonce spent, while the
+            // merged ledger holds an unreconciled cross-replica double-spend; the reason names the exit.
+            {
+                const conflict = (0, ledger_store_2.ledgerConflictReason)(path.dirname(ledgerFile));
+                if (conflict)
+                    return deny(conflict);
+            }
             if ((0, provenance_chain_1.blankNonce)(acting?.nonce)) {
                 return deny('the approval declared single-use (nonce) but the value is empty — single-use cannot be enforced, so it is denied');
             }

package/dist/holmes/hooks/stop.js

@@ -53,6 +53,8 @@ exports.guardCountOrZero = guardCountOrZero;
 exports.readGuardCount = readGuardCount;
 exports.writeGuardCount = writeGuardCount;
 const fs = __importStar(require("node:fs"));
+// @implements A-SPEC-645
+// @implements A-SPEC-642
 const npx_bin_1 = require("../project/npx-bin");
 const approval_queue_1 = require("../governance/approval-queue");
 const dependency_delta_1 = require("../guardrail/dependency-delta");
@@ -68,6 +70,7 @@ const cycle_detect_1 = require("../cpg/cycle-detect");
 const provenance_chain_1 = require("../governance/provenance-chain");
 const test_evidence_1 = require("../review/test-evidence");
 const test_outcomes_1 = require("../review/test-outcomes");
+const display_id_aliases_1 = require("../governance/display-id-aliases");
 const config_1 = require("../config/config");
 const pre_tool_use_1 = require("./pre-tool-use");
 const governance_history_1 = require("../guardrail/governance-history");
@@ -501,8 +504,12 @@ function evaluateStop(specs, evidence) {
     // Tampered audit trail blocks finishing — wires the provenance chain's verify into the live gate
     // (review finding: verify() previously had no product caller, so the chain's guarantee was inert).
     if (evidence?.provenance && !evidence.provenance.ok) {
-        problems.push(`[ART-2] provenance chain broken at seq ${evidence.provenance.brokenAt}: ${evidence.provenance.detail}`);
-        structured.push({ article: 'ART-2', detail: `provenance chain broken at seq ${evidence.provenance.brokenAt}: ${evidence.provenance.detail}` });
+        // @implements A-SPEC-642 — a cross-replica double-spend has no sequence; "seq undefined" hid that.
+        const provenanceDetail = evidence.provenance.brokenAt === undefined
+            ? `provenance ledger conflict: ${evidence.provenance.detail}`
+            : `provenance chain broken at seq ${evidence.provenance.brokenAt}: ${evidence.provenance.detail}`;
+        problems.push(`[ART-2] ${provenanceDetail}`);
+        structured.push({ article: 'ART-2', detail: provenanceDetail });
     }
     // @implements A-SPEC-191 (§4a) — an existing-but-unreadable findings ledger is not a clean turn:
     // it may hold an open critical, and a "clean" verdict here would also CLEAR standing ART-7 debt.
@@ -913,7 +920,11 @@ if (require.main === module) {
                 if (redFirstMode !== 'off') {
                     const head = (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: stopProjectRoot(), stdio: ['ignore', 'pipe', 'ignore'], env: (0, root_1.cleanSubprocessEnv)() }).toString().trim();
                     changedAspecs = changedAnchoredAspecs(stopProjectRoot());
-                    outcomesByAspec = (0, test_outcomes_1.groupOutcomesByAspec)((0, test_outcomes_1.readOutcomes)(stopProjectRoot()), head);
+                    // @implements A-SPEC-645 — a renumbered A-SPEC keeps its red-first evidence: records are
+                    // grouped under the display id the entity carries now, per the ledger's rename records.
+                    const { FileLedgerStore: LedgerForAliases } = require('../governance/ledger-store');
+                    const canonical = (0, display_id_aliases_1.displayIdCanonicalizer)(new LedgerForAliases(path.join(stopProjectRoot(), '.ax', 'ledger')).loadAll());
+                    outcomesByAspec = (0, test_outcomes_1.groupOutcomesByAspec)((0, test_outcomes_1.readOutcomes)(stopProjectRoot()), head, canonical);
                 }
             }
             catch {

package/dist/holmes/mcp/handlers/adoption.d.ts

@@ -0,0 +1,118 @@
+import { Spec } from '../../spec/spec-parser';
+import { SpecStore } from '../../spec/spec-store';
+import { DraftResult } from '../../reverse/draft';
+import { AnchorMapping } from '../../reverse/anchor';
+export interface AdoptionContext {
+    listSpecs(): Promise<Spec[]>;
+    writeSpec: SpecStore['write'];
+    assertReadableRoot(tool: string, root: string): void;
+    occupiedTarget(specs: Spec[]): string | undefined;
+}
+export declare function createAdoptionHandlers(context: AdoptionContext): {
+    /**
+     * Read-only inventory of a brownfield target: candidate clusters, coverage, and what the scan
+     * could not resolve. Deliberately does NOT call assertRepoTopLevel — a target that is not a git
+     * repository is a supported case here, reported as `isGit: false`.
+     */
+    reverse_scan(a: {
+        root: string;
+        maxFlagged?: number;
+    }): Promise<{
+        root: string;
+        isGit: boolean;
+        scanned: number;
+        droppedUntracked: number;
+        candidates: number;
+        anchored: number;
+        unanchored: number;
+        clusters: import("../../reverse/cluster").Cluster[];
+        testClusters: import("../../reverse/cluster").Cluster[];
+        coverage: {
+            structurallyResolved: number;
+            inTestClusters: number;
+            cohesionUnmeasured: number;
+            testsMatched: number;
+            testsUnmatched: number;
+            withDynamicIndicators: number;
+            indicators: Partial<Record<import("../../reverse/dynamic-wiring").Indicator, number>>;
+            uncalibratedIndicatorLanguages: string[];
+            ignoreUnsupportedPatterns: string[];
+        };
+        needsHumanConfirmation: import("../../reverse/scan").FlaggedFile[];
+        tests: import("../../reverse/test-map").TestMapping;
+    }>;
+    /**
+     * Draft H-SPEC/A-SPEC/T-SPEC documents for the recovered clusters under an EXISTING parent REQ.
+     *
+     * The REQ is the human's to write and this tool refuses without one — a requirement states
+     * business intent, which is not in the code. Everything emitted is `status: draft`, and writing
+     * requires an explicit `dryRun: false`.
+     *
+     * WHERE THE DOCUMENTS LAND: in the SERVER's configured spec store (`HOLMES_SPECS`, default
+     * `.ax/specs` relative to the server's working directory) — not inside `root`. In the intended
+     * adoption the two are the same directory, because the server runs inside the target it governs;
+     * pointing `root` at a different repository drafts that repository's slices into THIS store,
+     * which is a governance decision the caller has to make deliberately.
+     */
+    reverse_draft(a: {
+        root: string;
+        parentReqId?: string;
+        cluster?: string;
+        dryRun?: boolean;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        availableClusters?: undefined;
+        dryRun?: undefined;
+        parentReqId?: undefined;
+        clusters?: undefined;
+        drafted?: undefined;
+        skipped?: undefined;
+        refused?: undefined;
+    } | {
+        ok: boolean;
+        reason: string;
+        availableClusters: string[];
+        dryRun?: undefined;
+        parentReqId?: undefined;
+        clusters?: undefined;
+        drafted?: undefined;
+        skipped?: undefined;
+        refused?: undefined;
+    } | {
+        ok: boolean;
+        dryRun: boolean;
+        parentReqId: string;
+        clusters: number;
+        drafted: DraftResult[];
+        skipped: {
+            clusterKey: string;
+            reason: string;
+        }[];
+        refused: {
+            clusterKey: string;
+            reason: string;
+            findings?: unknown[];
+        }[];
+        reason?: undefined;
+        availableClusters?: undefined;
+    }>;
+    /**
+     * Insert `@implements` anchors into source files. Dry-run by DEFAULT, and anchoring to a
+     * non-approved A-SPEC is refused — a reverse-engineered draft describes code; description does
+     * not confer approval.
+     */
+    reverse_anchor(a: {
+        root: string;
+        mapping: AnchorMapping[];
+        dryRun?: boolean;
+    }): Promise<{
+        blockers: Record<string, string>;
+        applied: number;
+        dryRun: boolean;
+        would: number;
+        failed: import("../../reverse/anchor").RefusedAnchor[];
+        edits: import("../../reverse/anchor").AnchorEdit[];
+        refused: import("../../reverse/anchor").RefusedAnchor[];
+    }>;
+};