@sema-agent/core 5.57.0 → 5.58.0

package/dist/core/hooks.js

@@ -253,17 +253,7 @@ export function normalizeOrgGateVerdict(answer, unreadable) {
         return clean({ status: "unavailable", disclosures: [unreadable] });
     return clean({ status: "available", verdict: clean({ behavior: behavior, rule }), ...revisionCell });
 }
-export function normalizePersistedRuleHit(hit) {
-    if (typeof hit === "string")
-        return { hit: { rule: hit } };
-    if (!isPlainOwnRecord(hit))
-        return {};
-    if (ownDataValue(hit, "unreadable") === true)
-        return { unreadable: true };
-    const rule = ownDataValue(hit, "rule");
-    if (typeof rule !== "string")
-        return {};
-    const dots = ownDataValue(hit, "dots");
+function copiedUsableDots(dots) {
     let copied;
     try {
         if (Array.isArray(dots)) {
@@ -279,7 +269,53 @@ export function normalizePersistedRuleHit(hit) {
         copied = undefined;
     }
     const usable = copied?.every((d) => typeof d.actor === "string" && typeof d.counter === "number" && Number.isFinite(d.counter)) === true && copied.length > 0;
-    return { hit: { rule, ...(usable ? { dots: copied } : {}) } };
+    return usable ? { dots: copied } : {};
+}
+export function normalizePersistedRuleHit(hit) {
+    if (typeof hit === "string")
+        return { hit: { rules: [{ rule: hit }] } };
+    if (!isPlainOwnRecord(hit))
+        return {};
+    if (ownDataValue(hit, "unreadable") === true)
+        return { unreadable: true };
+    const rulesRaw = ownDataValue(hit, "rules");
+    if (rulesRaw === undefined) {
+        const coverageRaw = ownDataValue(hit, "segmentCoverage");
+        let rows;
+        try {
+            if (Array.isArray(coverageRaw)) {
+                const walked = [];
+                for (let i = 0; i < coverageRaw.length; i++) {
+                    const r = coverageRaw[i];
+                    walked.push(isPlainOwnRecord(r) ? { segment: ownDataValue(r, "segment"), covered: ownDataValue(r, "covered") } : { segment: undefined, covered: undefined });
+                }
+                rows = walked.every((r) => typeof r.segment === "string" && typeof r.covered === "boolean") ? walked : undefined;
+            }
+        }
+        catch {
+            rows = undefined;
+        }
+        return rows !== undefined && rows.length > 0 ? { coverage: rows.map((r) => ({ segment: r.segment, covered: r.covered })) } : {};
+    }
+    let members;
+    try {
+        if (Array.isArray(rulesRaw)) {
+            const walked = [];
+            for (let i = 0; i < rulesRaw.length; i++) {
+                const m = rulesRaw[i];
+                walked.push(isPlainOwnRecord(m) ? { rule: ownDataValue(m, "rule"), dots: ownDataValue(m, "dots") } : { rule: undefined, dots: undefined });
+            }
+            members = walked;
+        }
+    }
+    catch {
+        members = undefined;
+    }
+    if (members === undefined || members.length === 0)
+        return {};
+    if (!members.every((m) => typeof m.rule === "string"))
+        return {};
+    return { hit: { rules: members.map((m) => ({ rule: m.rule, ...copiedUsableDots(m.dots) })) } };
 }
 function preToolUseCrashReason(subject, err) {
     const raw = err instanceof Error ? err.message.trim() || err.name : String(err);
@@ -672,6 +708,7 @@ export async function runToolGate(input) {
         }
         const persistedRuleMandate = persistedRuleMandateOf(input);
         let personalEvidence = { dotsAbsent: input.persistedRules === undefined ? "not_wired" : "not_adjudicated" };
+        let laneCoverage;
         if (input.persistedRules &&
             !orgRealApprovalRequired &&
             decision.action === "ask" &&
@@ -689,21 +726,44 @@ export async function runToolGate(input) {
                 }
                 return await settleOrgVerdictWithin(pendingHit.then(normalizePersistedRuleHit).catch(() => ({ unreadable: true })), { unreadable: true }, { ...(input.abortSignal !== undefined ? { signal: input.abortSignal } : {}), timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS });
             })();
-            const hitEntry = answer.hit;
-            const hit = hitEntry?.rule;
+            const hitRules = answer.hit?.rules;
+            laneCoverage = answer.coverage;
             personalEvidence = { dotsAbsent: answer.unreadable === true ? "unavailable" : "no_match" };
-            if (hit !== undefined && persistedRuleMandate === undefined && decision.matchedAskRule === undefined) {
+            const disclosedRuleSet = (rules) => {
+                const shown = rules.slice(0, 5).map((r) => inlineUntrusted(r.rule, 200));
+                const rest = rules.length - shown.length;
+                return rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+            };
+            const unionDotsOf = (rules) => {
+                const seen = new Set();
+                const union = [];
+                for (const r of rules) {
+                    if (r.dots === undefined || r.dots.length === 0)
+                        return { dotsAbsent: "not_reported" };
+                    for (const d of r.dots) {
+                        const key = JSON.stringify([d.actor, d.counter]);
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            union.push(d);
+                        }
+                    }
+                }
+                return { dots: union };
+            };
+            if (hitRules !== undefined && persistedRuleMandate === undefined && decision.matchedAskRule === undefined) {
                 decision = {
                     action: "allow",
-                    message: `a persisted allow rule (${hit}) covers this call`,
+                    message: hitRules.length === 1
+                        ? `a persisted allow rule (${disclosedRuleSet(hitRules)}) covers this call`
+                        : `persisted allow rules (${disclosedRuleSet(hitRules)}) cover every segment of this call`,
                     decisionReason: "persisted_rule",
                     ...(policyRewrite !== undefined ? { updatedInput: policyRewrite } : {}),
                 };
-                await notifier.notifyAsync(() => input.persistedRules?.onResolved?.({ toolName: req.toolName, toolCallId, rule: hit }), "toolGate.persistedRuleResolved");
+                await notifier.notifyAsync(() => input.persistedRules?.onResolved?.({ toolName: req.toolName, toolCallId, rules: hitRules.map((r) => r.rule) }), "toolGate.persistedRuleResolved");
             }
-            else if (hit !== undefined) {
-                personalEvidence = hitEntry?.dots !== undefined && hitEntry.dots.length > 0 ? { dots: hitEntry.dots } : { dotsAbsent: "not_reported" };
-                const shownRule = inlineUntrusted(hit, 200);
+            else if (hitRules !== undefined) {
+                personalEvidence = unionDotsOf(hitRules);
+                const shownRule = disclosedRuleSet(hitRules);
                 const mandateNoun = persistedRuleMandate === "operator_always"
                     ? "this deployment mandates per-call confirmation for shell commands (shellGate: always)"
                     : persistedRuleMandate !== undefined
@@ -712,12 +772,14 @@ export async function runToolGate(input) {
                 decision = {
                     ...decision,
                     persistedRuleShadowed: shownRule,
-                    message: `${decision.message !== undefined ? `${decision.message} ` : ""}(a persisted allow rule (${shownRule}) matches this call but does not clear the ask — ${mandateNoun})`,
+                    message: hitRules.length === 1
+                        ? `${decision.message !== undefined ? `${decision.message} ` : ""}(a persisted allow rule (${shownRule}) matches this call but does not clear the ask — ${mandateNoun})`
+                        : `${decision.message !== undefined ? `${decision.message} ` : ""}(persisted allow rules (${shownRule}) match this call but do not clear the ask — ${mandateNoun})`,
                 };
             }
         }
         if (decision.action === "ask") {
-            decision = { ...decision, ruleEvidence: mintRuleEvidence(personalEvidence) };
+            decision = { ...decision, ruleEvidence: mintRuleEvidence(personalEvidence), ...(laneCoverage !== undefined ? { segmentCoverage: laneCoverage } : {}) };
         }
         if (input.autoMode &&
             !orgRealApprovalRequired &&
@@ -779,7 +841,7 @@ export async function runToolGate(input) {
             ? { origin: orgAskOrigin !== undefined ? `org_${orgAskOrigin}` : "policy" }
             : undefined;
         if (suspendAsk && decision.action === "ask") {
-            const suspended = await suspendAsk(req, currentInput, safety, undefined, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined);
+            const suspended = await suspendAsk(req, currentInput, safety, undefined, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined);
             if (suspended) {
                 if ("parkFailed" in suspended)
                     parkFailed = suspended.parkFailed;
@@ -798,7 +860,7 @@ export async function runToolGate(input) {
                     req.args = outcome.presentedInput;
                 }
                 if (suspendAsk && outcome.parkDeclined && parkFailed === undefined) {
-                    const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined);
+                    const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(decision), decision.action === "ask" ? decision.persistedRuleShadowed : undefined, decision.action === "ask" ? decision.decisionReason : undefined, decision.action === "ask" ? decision.probeReason : undefined, decision.action === "ask" ? decision.probeCause : undefined, decision.action === "ask" ? decision.segmentCoverage : undefined);
                     if (suspended) {
                         if ("parkFailed" in suspended)
                             parkFailed = suspended.parkFailed;
@@ -830,7 +892,7 @@ export async function runToolGate(input) {
                 askDenyResolution = resolved.resolution;
             decision = resolved;
             if (resolved.action === "deny" && resolved.approverUnavailable === true && suspendAsk && parkFailed === undefined) {
-                const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(askBeforeResolve), askBeforeResolve.action === "ask" ? askBeforeResolve.persistedRuleShadowed : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.decisionReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeCause : undefined);
+                const suspended = await suspendAsk(req, currentInput, safety, true, realApprovalOf(askBeforeResolve), askBeforeResolve.action === "ask" ? askBeforeResolve.persistedRuleShadowed : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.decisionReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeReason : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.probeCause : undefined, askBeforeResolve.action === "ask" ? askBeforeResolve.segmentCoverage : undefined);
                 if (suspended) {
                     if ("parkFailed" in suspended)
                         parkFailed = suspended.parkFailed;

package/dist/core/image-downsample.d.ts

@@ -36,7 +36,7 @@ export declare const IMAGE_MAX_HEIGHT = 2000;
  * replaced by an explanatory text block with the size + path; a within-limit image passes through unchanged.
  */
 /**
- * Optional image-resize seam (design/116 review CONFIRM-1, clay 拍 2026-07-02 加 seam 保体验): given an
+ * Optional image-resize seam (design/116 review CONFIRM-1, 裁定 2026-07-02 加 seam 保体验): given an
  * over-limit image, return a smaller re-encoded one — or undefined when it can't. CC resizes with sharp
  * (imageResizer.ts: fit within 2000x2000, JPEG quality ladder) so the model still SEES a degraded image;
  * core must not hard-depend on a native image library, so the capability is injected (or auto-detected).

package/dist/core/locked-config.d.ts

@@ -46,7 +46,7 @@ export interface LockedPreflight {
      *  always enforced, resolved ONCE here. With `toolPolicy` locked, the deployment's own
      *  `deps.toolPolicy` is the whole answer (a spec-supplied policy has already been refused). */
     toolPolicy: ToolPolicy | undefined;
-    /** F-012 (codex round 8): the effective resume-edit re-adjudication OVERRIDE, resolved lock-aware in
+    /** F-012: the effective resume-edit re-adjudication OVERRIDE, resolved lock-aware in
      *  the SAME slot as {@link toolPolicy}. With `toolPolicy` locked, a spec-supplied
      *  `basePolicyForResumeEdit` has already been refused wholesale, so this is the deployment's own
      *  `deps.basePolicyForResumeEdit` (or undefined — the caller-policy fallback then applies at the use

package/dist/core/lsp.d.ts

@@ -50,7 +50,7 @@ export interface LspSymbolInfo {
     positionUnknown?: boolean;
 }
 /**
- * RB-232(黑板 [1937]): WHY a "none" result was "none". Absent `reason` = a GENUINE empty answer (the server
+ * RB-232: WHY a "none" result was "none". Absent `reason` = a GENUINE empty answer (the server
  * answered null/[] — today's behavior byte-for-byte, and what an external manager returning bare
  * `{kind:"none"}` keeps getting). The failure reasons exist because one literal "No results." used to cover
  * both real emptiness and every transport-level fault — a findReferences that TIMED OUT read as "no

package/dist/core/mailbox-store.d.ts

@@ -110,7 +110,7 @@ export interface MailboxStore {
         maxAgeMs?: number;
     }): Promise<number>;
 }
-/** RB-250② (2026-07-28, 黑板 [1937]) class fix — the box age for `reap` is the MAX `sentAt`, not the
+/** RB-250② (2026-07-28) class fix — the box age for `reap` is the MAX `sentAt`, not the
  *  last array element: `sentAt` is caller-supplied, so append order need not be time order, and taking
  *  the tail let a box whose freshest message was mid-array be swept — both bundled backends discarded
  *  a brand-new message while the CC adapter (stores/cc/mailbox-store.ts, the in-package reference)

package/dist/core/mcp.d.ts

@@ -209,7 +209,7 @@ export interface MaterializedMcp {
      */
     statuses: McpServerStatus[];
     /**
-     * [1605] RefreshMcpTools (CC 2.1.218 parity, cli-锚形) — re-read the tool list of one server (or
+     * RefreshMcpTools (CC 2.1.218 parity, anchored to the CLI form) — re-read the tool list of one server (or
      * every CONNECTED server when `server` is omitted) over the EXISTING connection. NEVER dials or
      * re-dials: a dead/never-connected server reports `not_connected`; a live listTools failure
      * reports `failed` (the connection is left as-is). A refreshed entry carries the NEW intake
@@ -225,7 +225,7 @@ export interface MaterializedMcp {
     refresh: (server?: string) => Promise<McpRefreshResult[]>;
     dispose: () => Promise<void>;
 }
-/** [1605] One per-server entry of {@link MaterializedMcp.refresh}. `added`/`removed` are namespaced
+/** One per-server entry of {@link MaterializedMcp.refresh}. `added`/`removed` are namespaced
  *  (`mcp__<server>__<tool>`) names; `tools`/`axes`/`dropped` are present only on `"refreshed"`.
  *  The model-facing refresh receipt renders each `dropped` entry with ITS OWN `reason` (schema
  *  gate, same-listing name collision, …) — never a blanket label; a consumer matching that receipt
@@ -654,7 +654,7 @@ export declare function listEntryFingerprint(entry: unknown): string | undefined
  * page cap — a bounded multiplier, not a new unbounded surface. Per-entry admission stays where it
  * already is (the intake schema gate, which also drops a name a later page repeats).
  *
- * TIME, the reason `budgetMs` exists (codex review, confirmed): the page cap bounds REQUESTS, not
+ * TIME, the reason `budgetMs` exists (confirmed): the page cap bounds REQUESTS, not
  * latency. Giving every page its own full request timeout would let a server that stalls each page hold
  * a connect (or a refresh) for up to twenty timeouts — twenty minutes at the SDK's 60s default, where
  * an unpaginated listing cost one. So the WALK gets the budget a single listing used to have: page one

package/dist/core/memory-engine/consolidation-driver.d.ts

@@ -0,0 +1,207 @@
+/**
+ * design/376 片② — the host CONSOLIDATION DRIVER verb: one call that takes a long-accumulated,
+ * never-consolidated library to its fold fixpoint through the four engine verbs, as a PERSISTENT
+ * MULTI-CYCLE RUN.
+ *
+ * Why a run is a first-class object: under factory defaults a cold-start consolidation is a
+ * dozen-plus cycles with a hard 60-second throttle floor between them — a persistent job measured
+ * in minutes, not a call. The engine deliberately keeps NO driver state (its gate row settles per
+ * plan and clears the session count), so without a durable run account a process exit between two
+ * cycles would strand the work: no open plan to reconcile, no session edge to re-arm, and a naive
+ * re-entry would re-mint the whole plan at full model cost. The run row under the control plane is
+ * the resume seat: `runMemoryConsolidation` first looks for a PENDING run of the scope and
+ * CONTINUES it (same plan cache, same force requestId, zero new mint) — the idempotent re-entry
+ * GD-15 pins.
+ *
+ * Boundary reminders (design/339 §1.1, unchanged by this module):
+ *  - the engine adjudicates and commits; this driver only proposes and schedules — every write
+ *    goes through `commitConsolidationPlan`, nothing here touches the store;
+ *  - the engine holds no model seat; the model reaches this module as an explicit chat function;
+ *  - core still owns no timer: the throttle waits here run INSIDE a host's explicit call (or the
+ *    auto lane's task-boundary tick), never on a background schedule of core's own.
+ */
+import type { EngineNotice } from "../types.js";
+import { type ConsolidationGateRow, type ConsolidationRunStopReason, type MemoryConsolidationOptions } from "./consolidation.js";
+import { type ConsolidationPlanSummary } from "./engine.js";
+import { mintLlmConsolidationPlan, type ConsolidationDriveCycleRow, type ConsolidationDriveEngine, type ConsolidationFoldState, type DistillerChatFn, type LlmConsolidationPlan, type LlmConsolidationPlanProduct, type LlmDistillerContract } from "./distiller.js";
+export declare const CONSOLIDATION_DRIVER_RUNS_FILE = "distiller-runs.json";
+/** §1.6-4 — the mint archive: what was shown to the model and what it answered, verbatim, per run
+ *  (the fold law's audit other-half; strict-family placement beside the plan workbook). */
+export declare const CONSOLIDATION_DRIVER_PLANS_DIR = "distiller-plans";
+export interface ConsolidationDriverRunRow {
+    runId: string;
+    scope: string;
+    /** The WRITER claim: every open/resume bumps this under the run
+     *  store's lock, and every later write of the row is conditional on (runId, attempt) still
+     *  standing — of two invocations that raced onto one scope, exactly one keeps writing; the
+     *  superseded one stops with a coded error instead of silently clobbering the winner's counters
+     *  or terminal state. (Model spend under a genuine concurrent double-call is still at-least-once
+     *  — the claim serializes the ACCOUNT; the engine's plan-seat CAS serializes the store, and
+     *  cross-node cost suppression is the engine lease seat's job.) */
+    attempt: number;
+    /** The run-scoped force credential: ONE requestId across every forced snapshot of the run (the
+     *  engine dedups the FORCED audit announcement on it — one line per run). */
+    requestId: string;
+    /** The contract version of the run's surviving MINT — stamped at open, RE-stamped (with
+     *  {@link model}) by a resume that re-mints. */
+    contractVersion: string;
+    /** The id that minted the run's surviving plan: stamped at open; RE-stamped on a resume that
+     *  re-mints (the plan cache absent — nothing of the opening mint survived, so the current seat
+     *  mints every byte this run commits). The per-attempt plan archive is the byte-level anchor
+     *  either way. */
+    model: string;
+    startedAt: number;
+    state: "pending" | "settled";
+    /** Terminal only; the ONE closed set the receipt and the `_incomplete` notice share. */
+    outcome?: ConsolidationRunStopReason;
+    settledAt?: number;
+    stopDetail?: string;
+    /** The minted plan's replayable half (mint ONCE per run; each cycle filters, never re-mints). */
+    planCache?: {
+        maxInputsPerProduct: number;
+        products: LlmConsolidationPlanProduct[];
+    };
+    /** The archived mint transcript's file name under {@link CONSOLIDATION_DRIVER_PLANS_DIR}. */
+    planArchive?: string;
+    /** COMMITTED cycles only (the store moved): a refused/fuse-blocked/zero-delta cycle row does
+     *  not count — the receipt's "committed cycle(s)" label and the incomplete notice's zero-cycle
+     *  branch both read this number as writes. */
+    cyclesDone: number;
+    /** Store-delta superseded total across EVERY invocation of this run (the conservation wall's
+     *  evidence half — see the convergence check in the verb). Accumulated per cycle AFTER the
+     *  commit, so a crash between a cycle's commit and its row write loses that cycle's delta —
+     *  {@link foldBaseline} is the wall's immune second witness for exactly that window. */
+    entriesSuperseded: number;
+    /** The scope's fold-state `superseded` count at run OPEN (fresh claim; absent on rows opened
+     *  before the field existed). The conservation wall's STORE anchor: `final.superseded − this`
+     *  attests the run's folds even when a crash lands between a cycle's commit and its account
+     *  write — the seat serializes this scope's folds, so the since-open delta is this run's. */
+    foldBaseline?: {
+        superseded: number;
+    };
+    planIds: string[];
+    usage: {
+        calls: number;
+        promptTokens: number;
+        completionTokens: number;
+        retries: number;
+        truncations: number;
+    };
+    repairs: {
+        hallucinatedMembers: number;
+        duplicateMembers: number;
+        nonIntegerMembers: number;
+        emptyGroups: number;
+        oversizeGroups: number;
+    };
+    writeFailures: Array<{
+        key: string;
+        members: number;
+        reason: string | null;
+    }>;
+    residue?: Array<{
+        name: string;
+        targets: number;
+    }>;
+    /** The next moment a snapshot can pass the hard throttle (resume scheduling hint). */
+    nextEligibleAt?: number;
+}
+/** Host read face: the scope's latest driver run row (pending = resumable; settled = audit). */
+export declare function readConsolidationDriverRun(controlDir: string, scope: string): ConsolidationDriverRunRow | undefined;
+/** Archive one mint (prompts + transcript verbatim) beside the run account. The name carries the
+ *  CLAIM (`attempt`): two invocations that raced onto one run each archive
+ *  under their own name, so a superseded worker can never overwrite the winning transcript — the
+ *  run row's `planArchive` (written under the attempt guard) names the one that counts. */
+export declare function distillerPlanArchiveName(runId: string, attempt: number): string;
+export declare function archiveDistillerPlan(controlDir: string, runId: string, plan: LlmConsolidationPlan, attempt?: number): string;
+/** The engine face this verb consumes — `MemoryEngine` satisfies it structurally. */
+export interface ConsolidationDriverEngine extends ConsolidationDriveEngine {
+    readConsolidationGate(scope: string): ConsolidationGateRow | undefined;
+    listConsolidationPlans(): ConsolidationPlanSummary[];
+    readConsolidationFoldState(scope: string): Promise<ConsolidationFoldState>;
+    readonly controlPlaneRoot: string;
+}
+export interface RunMemoryConsolidationOptions {
+    /** The explicit model seat (design/339 §1.1: the ENGINE holds none). Build one with
+     *  `openAiCompatChatSeat` or hand any JSON-only completion function. */
+    chat: DistillerChatFn;
+    /** The explicit model id, recorded into the run and the archive (alias spellings refuse). */
+    model: string;
+    /** Audit locator recorded into the archive when the seat is endpoint-shaped. */
+    baseUrl?: string;
+    /** The frozen prompt contract; default = the product v1 (dl-3 byte-identical). A different
+     *  version here is a deployment's explicit measured choice. */
+    contract?: LlmDistillerContract;
+    /** The PROTOCOL knobs — pass the same object the engine was constructed with
+     *  (`MemoryEngineOptions.consolidation`); the driver derives its throttle window and per-plan
+     *  caps from it. Defaults = the factory defaults. */
+    consolidation?: MemoryConsolidationOptions;
+    /** Abort the run after this many cycles in THIS call (the run row stays pending only on crash;
+     *  a reached bound settles `max_cycles`). Positive integer; default 64. */
+    maxCycles?: number;
+    /** R2 — the structural-repair budget over the mint's member references: the ratio of member
+     *  claims the sanitiser had to DROP (hallucinated + duplicate + non-integer) to all member
+     *  claims the model made. Above this, the plan does not represent the model's intent and the
+     *  run aborts with zero writes rather than committing a harness-repaired fold. In [0, 1];
+     *  default 0.10. (Empty groups are the same drops counted at group grain; oversize groups are
+     *  not repairs — they ride on, named, and the schedule reports them infeasible. Format repairs
+     *  and retries are disclosed separately and bounded by the contract's own retry count.) */
+    mintRepairBudget?: number;
+    /** The run's force credential; defaults to a minted id. A RESUMED run keeps its original. */
+    requestId?: string;
+    /** Host seams for the throttle waits (tests and hosts with their own clocks). */
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    onProgress?: Parameters<typeof mintLlmConsolidationPlan>[0]["onProgress"];
+}
+export interface ConsolidationRunReceipt {
+    runId: string;
+    scope: string;
+    /** Whether this call CONTINUED a pending run (no new mint) instead of starting one. */
+    resumed: boolean;
+    outcome: ConsolidationRunStopReason;
+    converged: boolean;
+    stopDetail?: string;
+    /** This call's cycles (store-delta accounted); `cyclesDone` is the run total across resumes. */
+    cycles: ConsolidationDriveCycleRow[];
+    cyclesDone: number;
+    productsCommitted: number;
+    entriesSuperseded: number;
+    planIds: string[];
+    model: string;
+    contractVersion: string;
+    usage: ConsolidationDriverRunRow["usage"];
+    repairs: ConsolidationDriverRunRow["repairs"];
+    writeFailures: ConsolidationDriverRunRow["writeFailures"];
+    residue: Array<{
+        name: string;
+        targets: number;
+    }>;
+    planArchive?: string;
+    /** Advisory notices minted for this run (the `_incomplete` disclosure when not converged). */
+    notices: EngineNotice[];
+    /** A failed announcement enqueue is disclosed, never allowed to fail the settled run. */
+    announceFailures?: string[];
+}
+/**
+ * Run (or RESUME) one scope's consolidation as a persistent multi-cycle job. See the module note
+ * for the shape; the per-refusal behavior implements the design/376 §1.2 failure table:
+ *
+ *  - `_disabled` / a corrupt gate / an unreadable governance account BEFORE any commit: the coded
+ *    error is rethrown (a configuration/store fault the host must repair — a pending run row, if
+ *    one exists, stays resumable after the repair);
+ *  - `_gated` (time/session gate): retried under the run's force requestId — the run-level force
+ *    the design names; the FORCED audit line is engine-deduplicated to once per run;
+ *  - `_gated` (hard throttle): the driver WAITS the window out (`min(minRunIntervalMs, 60s)`) and
+ *    continues — a throttled cycle is scheduling, not a terminal;
+ *  - `_busy`: never a blind snapshot retry (the seat refuses snapshots too — a blind loop spins
+ *    forever): `reconcileConsolidation` first; a conflict/corrupt plan parks the run for the host
+ *    valve; a live competing worker is waited out briefly, then reported;
+ *  - model failures / a mint over the repair budget: the run settles `driver_failed` with ZERO
+ *    writes — the mint sits between snapshot and commit, so no seat was taken, `lastRunAt` never
+ *    moved and the time gate is not burned (the failure is free to retry);
+ *  - a conflict plan mid-run parks (`parked`); fuse residue and the cycle bound settle
+ *    `fuse_residue` / `max_cycles` with the residue named — the next run's FULL snapshot
+ *    re-distills the shrunken library (cross-run = re-mint; in-run = plan cache).
+ */
+export declare function runMemoryConsolidationDriver(engine: ConsolidationDriverEngine, scope: string, opts: RunMemoryConsolidationOptions): Promise<ConsolidationRunReceipt>;