@holmes-lab/holmes-kit 0.19.5 → 0.20.0

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

@@ -1,14 +1,10 @@
 import { SpecStore } from '../spec/spec-store';
 import { Spec } from '../spec/spec-parser';
-import { MaintenanceGroundTruth, MaintenanceAnalysis } from './maintenance-analyze';
-import { Action } from '../guardrail/phase';
 import { ScannedFile } from '../cpg/cpg-scanner';
 import { type DecisionRecord, type DecisionCitation } from '../rtm/rtm-builder';
 import { Basis } from './basis';
-import { Finding } from '../review/findings';
-import { Approval, Enforcement } from '../guardrail/risk-gate';
+import { Approval } from '../guardrail/risk-gate';
 import { Elicitor } from './elicit-approval';
-import { RiskAction } from '../guardrail/risk-types';
 /**
  * @implements A-SPEC-189 §7 (round 10)
  * A DELIBERATE refusal, distinguished by construction rather than by class.
@@ -27,8 +23,6 @@ export declare class HandlerRefusal extends Error {
 /** Marker test that survives realm boundaries (jest's instanceof does not). */
 export declare function isHandlerRefusal(e: unknown): e is Error;
 import { ChangeSourceInfo } from '../project/change-source';
-import { DraftResult } from '../reverse/draft';
-import { AnchorMapping } from '../reverse/anchor';
 /**
  * @implements A-SPEC-156
  * Basis is attached HERE, in one place, rather than inside each handler. Measured reasoning: 25
@@ -39,6 +33,7 @@ import { AnchorMapping } from '../reverse/anchor';
 export interface ElicitOpts {
     elicit?: Elicitor;
     clientName?: () => string;
+    observeInvocation?: (root: string) => void | Promise<void>;
 }
 /**
  * @implements A-SPEC-299
@@ -67,7 +62,593 @@ export declare function collectDecisions(root: string, scanned: readonly Scanned
     citations: DecisionCitation[];
 };
 declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
-    spec_create(a: any): Promise<{
+    entity_integrate(a: {
+        root?: string;
+        operation?: string;
+        base?: string;
+        left?: string;
+        right?: string;
+        operationId?: string;
+        plan?: unknown;
+    }): Promise<{
+        ok: true;
+        state: "completed";
+        operationId: string;
+    } | {
+        ok: true;
+        state: "abandoned";
+        operationId: string;
+        restored: string[];
+        untouched: string[];
+        preserved: string[];
+    } | {
+        ok: true;
+        record: import("../spec/entity-integration-discharge").DerivedDischargeRecord;
+        alreadyDischarged: boolean;
+    } | {
+        ok: boolean;
+        obligations: import("../spec/entity-integration-discharge").DerivedObligationStatus[];
+        plan?: undefined;
+        target?: undefined;
+        executable?: undefined;
+        code?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        plan: import("../spec/entity-integration-transaction").EntityIntegrationRecoveryInspection;
+        target: string;
+        executable: boolean;
+        obligations?: undefined;
+        code?: undefined;
+        reason?: undefined;
+    } | {
+        blockers: string[];
+        target?: string | undefined;
+        plan?: import("../spec/entity-integration-transaction").EntityIntegrationPlan | undefined;
+        preview: import("../spec/entity-integration-transaction").EntityIntegrationCandidate;
+        ok: boolean;
+        executable: boolean;
+        obligations?: undefined;
+        code?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+        obligations?: undefined;
+        plan?: undefined;
+        target?: undefined;
+        executable?: undefined;
+    }>;
+    entity_renumber(a: {
+        root?: string;
+        operation?: string;
+        changes?: import("../spec/entity-renumber").EntityRenumberChange[];
+        plan?: unknown;
+    }): Promise<{
+        ok: true;
+        state: "completed";
+        operationId: string;
+    } | {
+        restored: string[];
+        untouched: string[];
+        preserved: string[];
+        ok: true;
+        state: "abandoned";
+        operationId: string;
+    } | {
+        ok: boolean;
+        plan: import("../spec/entity-renumber-transaction").EntityRenumberRecoveryPlan;
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+        plan?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        conflicts: string[];
+        plan?: undefined;
+        reason?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        ids: string[];
+        reason: string;
+        plan?: undefined;
+        conflicts?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        executable: boolean;
+        blockers: string[];
+        inputVersion: string;
+        preview: {
+            proposal: import("../spec/entity-renumber").EntityRenumberProposal;
+            sources: import("../spec/renumber").SourceRenumberInventory;
+            workspaceId: string;
+            storeId: string;
+            storeLocator: string;
+            registrationVersion: string;
+            entries: {
+                entityId: string;
+                documentLocator: string;
+                text: string;
+                mapping: string;
+                mappingVersion: string;
+            }[];
+            referenceNamespaces: {
+                entityId: string;
+                displayId: string;
+                storeId: string;
+                workspaceId: string;
+            }[];
+            schema: string;
+        };
+        plan?: undefined;
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        executable: boolean;
+        plan: import("../spec/entity-renumber-transaction").EntityRenumberPlan;
+        blockers: never[];
+        recoveryAvailable: boolean;
+        inputVersion: string;
+        preview: {
+            proposal: import("../spec/entity-renumber").EntityRenumberProposal;
+            sources: import("../spec/renumber").SourceRenumberInventory;
+            workspaceId: string;
+            storeId: string;
+            storeLocator: string;
+            registrationVersion: string;
+            entries: {
+                entityId: string;
+                documentLocator: string;
+                text: string;
+                mapping: string;
+                mappingVersion: string;
+            }[];
+            referenceNamespaces: {
+                entityId: string;
+                displayId: string;
+                storeId: string;
+                workspaceId: string;
+            }[];
+            schema: string;
+        };
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+    }>;
+    entity_store(a: {
+        root?: string;
+        operation?: string;
+        plan?: unknown;
+    }): Promise<{
+        ok: true;
+        state: "active";
+        storeLocator: string;
+        storeId: string;
+    } | {
+        ok: true;
+        state: "legacy";
+        storeLocator: string;
+        storeId?: undefined;
+    } | {
+        ok: boolean;
+        plan: import("../spec/entity-store").EntityAdoptionPlan;
+        code?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        plan: {
+            sourceOwner?: {
+                token: string;
+                version: string;
+            } | undefined;
+            lockOwner?: {
+                token: string;
+                version: string;
+            } | undefined;
+            schema: "holmes-entity-recovery/1";
+            workspaceId: string;
+            storeLocator: string;
+            operations: ({
+                operationId: string;
+                kind: "aborted";
+                storeId: string;
+                journalVersion: null;
+                state: "empty";
+                targets: Array<{
+                    locator: string;
+                    beforeVersion: string | null;
+                    afterVersion: string | null;
+                    currentVersion: string | null;
+                    state: "unchanged" | "applied" | "unapplied" | "conflict";
+                }>;
+                inventoryConflicts: string[];
+                leftovers: string[];
+            } | {
+                retired?: true | undefined;
+                operationId: string;
+                kind: "adoption" | "write" | "legacy-renumber";
+                storeId: string | null;
+                journalVersion: string;
+                state: string;
+                targets: {
+                    locator: string;
+                    beforeVersion: string | null;
+                    afterVersion: string | null;
+                    currentVersion: string | null;
+                    state: string;
+                }[];
+                inventoryConflicts: string[];
+                leftovers?: undefined;
+            })[];
+        };
+        code?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+        plan?: undefined;
+    }>;
+    workspace_identity(a: {
+        root: string;
+        operation?: import("../project/workspace-identity").IdentityOperation;
+    }): Promise<{
+        ok: true;
+        state: "legacy";
+    } | {
+        ok: true;
+        state: "initialized";
+        workspaceId: string;
+    } | {
+        ok: true;
+        state: "registered";
+        workspaceId: string;
+        replicaId: string;
+    } | {
+        ok: boolean;
+        reason: string;
+        code?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+    }>;
+    ledger_reconcile: (a: {
+        root?: string;
+        nonce: string;
+        rationale?: string;
+    }) => Promise<{
+        ok: boolean;
+        reason: string;
+        reconciled?: undefined;
+        nonce?: undefined;
+        pending?: undefined;
+        code?: undefined;
+        events?: undefined;
+        remaining?: undefined;
+    } | {
+        ok: boolean;
+        reconciled: boolean;
+        nonce: string;
+        pending: string[];
+        reason: string;
+        code?: undefined;
+        events?: undefined;
+        remaining?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+        reconciled?: undefined;
+        nonce?: undefined;
+        pending?: undefined;
+        events?: undefined;
+        remaining?: undefined;
+    } | {
+        ok: boolean;
+        reconciled: boolean;
+        nonce: string;
+        events: {
+            replicaId: string | null;
+            seq: number;
+            hash: string;
+            ts: string;
+        }[];
+        remaining: string[];
+        reason?: undefined;
+        pending?: undefined;
+        code?: undefined;
+    }>;
+    rtm_impact: (a: {
+        root: string;
+        changed: string[];
+    }) => Promise<{
+        breadthWarning?: string | undefined;
+        rankedImpact: {
+            file: string;
+            score: number;
+        }[];
+        reachedByDepth: number[];
+        bounded: {
+            id: string;
+            reason: "hub" | "depth";
+            inDegree?: number;
+        }[] | undefined;
+        summariesOmitted?: number | undefined;
+        impacted: string[];
+        impactedSummaries: {
+            id: string;
+            summary: string | null;
+        }[];
+    }>;
+    rtm_reindex: (a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+    }) => Promise<{
+        semanticWarm?: {
+            tier: string;
+            computed: number;
+            cached: number;
+        } | undefined;
+        changed: number;
+        nodes: number;
+        edges: number;
+        changeSource: ChangeSourceInfo;
+    }>;
+    context_bundle: (a: {
+        root: string;
+        seedId: string;
+        budget: number;
+    }) => Promise<import("../context/bundler").ContextBundle>;
+    review_scope: (a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+    }) => Promise<{
+        scopeFallback?: "full" | undefined;
+        unscannedChangedFiles: string[];
+        testScope: import("../rtm/test-scope").TestScope;
+        changeSource: ChangeSourceInfo;
+        changedSymbols: string[];
+        impactedSpecs: string[];
+        acceptanceCriteria: Array<{
+            specId: string;
+            criteria: string;
+        }>;
+        unrequestedSymbols: string[];
+        coverageGaps: string[];
+        obligationGaps: string[];
+    }>;
+    review_prepare: (a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+        budget?: number;
+    }) => Promise<{
+        scopeFallback?: "full" | undefined;
+        package: import("../review/package").ReviewPackage;
+        unscannedChangedFiles: string[];
+        changeSource: ChangeSourceInfo;
+    }>;
+    review_record: (a: {
+        root: string;
+        findings: import("../review/findings").Finding[];
+    }) => Promise<{
+        recorded: number;
+    }>;
+    review_status: (a: {
+        root: string;
+    }) => Promise<{
+        blocked: boolean;
+        open: {
+            critical: number;
+            important: number;
+            minor: number;
+        };
+        reviewNeeded: import("../review/review-targets").ReviewNeeded[];
+    }>;
+    risk_check: (a: {
+        root?: string;
+        action: import("../guardrail/risk-types").RiskAction;
+        approval?: Approval;
+        changedSymbols?: string[];
+        enforcement?: import("../guardrail/risk-gate").Enforcement;
+        ts: string;
+        actor?: string;
+        rationale?: string;
+    }) => Promise<{
+        assessment: import("../guardrail/risk-types").RiskAssessment;
+        gate: import("../guardrail/risk-gate").GateResult;
+    }>;
+    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;
+    }>;
+    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: import("../reverse/draft").DraftResult[];
+        skipped: {
+            clusterKey: string;
+            reason: string;
+        }[];
+        refused: {
+            clusterKey: string;
+            reason: string;
+            findings?: unknown[];
+        }[];
+        reason?: undefined;
+        availableClusters?: undefined;
+    }>;
+    reverse_anchor: (a: {
+        root: string;
+        mapping: import("../reverse/anchor").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[];
+    }>;
+    spec_slice_init: (a: {
+        root?: string;
+        sliceName: string;
+        title: string;
+        objective: string;
+        filesToTouch: string[];
+    }) => Promise<{
+        ok: boolean;
+        specsCreated: string[];
+        unreadable: string[];
+    }>;
+    spec_slice_approve: (a: {
+        root?: string;
+        sliceName: string;
+    }) => Promise<{
+        ok: boolean;
+        approvedSpecs: string[];
+        alreadySealed: string[];
+        refused: {
+            id: string;
+            reason: string;
+        }[];
+    }>;
+    spec_remediate: (a: {
+        root?: string;
+        targetFile?: string;
+        aspecId?: string;
+    }) => Promise<{
+        ok: boolean;
+        actionsTaken: string[];
+        refused: {
+            id: string;
+            reason: string;
+        }[];
+    }>;
+    maintenance_outcome(a: {
+        root: string;
+        digest: string;
+        actualFiles?: string[];
+        actualSymbols?: string[];
+        actualTests?: string[];
+        actualClassification?: string;
+    }): Promise<import("./maintenance-evidence").EvidenceArtifact>;
+    impact_gate_check(a: {
+        root: string;
+        target: string;
+        digest?: string;
+    }): Promise<import("../guardrail/impact-gate").EditEvidenceVerdict>;
+    maintenance_calibration(a: {
+        root: string;
+        minSamples?: number;
+    }): Promise<{
+        artifacts: number;
+        unreadable: string[];
+        skippedSchema: number;
+        schema: string;
+        n: number;
+        withoutClassification: number;
+        bins: import("./maintenance-evidence").CalibrationBin[];
+        brierScore: number | null;
+        falsePositives: number;
+        falseNegatives: number;
+        minSamples: number;
+        status: "measured" | "insufficient-data";
+    }>;
+    spec_create: (a: any) => Promise<{
         ok: boolean;
         reason: string;
         created?: undefined;
@@ -76,7 +657,7 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok?: undefined;
         reason?: undefined;
     }>;
-    spec_validate(a: any): Promise<{
+    spec_validate: (a: any) => Promise<{
         ok: boolean;
         findings: {
             level: string;
@@ -84,32 +665,9 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
             message: any;
         }[];
     }>;
-    /**
-     * @implements A-SPEC-132
-     * Approval as an ACT: validate → seal → flip → ledger, in one call. This is the designed
-     * reversal of "no approval tool exists" (which promote-slice documented while it was true) —
-     * the act now includes digest computation a hand edit cannot perform honestly. Fail-closed on
-     * the SERVER-environment approval: nothing in the request payload can substitute, because the
-     * agent authors the payload and the operator authors the environment.
-     */
-    /**
-     * @implements A-SPEC-184
-     * Raise ONE named document from an older spec format to the current one.
-     *
-     * The compatibility policy this implements: older documents are read and left alone by default,
-     * and rise only when a human points at the one they intend to use. There is deliberately no bulk
-     * path — 155 documents here and 90 in the measured adoption target, and which of them are still
-     * live specifications is a judgement only a person holds.
-     *
-     * It declares a KIND. It does not confer approval: 37 of this repository's legacy documents read
-     * `status: Approved`, and carrying that across would mint approvals that never passed the sealing
-     * act. The old value is preserved as evidence and the document restarts at `draft`.
-     *
-     * Takes no `root`: the store is bound at server construction, exactly as `spec_create` is.
-     */
-    spec_upgrade(a: {
+    spec_upgrade: (a: {
         id: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         upgraded?: undefined;
@@ -131,28 +689,11 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         remaining: import("../spec/validator").Finding[];
         reason?: undefined;
     }>;
-    /**
-     * Move a document to `outdated` — the only path there.
-     *
-     * @implements A-SPEC-222
-     * `outdated` was in SPEC_STATUSES with no code writing it and no document carrying it: a
-     * declared state nothing could reach. That mattered the moment 23 deprecated REQs needed
-     * cleaning up, because the only transition tool sends everything to `draft`, and calling a
-     * retired document "draft" is a worse lie than the non-canonical word it replaced.
-     *
-     * Retirement withdraws authority rather than granting it, so it does NOT need the approval key
-     * by default. Two cases invert that, and the threshold follows the RISK rather than the name of
-     * the act:
-     *
-     *  - A sealed document. The code gate demands an approved T-SPEC naming the target A-SPEC;
-     *    retiring that T-SPEC removes the demand. Unguarded, retirement is an approval bypass.
-     *  - A document an APPROVED spec depends on. That chain is holding something up right now.
-     */
-    spec_retire(a: {
+    spec_retire: (a: {
         root?: string;
         id: string;
         reason?: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         retired?: undefined;
@@ -171,30 +712,12 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         dependents: string[];
         reason?: undefined;
     }>;
-    /**
-     * @implements A-SPEC-538.1
-     * The inverse of spec_approve: returns a SEALED (approved) spec to an editable `draft`, clearing
-     * `approved_digest` and `parent_digests` in ONE act, and records `spec-unsealed`. Hand-editing
-     * only `status` leaves seal residue that later trips validation; this atomizes the reverse.
-     *
-     * Un-sealing WITHDRAWS a seal, so — like retiring a sealed document — it demands a covering
-     * out-of-band HOLMES_APPROVAL (fail-closed): un-sealing an approved T-SPEC removes the code
-     * gate's demand, so an unguarded un-seal would be an approval bypass. And it refuses when an
-     * APPROVED spec depends on the target, because that dependent's `parent_digests` — the snapshot
-     * drift detection compares against — would silently go stale.
-     */
-    spec_renumber(a: {
+    spec_renumber: (a: {
         root?: string;
         oldBase: string;
         newBase: string;
         dryRun?: boolean;
-    }): Promise<{
-        ok: boolean;
-        reason: string;
-        dryRun?: undefined;
-        plan?: undefined;
-        movedSpecs?: undefined;
-    } | {
+    }) => Promise<{
         ok: boolean;
         dryRun: boolean;
         plan: import("../spec/renumber").RenumberPlan;
@@ -206,11 +729,14 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         movedSpecs: number;
         plan: import("../spec/renumber").RenumberPlan;
         reason?: undefined;
+    } | {
+        ok: boolean;
+        reason: string;
     }>;
-    spec_unseal(a: {
+    spec_unseal: (a: {
         root?: string;
         id: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         unsealed?: undefined;
@@ -229,30 +755,28 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         dependents: string[];
         reason?: undefined;
     }>;
-    /**
-     * @implements A-SPEC-538.2
-     * Read-only: report a spec's approval/seal state — sealed?, approved_digest, each parent's seal
-     * state, and the concrete blockers still standing between it and approval — so a caller need not
-     * parse files to ask "what is the approval state right now". Reuses `sealOf` and `approvalBlockers`
-     * (the same predicates the code gate and spec_approve read) so the report cannot drift from the
-     * acts it describes. No writes, no ledger append.
-     */
-    approval_status(a: {
+    approval_status: (a: {
         root?: string;
         id: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
     } | {
         graphPreview?: {
             impact?: import("../rtm/impact-advisory").ImpactAdvisory;
-            density?: import("../rtm/anchor-density").AnchorDensityFinding[];
+            density?: Array<import("../rtm/anchor-density").AnchorDensityFinding>;
             cycles?: {
-                findings: import("../cpg/cycle-detect").CycleFinding[];
+                findings: Array<import("../cpg/cycle-detect").CycleFinding>;
                 note: string;
             };
-            architecture?: import("../cpg/arch-observe").ArchObservation[];
+            architecture?: Array<import("../cpg/arch-observe").ArchObservation>;
             graphAsOf?: string;
+            graph?: {
+                status: "current" | "stale" | "unverified";
+                sourceCommit: string | null;
+                head: string | null;
+            };
+            unavailable?: "empty" | "unreadable";
         } | undefined;
         id: string;
         type?: string;
@@ -261,21 +785,14 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         approvedDigest?: string;
         parents: import("../spec/approval-status").ParentApproval[];
         blockers: string[];
+        resealBlockers: string[];
         ok: boolean;
         reason?: undefined;
     }>;
-    /**
-     * @implements A-SPEC-538.3
-     * Read-only: return the provenance ledger's events in time order (optionally narrowed to one
-     * spec) so the governance history — approved / unsealed / retired / review-needed … — is legible
-     * at a glance without reading raw JSONL. Reuses FileLedgerStore.loadAll(); the ordering/filtering/
-     * projection is the pure `timelineFrom`. No writes. An absent ledger is an empty history, not an
-     * error.
-     */
-    ledger_timeline(a: {
+    ledger_timeline: (a: {
         root?: string;
         id?: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         events?: undefined;
@@ -284,10 +801,10 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         events: import("../governance/ledger-timeline").TimelineEntry[];
         reason?: undefined;
     }>;
-    rtm_dashboard(a: {
+    rtm_dashboard: (a: {
         root?: string;
         port?: number;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         url?: undefined;
@@ -300,35 +817,41 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         census: import("../server/dashboard-launcher").DashboardCensus;
         reason?: undefined;
     }>;
-    spec_approve(a: {
+    spec_approve: (a: {
         root?: string;
         id: string;
-    }): Promise<{
-        ok: boolean;
+    }) => Promise<{
+        ok: false;
         reason: string;
-        findings?: undefined;
-        conflict?: undefined;
+        findings: import("../spec/validator").Finding[];
+        candidate?: undefined;
+        digest?: undefined;
+        parentDigests?: undefined;
     } | {
         ok: boolean;
         reason: string;
-        findings: import("../spec/validator").Finding[];
         conflict?: undefined;
     } | {
         ok: boolean;
         reason: string;
         conflict: import("../spec/version-conflict").ConflictDetail;
-        findings?: undefined;
     } | {
+        impactAdvisoryUnavailable?: "empty" | "unreadable" | undefined;
+        impactGraph?: {
+            status: "current" | "stale" | "unverified";
+            sourceCommit: string | null;
+            head: string | null;
+            graphAsOf?: string;
+        } | undefined;
         anchorDensity?: import("../rtm/anchor-density").AnchorDensityFinding[] | undefined;
         impactAdvisory?: import("../rtm/impact-advisory").ImpactAdvisory | undefined;
         approved: string;
         digest: string;
         ok?: undefined;
         reason?: undefined;
-        findings?: undefined;
         conflict?: undefined;
     }>;
-    spec_list(a: any): Promise<{
+    spec_list: (a: any) => Promise<{
         specs: {
             legacy?: boolean | undefined;
             parent?: string | undefined;
@@ -337,14 +860,14 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
             status: "draft" | "review" | "approved" | "outdated";
         }[];
     }>;
-    spec_next(): Promise<{
+    spec_next: () => Promise<{
         next: import("../spec/spec-types").SpecType;
     } | {
         next: null;
     }>;
-    rtm_check(a?: {
+    rtm_check: (a?: {
         root?: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         issues?: undefined;
@@ -363,20 +886,11 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         reason?: undefined;
         gaps?: undefined;
     }>;
-    /**
-     * Pin a REQ's citations: compute the content digest of every cited source that resolves inside
-     * the repo and record it as `rev`, so an author never hashes a file by hand and the digest is
-     * always derived from what is actually on disk.
-     *
-     * Explicit-invocation only, dry-run by DEFAULT, and never overwrites an existing digest — a
-     * re-pin would replace evidence of upstream drift with a fresh-looking value, converting the
-     * detector into a concealer.
-     */
-    citation_pin(a: {
+    citation_pin: (a: {
         root: string;
         id: string;
         dryRun?: boolean;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         id?: undefined;
@@ -393,9 +907,9 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         citations: unknown[];
         reason?: undefined;
     }>;
-    phase_status(a: {
+    phase_status: (a: {
         root?: string;
-    }): Promise<{
+    }) => Promise<{
         ok: boolean;
         reason: string;
         specs?: undefined;
@@ -410,18 +924,18 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok?: undefined;
         reason?: undefined;
     }>;
-    phase_check(a: {
-        action?: Action;
+    phase_check: (a: {
+        action?: import("../guardrail/phase").Action;
         target: string;
         targetAspecId?: string;
-    }): Promise<import("../guardrail/phase").CheckResult | {
+    }) => Promise<import("../guardrail/phase").CheckResult | {
         decision: string;
         note: string;
     }>;
-    cpg_scan(a: {
+    cpg_scan: (a: {
         root: string;
         lints?: boolean;
-    }): Promise<{
+    }) => Promise<{
         files: number;
         symbols: number;
         skipped: {
@@ -451,17 +965,10 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         }[];
         skippedCount: number;
     }>;
-    /**
-     * @implements A-SPEC-138
-     * Call-graph taint REACHABILITY screen: source-named functions that reach sink-named functions
-     * through call edges. A SCREENING signal that routes a security review, NOT a data-flow proof —
-     * the result always carries the honesty envelope (kind + limits) and phrases pairs as "reaches",
-     * never "vulnerable".
-     */
-    taint_scan(a: {
+    taint_scan: (a: {
         root: string;
         dataFlow?: boolean;
-    }): Promise<{
+    }) => Promise<{
         kind: string;
         limits: ("name-based matching" | "no def-use" | "no sanitizers" | "call-edge-only")[];
         maxPaths: number | undefined;
@@ -473,12 +980,10 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
     } | {
         dataFlow: {
             findings: Record<string, unknown>[];
-            /** Findings the reaching-definition evidence positively refuted (dead or fully sanitized). */
             refutedByReachingDefs: number;
             limits: ("no field sensitivity (obj.a and obj.b are one value)" | "no aliasing" | "no path sensitivity" | "no container/element tracking" | "no reflection or dynamic dispatch" | "sink matching is by callee NAME with no receiver type — RE.exec(s) is indistinguishable from child_process.exec(s)" | "no anonymous-function parameters (arrow/function-expression params are not bound)" | "not statement-order sensitive — a variable tainted anywhere in a function is tainted throughout it" | "reports reachability of tainted data to a sink, never exploitability")[];
             converged: boolean;
             truncated: number;
-            /** Which languages this run could actually judge, so a zero is readable. */
             languagesAnalysed: (string | null)[];
         };
         kind: string;
@@ -489,14 +994,14 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok?: undefined;
         reason?: undefined;
     }>;
-    test_run(a: {
+    test_run: (a: {
         root: string;
         base?: string;
         head?: string;
         since?: string;
         mark?: string;
         mutate?: string;
-    }): Promise<{
+    }) => Promise<{
         mutate: {
             tspec: string;
             aspec: string | undefined;
@@ -528,298 +1033,22 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         changeSource: ChangeSourceInfo;
         mutate?: undefined;
     }>;
-    issue_localize(a: {
+    issue_localize: (a: {
         root: string;
         issue: string;
         topN?: number;
-    }): Promise<import("../rtm/localize").LocalizationReport>;
-    maintenance_analyze(a: {
+    }) => Promise<import("../rtm/localize").LocalizationReport>;
+    maintenance_analyze: (a: {
         root: string;
         request: string;
         historyLimit?: number;
         contextBudget?: number;
-        groundTruth?: MaintenanceGroundTruth;
+        groundTruth?: import("./maintenance-analyze").MaintenanceGroundTruth;
         persist?: boolean;
         changedFiles?: string[];
-    }): Promise<MaintenanceAnalysis & {
+    }) => Promise<import("./maintenance-analyze").MaintenanceAnalysis & {
         persistedTo?: string;
         bounded?: boolean;
     }>;
-    maintenance_outcome(a: {
-        root: string;
-        digest: string;
-        actualFiles?: string[];
-        actualSymbols?: string[];
-        actualTests?: string[];
-        actualClassification?: string;
-    }): Promise<import("./maintenance-evidence").EvidenceArtifact>;
-    impact_gate_check(a: {
-        root: string;
-        target: string;
-        digest?: string;
-    }): Promise<import("../guardrail/impact-gate").EditEvidenceVerdict>;
-    maintenance_calibration(a: {
-        root: string;
-        minSamples?: number;
-    }): Promise<{
-        artifacts: number;
-        unreadable: string[];
-        skippedSchema: number;
-        schema: string;
-        n: number;
-        withoutClassification: number;
-        bins: import("./maintenance-evidence").CalibrationBin[];
-        brierScore: number | null;
-        falsePositives: number;
-        falseNegatives: number;
-        minSamples: number;
-        status: "measured" | "insufficient-data";
-    }>;
-    rtm_impact(a: {
-        root: string;
-        changed: string[];
-    }): Promise<{
-        breadthWarning?: string | undefined;
-        rankedImpact: {
-            file: string;
-            score: number;
-        }[];
-        reachedByDepth: number[];
-        bounded: {
-            id: string;
-            reason: "hub" | "depth";
-            inDegree?: number;
-        }[] | undefined;
-        summariesOmitted?: number | undefined;
-        impacted: string[];
-        impactedSummaries: {
-            id: string;
-            summary: string | null;
-        }[];
-    }>;
-    rtm_reindex(a: {
-        root: string;
-        base?: string;
-        head?: string;
-        since?: string;
-    }): Promise<{
-        changed: number;
-        nodes: number;
-        edges: number;
-        changeSource: ChangeSourceInfo;
-        semanticWarm?: {
-            tier: string;
-            computed: number;
-            cached: number;
-        };
-    }>;
-    context_bundle(a: {
-        root: string;
-        seedId: string;
-        budget: number;
-    }): Promise<import("../context/bundler").ContextBundle>;
-    review_scope(a: {
-        root: string;
-        base?: string;
-        head?: string;
-        since?: string;
-    }): Promise<{
-        scopeFallback?: "full" | undefined;
-        unscannedChangedFiles: string[];
-        testScope: import("../rtm/test-scope").TestScope;
-        changeSource: ChangeSourceInfo;
-        changedSymbols: string[];
-        impactedSpecs: string[];
-        acceptanceCriteria: Array<{
-            specId: string;
-            criteria: string;
-        }>;
-        unrequestedSymbols: string[];
-        coverageGaps: string[];
-        obligationGaps: string[];
-    }>;
-    review_prepare(a: {
-        root: string;
-        base?: string;
-        head?: string;
-        since?: string;
-        budget?: number;
-    }): Promise<{
-        scopeFallback?: "full" | undefined;
-        package: import("../review/package").ReviewPackage;
-        unscannedChangedFiles: string[];
-        changeSource: ChangeSourceInfo;
-    }>;
-    review_record(a: {
-        root: string;
-        findings: Finding[];
-    }): Promise<{
-        recorded: number;
-    }>;
-    review_status(a: {
-        root: string;
-    }): Promise<{
-        blocked: boolean;
-        open: {
-            critical: number;
-            important: number;
-            minor: number;
-        };
-        reviewNeeded: import("../review/review-targets").ReviewNeeded[];
-    }>;
-    risk_check(a: {
-        root?: string;
-        action: RiskAction;
-        approval?: Approval;
-        changedSymbols?: string[];
-        enforcement?: Enforcement;
-        ts: string;
-        actor?: string;
-        rationale?: string;
-    }): Promise<{
-        assessment: import("../guardrail/risk-types").RiskAssessment;
-        gate: import("../guardrail/risk-gate").GateResult;
-    }>;
-    /**
-     * 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[];
-    }>;
-    spec_slice_init(a: {
-        root?: string;
-        sliceName: string;
-        title: string;
-        objective: string;
-        filesToTouch: string[];
-    }): Promise<{
-        ok: boolean;
-        specsCreated: string[];
-        unreadable: string[];
-    }>;
-    spec_slice_approve(a: {
-        root?: string;
-        sliceName: string;
-    }): Promise<{
-        ok: boolean;
-        approvedSpecs: string[];
-        alreadySealed: string[];
-        refused: {
-            id: string;
-            reason: string;
-        }[];
-    }>;
-    spec_remediate(a: {
-        root?: string;
-        targetFile?: string;
-        aspecId?: string;
-    }): Promise<{
-        ok: boolean;
-        actionsTaken: string[];
-        refused: {
-            id: string;
-            reason: string;
-        }[];
-    }>;
 };
 export {};