@remnic/core 10.0.4 → 10.0.5

package/src/correction/correction-executor.ts

@@ -68,6 +68,8 @@ export interface ExecutorMemory {
   entityRef?: string;
   /** Raw content used for the tombstone hash (rule 23). */
   rawContent: string;
+  /** Frontmatter status. Absent is treated as active. */
+  status?: string;
 }
 
 export interface ExecutorDeps {
@@ -486,13 +488,29 @@ export class CorrectionExecutor {
         if (action.replacement && !replacementResult) {
           continue;
         }
+        if (action.winnerId && !action.replacement) {
+          const winner = await this.deps.getMemory(namespace, action.winnerId, abortSignal);
+          const winnerStatus = winner ? (winner.status ?? "active") : undefined;
+          if (!winner || winnerStatus !== "active") {
+            results.push({
+              action,
+              status: "failed",
+              error: winner
+                ? `supersede winner is not active: ${action.winnerId} (${winnerStatus})`
+                : `supersede winner not found: ${action.winnerId}`,
+            });
+            continue;
+          }
+        }
         await this.retireAndTombstone(
           namespace,
           action,
           "supersession",
           results,
           appliedTouched,
-          { supersededBy: replacementResult?.memoryId },
+          {
+            supersededBy: replacementResult?.memoryId ?? action.winnerId,
+          },
           abortSignal
         );
         if (results.at(-1)?.status === "applied") {

package/src/correction/correction-planner.test.ts

@@ -38,6 +38,8 @@ interface StubState {
   writeReplacementCalls: number;
   propagateCalls: number;
   retireCalls: number;
+  statusById?: Map<string, string>;
+  classifyCalls?: number;
 }
 
 function makeCandidate(over: Partial<PlannerCandidate> & { memoryId: string }): PlannerCandidate {
@@ -72,12 +74,18 @@ function makeDeps(stateDir: string, state: StubState, opts: { maxAffected?: numb
       }
       return out;
     },
+    inspectMemory: async ({ memoryId }) => {
+      const candidate = state.candidatesById.get(memoryId);
+      if (!candidate) return null;
+      return { candidate, status: state.statusById?.get(memoryId) ?? "active" };
+    },
     expandNeighbors: async ({ seedIds }) => {
       // No neighbors in the stub; return the seeds themselves so neighbor
       // expansion is exercised but produces no surprises.
       return seedIds.map((id) => state.candidatesById.get(id)).filter((c): c is PlannerCandidate => c !== undefined);
     },
     classifyAndDraft: async ({ text, candidates }) => {
+      state.classifyCalls = (state.classifyCalls ?? 0) + 1;
       return typeof state.llmResult === "function"
         ? state.llmResult(text, candidates)
         : state.llmResult;
@@ -787,3 +795,136 @@ test("#1713: recoverStaleApplyingPlans recovers pre-fix plans immediately at exp
     assert.equal(recovered.length, 1, "pre-fix plan at expiry must be recovered immediately");
   });
 });
+
+test("duplicateOf skips the LLM and drafts one recoverable supersede linked to the winner", async () => {
+  await withTempDir(async (dir) => {
+    const state: StubState = {
+      candidatesById: new Map([
+        ["mem-loser", makeCandidate({ memoryId: "mem-loser", content: "duplicate fact" })],
+        ["mem-winner", makeCandidate({ memoryId: "mem-winner", content: "canonical fact" })],
+      ]),
+      llmResult: () => {
+        throw new Error("classifyAndDraft must not run in duplicate mode");
+      },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const plan = await new CorrectionPlanner(makeDeps(dir, state)).plan(
+      { text: "mem-loser duplicates mem-winner", targetIds: ["mem-loser"], duplicateOf: "mem-winner" },
+      ["default"],
+    );
+    assert.equal(state.classifyCalls ?? 0, 0);
+    assert.equal(plan.actions.length, 1);
+    assert.deepEqual(plan.actions[0], { kind: "supersede", loserId: "mem-loser", winnerId: "mem-winner" });
+    assert.equal(plan.classification, "outdated");
+    assert.equal(plan.confidence, 1);
+    assert.equal(plan.affected.length, 1);
+    assert.equal(plan.affected[0]?.memoryId, "mem-loser");
+    assert.equal(plan.request.duplicateOf, "mem-winner");
+  });
+});
+
+test("a model-selected winnerId outside the located set is dropped", async () => {
+  await withTempDir(async (dir) => {
+    const state: StubState = {
+      candidatesById: new Map([
+        ["mem-loser", makeCandidate({ memoryId: "mem-loser", content: "duplicate fact" })],
+        ["mem-winner", makeCandidate({ memoryId: "mem-winner", content: "canonical fact" })],
+      ]),
+      llmResult: {
+        classification: "outdated",
+        confidence: 0.9,
+        actions: [{ kind: "supersede", loserId: "mem-loser", winnerId: "mem-not-located" }],
+        relevance: [{ memoryId: "mem-loser", why: "duplicate" }],
+        warnings: [],
+      },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const plan = await new CorrectionPlanner(makeDeps(dir, state)).plan(
+      { text: "retire the duplicate", targetIds: ["mem-loser"] },
+      ["default"],
+    );
+    assert.equal(plan.actions.length, 0);
+    assert.match(plan.warnings.join(" "), /outside the located candidate set/);
+  });
+});
+
+test("a model-selected winnerId inside the located set is kept", async () => {
+  await withTempDir(async (dir) => {
+    const state: StubState = {
+      candidatesById: new Map([
+        ["mem-loser", makeCandidate({ memoryId: "mem-loser", content: "duplicate fact" })],
+        ["mem-winner", makeCandidate({ memoryId: "mem-winner", content: "canonical fact" })],
+      ]),
+      llmResult: {
+        classification: "outdated",
+        confidence: 0.9,
+        actions: [{ kind: "supersede", loserId: "mem-loser", winnerId: "mem-winner" }],
+        relevance: [{ memoryId: "mem-loser", why: "duplicate" }],
+        warnings: [],
+      },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const plan = await new CorrectionPlanner(makeDeps(dir, state)).plan(
+      { text: "retire the duplicate", targetIds: ["mem-loser", "mem-winner"] },
+      ["default"],
+    );
+    assert.deepEqual(plan.actions, [{ kind: "supersede", loserId: "mem-loser", winnerId: "mem-winner" }]);
+  });
+});
+
+test("duplicateOf rejects same id, missing memories, inactive memories, and a target list that is not exactly one", async () => {
+  await withTempDir(async (dir) => {
+    const state: StubState = {
+      candidatesById: new Map([
+        ["mem-loser", makeCandidate({ memoryId: "mem-loser" })],
+        ["mem-winner", makeCandidate({ memoryId: "mem-winner" })],
+        ["mem-old", makeCandidate({ memoryId: "mem-old" })],
+      ]),
+      statusById: new Map([["mem-old", "superseded"]]),
+      llmResult: { classification: "outdated", confidence: 1, actions: [], relevance: [], warnings: [] },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const planner = new CorrectionPlanner(makeDeps(dir, state));
+    await assert.rejects(
+      () => planner.plan({ text: "same", targetIds: ["mem-loser"], duplicateOf: "mem-loser" }, ["default"]),
+      /different memory from targetIds/,
+    );
+    await assert.rejects(
+      () => planner.plan({ text: "missing loser", targetIds: ["missing"], duplicateOf: "mem-winner" }, ["default"]),
+      /target memory not found: missing/,
+    );
+    await assert.rejects(
+      () => planner.plan({ text: "missing winner", targetIds: ["mem-loser"], duplicateOf: "missing-winner" }, ["default"]),
+      /duplicateOf memory not found: missing-winner/,
+    );
+    await assert.rejects(
+      () => planner.plan({ text: "inactive loser", targetIds: ["mem-old"], duplicateOf: "mem-winner" }, ["default"]),
+      /target memory is not active: mem-old \(superseded\)/,
+    );
+    state.statusById = new Map([["mem-winner", "forgotten"]]);
+    await assert.rejects(
+      () => planner.plan({ text: "inactive winner", targetIds: ["mem-loser"], duplicateOf: "mem-winner" }, ["default"]),
+      /duplicateOf memory is not active: mem-winner \(forgotten\)/,
+    );
+    await assert.rejects(
+      () => planner.plan({ text: "no target", duplicateOf: "mem-winner" }, ["default"]),
+      /exactly one targetIds entry/,
+    );
+    await assert.rejects(
+      () => planner.plan(
+        { text: "two targets", targetIds: ["mem-loser", "mem-winner"], duplicateOf: "mem-winner" },
+        ["default"],
+      ),
+      /exactly one targetIds entry/,
+    );
+    assert.equal(state.classifyCalls ?? 0, 0);
+  });
+});

package/src/correction/correction-planner.ts

@@ -7,9 +7,11 @@
  *      error, rule 34). Else: search via the injected search path scoped to
  *      the caller's readable namespaces, plus 1-hop entity-graph neighbors of
  *      top hits. Cap candidates at `maxAffected`.
- *   2. CLASSIFY + DRAFT via one LLM call (Responses API only, gotcha 1). On
- *      LLM failure → deterministic fallback plan (rule 13): classification
- *      `outdated`, `confidence: 0`, empty actions, warning set.
+ *   2. CLASSIFY + DRAFT via one LLM call (Responses API only, gotcha 1),
+ *      unless `duplicateOf` is set — that path skips the LLM and drafts one
+ *      recoverable supersede. On LLM failure → deterministic fallback plan
+ *      (rule 13): classification `outdated`, `confidence: 0`, empty actions.
+ *      A caller abort throws instead of falling back.
  *   3. RENDER DIFF by materializing what each action would do, using the
  *      injected diff renderer (page-versioning — reuse, don't fork).
  *   4. PERSIST the plan atomically under
@@ -81,6 +83,16 @@ export interface PlannerDeps {
     targetIds: readonly string[];
     namespaces: readonly string[];
   }): Promise<PlannerCandidate[]>;
+  /**
+   * Inspect one memory for duplicate-mode validation. Absent means "not
+   * found" (including outside the readable namespaces). A missing method
+   * falls back to {@link resolveTargets}, which reports inactive memories
+   * as not found.
+   */
+  inspectMemory?(request: {
+    memoryId: string;
+    namespaces: readonly string[];
+  }): Promise<PlannerMemoryInspection | null>;
   /**
    * One-hop entity-graph neighbors of the supplied candidates. Returns the
    * union (deduped by memoryId); neighbors not already in `seedIds` only.
@@ -99,6 +111,7 @@ export interface PlannerDeps {
   classifyAndDraft(request: {
     text: string;
     candidates: PlannerCandidate[];
+    abortSignal?: AbortSignal;
   }): Promise<LlmClassificationResult>;
   /**
    * Render a human-readable diff preview for the planned actions, using
@@ -120,6 +133,13 @@ export interface PlannerDeps {
   now(): Date;
 }
 
+/** One memory inspected for an explicit duplicate supersede. */
+export interface PlannerMemoryInspection {
+  candidate: PlannerCandidate;
+  /** Omitted status is treated as active (older files leave it unset). */
+  status?: string;
+}
+
 /** Result of the single LLM classify+draft call. */
 export interface LlmClassificationResult {
   classification: CorrectionClassification;
@@ -177,10 +197,15 @@ export class CorrectionPlanner {
       );
     }
 
-    // 1. LOCATE
-    const located = await this.locateCandidates(cleaned, namespaces, abortSignal);
+    // 1. LOCATE — duplicateOf skips search and the classifier.
+    const explicitDuplicate = cleaned.duplicateOf
+      ? await this.planExplicitDuplicate(cleaned, namespaces, abortSignal)
+      : null;
+    const located = explicitDuplicate
+      ? { candidates: [explicitDuplicate.loser] }
+      : await this.locateCandidates(cleaned, namespaces, abortSignal);
     throwIfAborted(abortSignal, "correction planning aborted");
-    if (located.candidates.length === 0) {
+    if (!explicitDuplicate && located.candidates.length === 0) {
       // No candidates AND no explicit targets → empty plan is valid (the user
       // can still discard). But explicit-target-not-found was already raised
       // inside locateCandidates (rule 34).
@@ -191,10 +216,13 @@ export class CorrectionPlanner {
     }
 
     // 2. CLASSIFY + DRAFT
-    const llm = await this.deps.classifyAndDraft({
-      text: cleaned.text,
-      candidates: located.candidates,
-    });
+    const llm = explicitDuplicate
+      ? explicitDuplicate.llm
+      : await this.deps.classifyAndDraft({
+          text: cleaned.text,
+          candidates: located.candidates,
+          abortSignal,
+        });
     throwIfAborted(abortSignal, "correction planning aborted");
 
     // Validate every action shape before persisting — the adapter is trusted
@@ -235,6 +263,7 @@ export class CorrectionPlanner {
     // absent from the candidate set and warn.
     const candidateIds = new Set(located.candidates.map((c) => c.memoryId));
     if (llm.actions.length > 0 && candidateIds.size > 0) {
+      const explicitWinner = cleaned.duplicateOf;
       const filtered = llm.actions.filter((action) => {
         const id =
           action.kind === "supersede"
@@ -242,7 +271,19 @@ export class CorrectionPlanner {
             : action.kind === "edit" || action.kind === "retract" || action.kind === "rescope"
               ? action.memoryId
               : null;
-        return id === null || candidateIds.has(id);
+        if (id !== null && !candidateIds.has(id)) return false;
+        // A model-picked winner must be a located candidate. duplicateOf is
+        // the exception: that winner was validated as an active memory and is
+        // intentionally not part of the mutated set.
+        if (
+          action.kind === "supersede" &&
+          action.winnerId &&
+          action.winnerId !== explicitWinner &&
+          !candidateIds.has(action.winnerId)
+        ) {
+          return false;
+        }
+        return true;
       });
       if (filtered.length < llm.actions.length) {
         const dropped = llm.actions.length - filtered.length;
@@ -290,6 +331,71 @@ export class CorrectionPlanner {
     return this.persist(plan, abortSignal);
   }
 
+  private async planExplicitDuplicate(
+    request: CorrectionRequest,
+    namespaces: readonly string[],
+    abortSignal?: AbortSignal,
+  ): Promise<{ loser: PlannerCandidate; llm: LlmClassificationResult }> {
+    const winnerId = request.duplicateOf;
+    if (!winnerId || !request.targetIds || request.targetIds.length !== 1) {
+      throw new CorrectionContractError(
+        "CorrectionRequest.duplicateOf requires exactly one targetIds entry (the duplicate memory).",
+      );
+    }
+    if (request.targetIds[0] === winnerId) {
+      throw new CorrectionContractError(
+        "CorrectionRequest.duplicateOf must be a different memory from targetIds.",
+      );
+    }
+    const loserId = request.targetIds[0];
+    const loser = await this.inspectDuplicateParty(loserId, namespaces, "target");
+    throwIfAborted(abortSignal, "correction planning aborted");
+    await this.inspectDuplicateParty(winnerId, namespaces, "duplicateOf");
+    throwIfAborted(abortSignal, "correction planning aborted");
+    return {
+      loser,
+      llm: {
+        classification: "outdated",
+        confidence: 1,
+        actions: [{ kind: "supersede", loserId, winnerId }],
+        relevance: [{
+          memoryId: loserId,
+          why: `duplicate of ${winnerId}; recoverable supersede`,
+        }],
+        warnings: [],
+      },
+    };
+  }
+
+  private async inspectDuplicateParty(
+    memoryId: string,
+    namespaces: readonly string[],
+    role: "target" | "duplicateOf",
+  ): Promise<PlannerCandidate> {
+    const notFound = role === "target"
+      ? `target memory not found: ${memoryId}`
+      : `duplicateOf memory not found: ${memoryId}`;
+    const inactive = (status: string) => role === "target"
+      ? `target memory is not active: ${memoryId} (${status})`
+      : `duplicateOf memory is not active: ${memoryId} (${status})`;
+    if (this.deps.inspectMemory) {
+      const found = await this.deps.inspectMemory({ memoryId, namespaces });
+      if (!found) throw new CorrectionContractError(notFound);
+      const status = found.status && found.status.length > 0 ? found.status : "active";
+      if (status !== "active") throw new CorrectionContractError(inactive(status));
+      return found.candidate;
+    }
+    try {
+      const resolved = await this.deps.resolveTargets({ targetIds: [memoryId], namespaces });
+      const candidate = resolved.find((item) => item.memoryId === memoryId) ?? resolved[0];
+      if (!candidate) throw new CorrectionContractError(notFound);
+      return candidate;
+    } catch (err) {
+      if (err instanceof CorrectionContractError) throw new CorrectionContractError(notFound);
+      throw err;
+    }
+  }
+
   private async locateCandidates(
     request: CorrectionRequest,
     namespaces: readonly string[],

package/src/correction/correction-surfaces.test.ts

@@ -39,7 +39,7 @@ function extractToolNames(response: unknown): Set<string> {
 }
 
 interface MockCalls {
-  planRequests: Array<{ text: string; targetIds?: string[]; principal?: string; abortSignal?: AbortSignal }>;
+  planRequests: Array<{ text: string; targetIds?: string[]; duplicateOf?: string; principal?: string; abortSignal?: AbortSignal }>;
   applyRequests: Array<{ planId: string; confirm: boolean; principal?: string; abortSignal?: AbortSignal }>;
 }
 
@@ -54,6 +54,7 @@ function makeMockService(
       req: {
         text: string;
         targetIds?: string[];
+        duplicateOf?: string;
         principal?: string;
       },
       opts?: { abortSignal?: AbortSignal },
@@ -128,6 +129,26 @@ test("tools/list gate: correction tools present when correctionVisible on (defau
   assert.equal(names.has("engram.memory_correct_apply"), true, "apply tool must be present by default");
   assert.equal(names.has("remnic_memory_correct_plan"), true, "plan alias must be present");
   assert.equal(names.has("remnic_memory_correct_apply"), true, "apply alias must be present");
+  const tools = (response as { result?: { tools?: Array<{ name?: string; inputSchema?: { properties?: Record<string, unknown> } }> } }).result?.tools ?? [];
+  const planTool = tools.find((tool) => tool.name === "engram.memory_correct_plan");
+  assert.ok(planTool?.inputSchema?.properties?.duplicateOf, "plan schema must advertise duplicateOf");
+});
+
+test("MCP surface: memory_correct_plan forwards duplicateOf", async () => {
+  const { service, calls } = makeMockService(STUB_PLAN, STUB_OUTCOME);
+  const server = new EngramMcpServer(service, { emitLegacyTools: true, correctionVisible: true });
+  await server.handleRequest({
+    jsonrpc: "2.0",
+    id: 2,
+    method: "tools/call",
+    params: {
+      name: "engram.memory_correct_plan",
+      arguments: { text: "duplicate", targetIds: ["mem-loser"], duplicateOf: "mem-winner" },
+    },
+  });
+  assert.equal(calls.planRequests.length, 1);
+  assert.deepEqual(calls.planRequests[0]?.targetIds, ["mem-loser"]);
+  assert.equal(calls.planRequests[0]?.duplicateOf, "mem-winner");
 });
 
 // ---------------------------------------------------------------------------

package/src/local-llm-qos.test.ts

@@ -188,6 +188,42 @@ test("LocalLlmClient allows recall-critical work to run while background work is
   }
 });
 
+test("LocalLlmClient drops a queued background request when its signal aborts", async () => {
+  const client = new LocalLlmClient(createConfig());
+  let runs = 0;
+  let releaseHeld: (() => void) | undefined;
+  (client as any).runChatCompletionRequest = async () => {
+    runs += 1;
+    await new Promise<void>((resolve) => {
+      releaseHeld = resolve;
+    });
+    return {
+      content: "held",
+      usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2 },
+    };
+  };
+
+  const held = client.chatCompletion(
+    [{ role: "user", content: "hold" }],
+    { operation: "hold", priority: "background" },
+  );
+  await tick();
+  assert.equal(runs, 1);
+
+  const controller = new AbortController();
+  const queued = client.chatCompletion(
+    [{ role: "user", content: "queued" }],
+    { operation: "queued", priority: "background", signal: controller.signal },
+  );
+  controller.abort();
+  assert.equal(await queued, null);
+  assert.equal(runs, 1);
+  assert.equal((client as any).requestQueues.background.length, 0);
+
+  releaseHeld?.();
+  assert.equal((await held)?.content, "held");
+});
+
 test("LocalLlmClient skips queued work once a cooldown is activated", async () => {
   const client = new LocalLlmClient(createConfig());
   const executionOrder: string[] = [];

package/src/local-llm.ts

@@ -1351,13 +1351,30 @@ export class LocalLlmClient {
     if (options.priority) {
       const priority = options.priority;
       return await new Promise<LocalLlmChatCompletionResult | null>((resolve) => {
-        this.requestQueues[priority].push({
+        let settled = false;
+        let onAbort: (() => void) | undefined;
+        const finish = (value: LocalLlmChatCompletionResult | null): void => {
+          if (settled) return;
+          settled = true;
+          if (onAbort) options.signal?.removeEventListener("abort", onAbort);
+          resolve(value);
+        };
+        const queued: LocalLlmQueuedRequest = {
           messages,
           options,
           priority,
           enqueuedAtMs: Date.now(),
-          resolve,
-        });
+          resolve: finish,
+        };
+        onAbort = () => {
+          const queue = this.requestQueues[priority];
+          const index = queue.indexOf(queued);
+          if (index >= 0) queue.splice(index, 1);
+          finish(null);
+        };
+        this.requestQueues[priority].push(queued);
+        if (options.signal?.aborted) onAbort();
+        else if (options.signal) options.signal.addEventListener("abort", onAbort, { once: true });
         this.scheduleQueueDrain();
       });
     }

package/src/orchestration/session-context.ts

@@ -632,21 +632,6 @@ export class SessionContextCoordinator {
         const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
         return canWriteNamespace(principal, req.namespace, this.deps.config);
       },
-      llmComplete: async ({ system, user }) => {
-        const llmResult = await this.deps.localLlm.chatCompletion(
-          [
-            { role: "system", content: system },
-            { role: "user", content: user },
-          ],
-          { operation: "correction-classify", priority: "background" },
-        );
-        if (!llmResult) {
-          throw new Error(
-            "passive correction classify+draft: local LLM unavailable (disabled or in cooldown)",
-          );
-        }
-        return llmResult.content;
-      },
     });
     return this.deps._passiveCorrectionService;
   }

package/src/recall-handles-wiring.test.ts

@@ -397,6 +397,30 @@ test("correctionPlan: a handle in targetIds is resolved before planning; an unkn
   }
 });
 
+test("correctionPlan: a handle in duplicateOf is resolved before planning", async () => {
+  const { service, memoryDir } = await makeHarness({
+    recallMemoryHandles: true,
+    correctionEnabled: true,
+  });
+  try {
+    await assert.rejects(
+      () =>
+        service.correctionPlan({
+          text: "that memory is a duplicate",
+          targetIds: ["fact-loser"],
+          duplicateOf: "[m:dead]",
+          sessionKey: SESSION,
+        }),
+      (err: unknown) =>
+        err instanceof EngramAccessInputError &&
+        /not found/i.test((err as Error).message) &&
+        (err as Error).message.includes("[m:dead]"),
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("correctionPlan: a resolved handle targetIds set reaches the planner as concrete ids (round-trip)", async () => {
   const { orchestrator, service, memoryDir } = await makeHarness({
     recallMemoryHandles: true,

package/src/types.ts

@@ -916,33 +916,16 @@ export interface PluginConfig
    * deployments prefer the older (always-inject) behavior. Default `false`.
    */
   temporalExpiredInInjection: boolean;
-  /**
-   * Correction Contract (issue #1580) — one plan/apply pipeline for memory
-   * corrections. Master visibility + enforcement gate for the
-   * `memory_correct_plan` / `memory_correct_apply` tools. Default `true`:
-   * planning is read-only (locates candidates + drafts a pending plan file)
-   * and safe to ship on; `false` hides the tools and rejects runtime calls so
-   * the surface cannot drift out of sync. Parsed from `correction.enabled`
-   * (nested) or `correctionEnabled` (flat legacy).
-   */
+  /** Correction Contract (#1580). `correction.enabled` / `correctionEnabled`. Default true. */
   correctionEnabled: boolean;
-  /**
-   * Whether `memory_correct_apply` requires an explicit `confirm: true` to
-   * mutate memories. Default `true` (least-privileged). Parsed from
-   * `correction.applyRequiresConfirm` / `correctionApplyRequiresConfirm`.
-   */
+  /** Apply requires `confirm: true`. `correction.applyRequiresConfirm`. Default true. */
   correctionApplyRequiresConfirm: boolean;
-  /**
-   * Max memories a single correction plan may touch; over-limit plans are
-   * rejected, never silently truncated (review thread). Default `10`. Parsed
-   * from `correction.maxAffected` / `correctionMaxAffected`.
-   */
+  /** Max memories one plan may touch. `correction.maxAffected`. Default 10. */
   correctionMaxAffected: number;
-  /**
-   * Plan time-to-live in hours; expired plans are rejected at apply. Default
-   * `24`. Parsed from `correction.planTtlHours` / `correctionPlanTtlHours`.
-   */
+  /** Plan TTL hours. `correction.planTtlHours`. Default 24. */
   correctionPlanTtlHours: number;
+  /** Per-attempt classify timeout (ms, 1..300000). `correction.classifyTimeoutMs`. Default 45000. */
+  correctionClassifyTimeoutMs: number;
   /**
    * Passive correction capture (issue #1581) — detects corrections expressed
    * passively in conversation turns during extraction and routes them to the