@sema-agent/core 5.47.0 → 5.49.0

package/dist/agents/teacher.js

@@ -1,4 +1,6 @@
 import { randomUUID } from "node:crypto";
+import { MAX_STRATEGY_INJECTION_TOTAL_BYTES, MAX_STRATEGY_PROBLEM_BYTES, MAX_STRATEGY_TEXT_BYTES } from "../core/strategy-store.js";
+import { createSafeNotifier, observeThenableRejection } from "../core/safe-notify.js";
 import { mapNestedSuspend, isDurablePause } from "./suspend-guard.js";
 import { isDefineToolProduct, stampDefineToolBrand } from "../core/tools.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
@@ -46,31 +48,102 @@ export function parseTeacherAdvice(text) {
 export async function runWithTeacher(runner, studentSpec, teacher = {}) {
     const store = teacher.strategyStore;
     const scope = teacher.scope;
+    const incidentNotifier = createSafeNotifier();
+    const warnedIncidentOps = new Set();
+    const discloseStoreIncident = (i) => {
+        const seat = teacher.onStrategyStoreIncident;
+        if (seat) {
+            const site = `teacher.onStrategyStoreIncident.${i.op}`;
+            incidentNotifier.notify(() => observeThenableRejection(seat(i), incidentNotifier, site), site);
+        }
+        else if (!warnedIncidentOps.has(i.op)) {
+            warnedIncidentOps.add(i.op);
+            console.warn(`runWithTeacher: strategy store ${i.op} failed (contained — the run continues): ${i.error}`);
+        }
+    };
+    const isConfigCoded = (e) => typeof e?.code === "string" && (e.code).startsWith("config.");
     let spec = studentSpec;
+    let injected;
     if (store && scope && teacher.injectStrategies !== false) {
-        const found = await store.find(scope, studentSpec.objective, teacher.retrieveK ?? 3);
+        let found = [];
+        try {
+            const raw = await store.find(scope, studentSpec.objective, teacher.retrieveK ?? 3);
+            if (!Array.isArray(raw)) {
+                discloseStoreIncident({ op: "find", error: "store.find returned a non-array result — injecting nothing" });
+            }
+            else {
+                let dropped = 0;
+                for (const e of raw) {
+                    const c = e;
+                    const id = c?.id;
+                    const ts = c?.ts;
+                    const strategy = c?.strategy;
+                    if (typeof id !== "string" || typeof ts !== "string" || typeof strategy !== "string") {
+                        dropped++;
+                        continue;
+                    }
+                    const origin = c?.origin;
+                    found.push({ id, ts, strategy, ...(origin === "earned" || origin === "seeded" ? { origin } : {}) });
+                }
+                if (dropped > 0) {
+                    discloseStoreIncident({ op: "find", error: `${dropped} malformed retrieval entries dropped (id/ts/strategy must be strings)` });
+                }
+            }
+        }
+        catch (e) {
+            if (isConfigCoded(e))
+                throw e;
+            discloseStoreIncident({ op: "find", error: String(e?.message ?? e) });
+            found = [];
+        }
+        let budget = 0;
+        for (let i = 0; i < found.length; i++) {
+            budget += Buffer.byteLength(found[i].strategy, "utf8");
+            if (budget > MAX_STRATEGY_INJECTION_TOTAL_BYTES) {
+                discloseStoreIncident({
+                    op: "find",
+                    error: `injection truncated to ${i} of ${found.length} retrieved strategies — combined text exceeded ${MAX_STRATEGY_INJECTION_TOTAL_BYTES} bytes`,
+                });
+                found = found.slice(0, i);
+                break;
+            }
+        }
         if (found.length > 0) {
             const block = `[STRATEGIES from PAST, DIFFERENT tasks — they may NOT apply. If unsure, IGNORE them and proceed normally.]\n` +
-                found.map((s) => `- ${s.strategy}`).join("\n");
+                delimitUntrusted("PAST STRATEGIES (from DIFFERENT tasks; may NOT apply — verify before use)", found.map((s) => `- ${s.strategy}`).join("\n"));
             spec = { ...studentSpec, objective: `${block}\n\n${studentSpec.objective}` };
+            injected = found.map((s) => ({ id: s.id, ts: s.ts, ...(s.origin !== undefined ? { origin: s.origin } : {}) }));
         }
     }
     const result = await runTeacherCore(runner, spec, teacher);
     if (store && scope && result.status === "completed" && result.escalations.length > 0) {
         const advice = result.escalations[result.escalations.length - 1].teacher;
         if (advice.strategy && advice.confidence >= (teacher.minConfidenceToStore ?? 2)) {
-            await store.save({
-                id: randomUUID(),
-                problem: studentSpec.objective,
-                strategy: advice.strategy,
-                confidence: advice.confidence,
-                scope,
-                ts: new Date().toISOString(),
-                teacherModel: typeof teacher.model === "string" ? teacher.model : teacher.model?.id,
-            });
+            try {
+                const clip = (text, maxBytes) => {
+                    let out = text;
+                    while (Buffer.byteLength(out) > maxBytes)
+                        out = out.slice(0, -1);
+                    return out;
+                };
+                await store.save({
+                    id: randomUUID(),
+                    problem: clip(studentSpec.objective, MAX_STRATEGY_PROBLEM_BYTES),
+                    strategy: clip(advice.strategy, MAX_STRATEGY_TEXT_BYTES),
+                    confidence: Math.min(3, Math.max(0, advice.confidence)),
+                    scope,
+                    ts: new Date().toISOString(),
+                    teacherModel: typeof teacher.model === "string" ? teacher.model : teacher.model?.id,
+                });
+            }
+            catch (e) {
+                if (isConfigCoded(e))
+                    throw e;
+                discloseStoreIncident({ op: "save", error: String(e?.message ?? e) });
+            }
         }
     }
-    return result;
+    return injected !== undefined && injected.length > 0 ? { ...result, strategiesInjected: injected } : result;
 }
 async function runTeacherCore(runner, studentSpec, teacher) {
     const maxEscalations = teacher.maxEscalations ?? 3;

package/dist/config/defaults.d.ts

@@ -21,6 +21,26 @@
  */
 export declare const RETAIN_DEFAULT_TTL_MS: number;
 export declare const RETAIN_DEFAULT_MAX = 16;
+/** Subagent transcript persistence — the delegation ENTRY caps (CC values: 20 concurrent /
+ *  200 per session tree). The INLET bound family (`RunnerDeps.delegationEntryCaps`), as opposed to
+ *  the retain pair above, which is a pure in-memory fast-lane handle bound (outlet — armed
+ *  deployments lose nothing when it evicts). Concurrent = running/pending a* handles under one
+ *  (scope, rootSessionId) key in THIS process's registry; cumulative = retained-window count under
+ *  the same key (see the enforcement site for the exact retained-window semantics). */
+export declare const DELEGATION_MAX_CONCURRENT_DEFAULT = 20;
+export declare const DELEGATION_MAX_PER_SESSION_DEFAULT = 200;
+/** Subagent transcript persistence — orphan adoption (CC parity: after a restart a deployment
+ *  auto-adopts at most this many stale rows whose transcript mtime is inside the window; older ones
+ *  stay MANUALLY continuable for the whole retention period — never deleted by the window). The
+ *  TRIGGER is deployment-owned (core has no daemon and never revives runs nobody asked for); these
+ *  constants are the shared vocabulary so every deployment adopts by the same numbers. */
+export declare const ORPHAN_ADOPT_WINDOW_MS_DEFAULT: number;
+export declare const ORPHAN_ADOPT_MAX_DEFAULT = 20;
+/** Subagent transcript persistence — the default transcript retention period (CC
+ *  cleanupPeriodDays parity). Core ships NO sweeper (design/151 ruling 2): the blessed path is the
+ *  deployment calling `TaskRegistry.reapDurableAgents` with `maxAgeMs` derived from this (boot +
+ *  every 24h is the reference cadence). */
+export declare const SUBAGENT_TRANSCRIPT_RETENTION_DAYS_DEFAULT = 30;
 /** Default idle TTL (days) before a cached session is evicted (config-catalog `session.idleTtlDays`). */
 export declare const SESSION_DEFAULT_TTL_DAYS = 7;
 /**

package/dist/config/defaults.js

@@ -1,4 +1,9 @@
 export const RETAIN_DEFAULT_TTL_MS = 30 * 60 * 1000;
 export const RETAIN_DEFAULT_MAX = 16;
+export const DELEGATION_MAX_CONCURRENT_DEFAULT = 20;
+export const DELEGATION_MAX_PER_SESSION_DEFAULT = 200;
+export const ORPHAN_ADOPT_WINDOW_MS_DEFAULT = 48 * 60 * 60 * 1000;
+export const ORPHAN_ADOPT_MAX_DEFAULT = 20;
+export const SUBAGENT_TRANSCRIPT_RETENTION_DAYS_DEFAULT = 30;
 export const SESSION_DEFAULT_TTL_DAYS = 7;
 export const RUNNING_AGENT_OBSERVE_EVERY_BEATS = 4;

package/dist/core/background-agent-store.d.ts

@@ -170,6 +170,7 @@ export interface BackgroundAgentRecord {
 export declare const REVIVED_ROW_CLEARED_FIELDS: readonly ["settledAt", "stoppedBy", "completionId", "finalOutput", "finalOutputFull", "error", "errorCode", "errorRetryable", "errorKind", "errorRetryAfterMs", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"];
 /** Erase {@link REVIVED_ROW_CLEARED_FIELDS} from a record a revival is about to write back. */
 export declare function clearRevivedRowTerminalPayload(record: BackgroundAgentRecord): void;
+export declare function announceTranscriptIntegrityGapOnce(handle: string, scope: string | undefined, sink: ((handle: string, scope: string | undefined) => void) | undefined): void;
 /** Content-free projection for list reads (design/151 HIGH-1: `summary`/`finalOutput`/`recentSteps`
  *  and friends NEVER ride a list — content is get-by-handle only, behind the full predicate). */
 export interface BackgroundAgentRowSummary {

package/dist/core/background-agent-store.js

@@ -21,6 +21,20 @@ export function clearRevivedRowTerminalPayload(record) {
     for (const field of REVIVED_ROW_CLEARED_FIELDS)
         delete record[field];
 }
+const transcriptIntegrityAnnounced = new Set();
+export function announceTranscriptIntegrityGapOnce(handle, scope, sink) {
+    if (sink === undefined)
+        return;
+    const key = `${scope ?? ""}\u0000${handle}`;
+    if (transcriptIntegrityAnnounced.has(key))
+        return;
+    transcriptIntegrityAnnounced.add(key);
+    try {
+        sink(handle, scope);
+    }
+    catch {
+    }
+}
 export class BackgroundAgentStoreError extends Error {
     code;
     constructor(code, message) {

package/dist/core/mcp.d.ts

@@ -36,6 +36,7 @@ import type { AgentTool } from "../internal/harness-types.js";
 import type { ImageContent, TextContent } from "../internal/llm.js";
 import { type McpImageResizer } from "./image-downsample.js";
 import type { McpServerSpec, OnElicit, ToolEffect } from "./types.js";
+import { type ReminderDisclosureCounts } from "./reminder-disclosure.js";
 /**
  * The safety axes (design/77 §4 irreversibility, design/70 egress) derived from one materialized MCP
  * tool's server-advertised `annotations`. These ride alongside the {@link AgentTool} (which is vendored
@@ -462,7 +463,11 @@ export declare function normalizeMcpToolSchema(schema: unknown): McpSchemaNormal
  * combinator's own structure is legal JSON Schema ⇒ passes validateJsonSchemaShape too).
  */
 export declare function mcpToolSchemaProblem(schema: unknown): string | undefined;
-export declare function materializeMcpTools(specs: McpServerSpec[], principal?: string, onElicit?: OnElicit, imageResizer?: McpImageResizer): Promise<MaterializedMcp>;
+export declare function materializeMcpTools(specs: McpServerSpec[], principal?: string, onElicit?: OnElicit, imageResizer?: McpImageResizer, // design/116 CONFIRM-1 seam: deployment-injected; default = auto-detected sharp
+reminderDisclosure?: {
+    reminderMark?: string;
+    counts?: ReminderDisclosureCounts;
+}): Promise<MaterializedMcp>;
 /**
  * Fold the caller's AUTHORITATIVE per-tool override (design F: caller = trust root) over the server-hint axis.
  * Unlike server hints, the caller may RAISE or LOWER any axis: `effect` sets the repeat-safety class (lower to

package/dist/core/mcp.js

@@ -11,6 +11,7 @@ import { MCP_IMAGE_MAX_BASE64, sharpImageResizer } from "./image-downsample.js";
 import { sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
 import { truncateError } from "./tool-errors.js";
 import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "./untrusted-text.js";
+import { discloseReminderShaped } from "./reminder-disclosure.js";
 import { withContentOrigin } from "./memory-engine/content-origin.js";
 import { validateJsonSchemaShape } from "./runner/strict-output-schema.js";
 export const MCP_PREFIX = MCP_NAMESPACE.prefix;
@@ -649,7 +650,10 @@ export function mcpToolSchemaProblem(schema) {
     }
     return undefined;
 }
-export async function materializeMcpTools(specs, principal, onElicit, imageResizer) {
+export async function materializeMcpTools(specs, principal, onElicit, imageResizer, reminderDisclosure) {
+    const mcpDisclosure = reminderDisclosure?.reminderMark !== undefined
+        ? { mark: reminderDisclosure.reminderMark, windows: new Map(), ...(reminderDisclosure.counts !== undefined ? { counts: reminderDisclosure.counts } : {}) }
+        : undefined;
     const clients = [];
     const tools = [];
     const toolAxes = [];
@@ -661,7 +665,7 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
     const droppedTools = [];
     let disposing = false;
     const serverHandles = [];
-    const settled = await Promise.allSettled(specs.map((spec) => connectServer(spec, principal, onElicit, imageResizer)));
+    const settled = await Promise.allSettled(specs.map((spec) => connectServer(spec, principal, onElicit, imageResizer, mcpDisclosure)));
     try {
         for (let i = 0; i < specs.length; i++) {
             const r = settled[i];
@@ -728,7 +732,7 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
                 try {
                     const listed = await listToolsLenient(h.client);
                     cacheMcpToolMetadata(h.client, listed.tools);
-                    const { serverTools, serverAxes, dropped } = intakeListedTools(listed, h.spec, h.client, h.health, imageResizer);
+                    const { serverTools, serverAxes, dropped } = intakeListedTools(listed, h.spec, h.client, h.health, imageResizer, mcpDisclosure);
                     const newNames = serverTools.map((t) => t.name);
                     const added = newNames.filter((n) => !h.toolNames.includes(n));
                     const removed = h.toolNames.filter((n) => !newNames.includes(n));
@@ -1119,7 +1123,7 @@ const LENIENT_CALL_TOOL_RESULT_SCHEMA = { safeParse: parseCallToolResultLenient
 async function listToolsLenient(client, options) {
     return client.request({ method: "tools/list", params: {} }, LenientListToolsResultSchema, options);
 }
-async function connectServer(spec, principal, onElicit, imageResizer) {
+async function connectServer(spec, principal, onElicit, imageResizer, reminderDisclosure) {
     const elicitOn = spec.elicitation === true && onElicit !== undefined;
     const health = { dead: false, pendingElicitations: 0, lastElicitationClosedAt: 0 };
     const client = new Client({ name: `sema-core/${spec.name}`, version: "0.1.0" }, { capabilities: elicitOn ? { elicitation: { form: {} } } : {} });
@@ -1155,7 +1159,7 @@ async function connectServer(spec, principal, onElicit, imageResizer) {
         };
         const listed = await listToolsLenient(client, startupOpts);
         cacheMcpToolMetadata(client, listed.tools);
-        const { serverTools, serverAxes, dropped } = intakeListedTools(listed, spec, client, health, imageResizer);
+        const { serverTools, serverAxes, dropped } = intakeListedTools(listed, spec, client, health, imageResizer, reminderDisclosure);
         const caps = client.getServerCapabilities();
         const resourceInfo = caps?.resources
             ? {
@@ -1188,7 +1192,7 @@ async function connectServer(spec, principal, onElicit, imageResizer) {
         throw err;
     }
 }
-function intakeListedTools(listed, spec, client, health, imageResizer) {
+function intakeListedTools(listed, spec, client, health, imageResizer, reminderDisclosure) {
     const serverTools = [];
     const serverAxes = [];
     const dropped = [];
@@ -1276,8 +1280,31 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
                         type: "text",
                         text: `[structuredContent] JSON with schema: ${inferCompactSchema(sc)}\n${truncateError(JSON.stringify(sc))}`,
                     });
-                    return { content, details: { type: "mcp", structuredContent: sc }, terminate: false };
                 }
+                if (reminderDisclosure !== undefined) {
+                    const textIdx = [];
+                    const segments = [];
+                    content.forEach((b, i) => {
+                        if (b.type === "text" && typeof b.text === "string") {
+                            textIdx.push(i);
+                            segments.push(b.text);
+                        }
+                    });
+                    const d = discloseReminderShaped({
+                        segments,
+                        mark: reminderDisclosure.mark,
+                        outlet: "mcp",
+                        defuseExactMark: true,
+                        throttle: { key: `${spec.name}:${remoteName}`, windows: reminderDisclosure.windows },
+                        ...(reminderDisclosure.counts !== undefined ? { counts: reminderDisclosure.counts } : {}),
+                    });
+                    if (d.defused)
+                        textIdx.forEach((ci, si) => (content[ci] = { type: "text", text: d.segments[si] }));
+                    if (d.trailer !== undefined)
+                        content.push({ type: "text", text: d.trailer });
+                }
+                if (sc !== undefined)
+                    return { content, details: { type: "mcp", structuredContent: sc }, terminate: false };
                 return { content, details: res, terminate: false };
             },
         });

package/dist/core/memory-engine/delegation-settlement.d.ts

@@ -221,6 +221,11 @@ export interface HoldRow {
     };
     /** Host valve verdict awaiting the next harvest ("release" commits with cause "static"). */
     resolved?: "release" | "discard";
+    /** The verdict's GENERATION (strictly increases on every re-resolution): the settle leg's
+     *  consumed-verdict exit clears only the exact generation it read, so a host re-resolution
+     *  racing a failing release attempt is never erased by the stale attempt's cleanup. Absent on
+     *  rows resolved before the member existed (a generation-less clear matches those). */
+    resolvedAt?: number;
 }
 export declare function readHolds(controlDir: string): HoldRow[];
 /** ATOMIC no-replace restore of a staged file onto a plane path (adversarial round 2: an
@@ -308,6 +313,28 @@ export declare function resolveHoldRecord(controlDir: string, input: {
     requestId: string;
     now: () => number;
 }): void;
+/**
+ * Consume a standing valve verdict WITHOUT any other transition — the settle leg's exit for a
+ * valve release that FAILED on an already-disposed row (an expired hold whose release hit a
+ * judgment refusal: lost custody, re-scan refusal, CAS conflict). `disposeHold` is a no-op there
+ * (the row is already terminal), so leaving `resolved` standing would re-run the identical failing
+ * release — and re-announce a disposal that never happened — on every subsequent harvest, forever.
+ * Clearing it returns the row to its plain disposed/expired state: the failure is disclosed by the
+ * caller, custody/quarantine bytes stay addressable, and `resolveHold(holdId, "release")` remains
+ * admissible after the host reconciles. GENERATION-KEYED: only the exact verdict generation the
+ * caller read is cleared — a host re-resolution that landed while the failing attempt was in
+ * flight is a NEWER generation and stands (the stale attempt's cleanup must not erase a live host
+ * action). A generation-less verdict (a row written before the member existed) is consumable
+ * against a generation-less read — every CURRENT writer mints a generation, so the only verdict
+ * such a clear can erase is one written by a PRE-generation writer racing on the same control
+ * plane: the standing mixed-version-writer class the upgrade-order duty prices, kept consumable
+ * on purpose (refusing it would revive the forever-re-firing valve loop for every verdict minted
+ * before the upgrade). Idempotent; unknown/verdict-less/other-generation rows are a no-op.
+ */
+export declare function clearHoldResolution(controlDir: string, input: {
+    holdId: string;
+    ifResolvedAt: number | undefined;
+}): void;
 /** Read one hold's custody bytes (release leg + expired-release valve). Returns undefined when
  *  the custody file is gone or fails its digest — the caller records capture_lost, never commits
  *  unverified bytes. For an expired-released row the bytes may already sit in quarantine

package/dist/core/memory-engine/delegation-settlement.js

@@ -346,6 +346,7 @@ function coerceHolds(raw) {
             !HOLD_STATUSES.has(row.status) ||
             (row.disposition !== undefined && (typeof row.disposition !== "object" || row.disposition === null || !HOLD_TERMINALS.has(row.disposition.terminal) || (row.disposition.quarantineName !== undefined && !safeBasename(row.disposition.quarantineName)))) ||
             (row.resolved !== undefined && row.resolved !== "release" && row.resolved !== "discard") ||
+            (row.resolvedAt !== undefined && (typeof row.resolvedAt !== "number" || !Number.isSafeInteger(row.resolvedAt) || row.resolvedAt < 0 || row.resolvedAt >= 2 ** 50 || row.resolved === undefined)) ||
             (row.entryId !== undefined && typeof row.entryId !== "string") ||
             (row.baseRev !== undefined && typeof row.baseRev !== "string") ||
             (row.op === "update" && (!reqStr(row.entryId) || !reqStr(row.baseRev))) ||
@@ -401,6 +402,14 @@ export function openInstructionHold(controlDir, input) {
     const digest = sha256(buf);
     const captureName = `${holdId}.md`;
     const holdDir = join(controlDir, HOLD_DIR);
+    const refuse = (reason, terminal) => {
+        try {
+            disposeHold(controlDir, { holdId, terminal, now: input.now });
+        }
+        catch {
+        }
+        return { ok: false, holdId, reason };
+    };
     try {
         lockedStrictUpdate(controlDir, HOLDS_FILE, "memory instruction-hold ledger", coerceHolds, (rec) => {
             if (rec.rows.some((r) => r.holdId === holdId))
@@ -431,10 +440,10 @@ export function openInstructionHold(controlDir, input) {
         writeFileSync(join(holdDir, captureName), buf, { flag: "wx" });
         const back = readFileSync(join(holdDir, captureName));
         if (sha256(back) !== digest)
-            return { ok: false, holdId, reason: "hold capture verification failed (written bytes do not hash to the captured digest)" };
+            return refuse("hold capture verification failed (written bytes do not hash to the captured digest)", "capture_lost");
     }
     catch (err) {
-        return { ok: false, holdId, reason: `hold capture failed: ${err instanceof Error ? err.message : String(err)}` };
+        return refuse(`hold capture failed: ${err instanceof Error ? err.message : String(err)}`, "capture_lost");
     }
     const stagingName = uniqueStagingName(holdId, input.now);
     const stagingPath = join(holdDir, stagingName);
@@ -447,7 +456,7 @@ export function openInstructionHold(controlDir, input) {
         if (code === "ENOENT") {
         }
         else {
-            return { ok: false, holdId, reason: `hold removal failed (${code ?? "rename error"}): the plane file was not moved` };
+            return refuse(`hold removal failed (${code ?? "rename error"}): the plane file was not moved`, "discarded");
         }
     }
     if (existsSync(stagingPath)) {
@@ -475,7 +484,7 @@ export function openInstructionHold(controlDir, input) {
         });
     }
     catch (err) {
-        return { ok: false, holdId, reason: `hold ledger flip refused: ${err instanceof Error ? err.message : String(err)}` };
+        return refuse(`hold ledger flip refused: ${err instanceof Error ? err.message : String(err)}`, "discarded");
     }
     return { ok: true, holdId, ...(thirdWriterStranded !== undefined ? { thirdWriterStranded } : {}) };
 }
@@ -604,6 +613,7 @@ export function markHoldReleased(controlDir, input) {
             return { result: undefined };
         r.status = "released";
         delete r.resolved;
+        delete r.resolvedAt;
         return { next: rec, result: r.captureName };
     });
     if (captureName === undefined)
@@ -638,6 +648,23 @@ export function resolveHoldRecord(controlDir, input) {
             throw e;
         }
         r.resolved = input.action;
+        const nextGeneration = Math.max(input.now(), 0, (r.resolvedAt ?? 0) + 1);
+        if (!Number.isSafeInteger(nextGeneration) || nextGeneration < 0 || nextGeneration >= 2 ** 50) {
+            const e = new Error(`resolveHold: hold ${JSON.stringify(input.holdId)} cannot mint a fresh verdict generation (${String(nextGeneration)} — an exhausted window, a deranged clock, or a corrupt ledger row) — refused, never written.`);
+            e.code = "memory.hold_resolve_invalid_state";
+            throw e;
+        }
+        r.resolvedAt = nextGeneration;
+        return { next: rec, result: undefined };
+    });
+}
+export function clearHoldResolution(controlDir, input) {
+    lockedStrictUpdate(controlDir, HOLDS_FILE, "memory instruction-hold ledger", coerceHolds, (rec) => {
+        const r = rec.rows.find((x) => x.holdId === input.holdId);
+        if (r === undefined || r.resolved === undefined || r.resolvedAt !== input.ifResolvedAt)
+            return { result: undefined };
+        delete r.resolved;
+        delete r.resolvedAt;
         return { next: rec, result: undefined };
     });
 }

package/dist/core/memory-engine/dual-root.js

@@ -75,5 +75,16 @@ export function mergeHarvestReports(a, b) {
     const qf = [...(a.quarantineFailures ?? []), ...(b.quarantineFailures ?? [])];
     if (qf.length > 0)
         merged.quarantineFailures = qf;
+    const ac = a.containment;
+    const bc = b.containment;
+    if (ac !== undefined || bc !== undefined) {
+        merged.containment = {
+            indexRolledBack: ac?.indexRolledBack === true || bc?.indexRolledBack === true,
+            quarantinedInstruction: [...(ac?.quarantinedInstruction ?? []), ...(bc?.quarantinedInstruction ?? [])],
+            heldInstruction: [...(ac?.heldInstruction ?? []), ...(bc?.heldInstruction ?? [])],
+            releasedHolds: [...(ac?.releasedHolds ?? []), ...(bc?.releasedHolds ?? [])],
+            disposedHolds: [...(ac?.disposedHolds ?? []), ...(bc?.disposedHolds ?? [])],
+        };
+    }
     return merged;
 }

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

@@ -803,7 +803,12 @@ export declare class MemoryEngine {
      * and a re-call RESUMES it idempotently. Refusals (#123 coded, caller-shape):
      * unattributed/invalid input, unknown/unmarked entry, and a CHALLENGED entry — the clear valve
      * is not a challenge exit (adjudicate the challenge first; clearing a challenged entry would
-     * launder the exclusion through the weaker credential).
+     * launder the exclusion through the weaker credential); the challenged refusal re-judges on the
+     * RESUME path too while the marked entry stands. Two effect-half refusals (terminal, both
+     * states untouched): an on-disk projection diverging from the committed state (the clear never
+     * overwrites unadopted plane bytes — adopt/reconcile first), and a resumed row whose entry is
+     * ABSENT without a recorded committed tombstone (that absence is an independent deletion the
+     * clear never resurrects; the custody bytes stay disclosed on the terminal row).
      */
     clearEntryOrigin(entryId: string, input: {
         requestId: string;