@remnic/core 10.0.3 → 10.0.5

package/dist/{chunk-NGOZH7R5.js → chunk-GVUW5XK5.js}

@@ -12,9 +12,6 @@ import {
 import {
   isSharedContextWriteInputError
 } from "./chunk-IFBSZGW3.js";
-import {
-  UNATTRIBUTED_ACCESS_WRITE_ORIGIN
-} from "./chunk-OGXXGHW6.js";
 import {
   ACTIVE_DECISION_STATUSES,
   CodegraphRuntimeError,
@@ -34,14 +31,17 @@ import {
   serializeDecisionRecord
 } from "./chunk-EQUD7FP4.js";
 import {
-  WriteQuarantineStore
-} from "./chunk-BANSBRNX.js";
+  UNATTRIBUTED_ACCESS_WRITE_ORIGIN
+} from "./chunk-OGXXGHW6.js";
 import {
   WHO_KNOWS_DEFAULT_LIMIT,
   computeWhoKnows,
   loadWhoKnowsEntities,
   validateWhoKnowsInput
-} from "./chunk-2NV7MMMM.js";
+} from "./chunk-XQSJXNWC.js";
+import {
+  WriteQuarantineStore
+} from "./chunk-BANSBRNX.js";
 import {
   trustResultFor
 } from "./chunk-GNVZQ5JN.js";
@@ -59,7 +59,7 @@ import {
 } from "./chunk-ROBHL3GL.js";
 import {
   summarizeHourlyStatus
-} from "./chunk-NQHSXHJP.js";
+} from "./chunk-L6GNS5GB.js";
 import {
   planSessionTranscriptMigration
 } from "./chunk-WWDO7ZWM.js";
@@ -68,7 +68,7 @@ import {
 } from "./chunk-JYG2334B.js";
 import {
   runRecallWhy
-} from "./chunk-R4NGLTUS.js";
+} from "./chunk-TDMNADPI.js";
 import {
   renderNavigationResult
 } from "./chunk-KIW3OOZE.js";
@@ -84,7 +84,7 @@ import {
 } from "./chunk-VYDGHJIN.js";
 import {
   planDisclosureStep
-} from "./chunk-35A7GCHG.js";
+} from "./chunk-6T42L5FI.js";
 import {
   parseNavigateLinkType
 } from "./chunk-7O5EW7KX.js";
@@ -93,41 +93,41 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-32HO62I4.js";
+} from "./chunk-OFEHITAZ.js";
 import {
   estimateRecallTokens,
   summarizeDisclosureTokens
-} from "./chunk-QPWUG2S3.js";
+} from "./chunk-CYEK6Z3P.js";
+import {
+  buildEmbeddingAwareSnapshotStream
+} from "./chunk-BNMI3JBV.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-CSLK7BN6.js";
+} from "./chunk-7LYRFI5A.js";
 import {
   ReplicaDivergenceMonitor
 } from "./chunk-E6UNM67F.js";
 import {
-  buildEmbeddingAwareSnapshotStream
-} from "./chunk-BNMI3JBV.js";
+  recordMemoryOutcome
+} from "./chunk-UD7UNYRD.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-6WHJ2EAB.js";
 import {
   objectiveStateStoreOverrideForNamespace
 } from "./chunk-HM7RHKS4.js";
-import {
-  recordMemoryOutcome
-} from "./chunk-UD7UNYRD.js";
 import {
   runMemoryBrowse
-} from "./chunk-EJJMDLVB.js";
+} from "./chunk-IJ4FEGZR.js";
 import {
   isSearchExcludedPath
-} from "./chunk-2EZB2DL5.js";
+} from "./chunk-GE6HETIF.js";
 import {
   coerceIncludedMemories
 } from "./chunk-2YA5N2BY.js";
 import {
   readProjectedHarmonicGraph
-} from "./chunk-RXT6UB25.js";
+} from "./chunk-YJAOYEWI.js";
 import {
   buildGraphSnapshot
 } from "./chunk-CHDGJJV6.js";
@@ -145,7 +145,7 @@ import {
 } from "./chunk-BLVHDY2U.js";
 import {
   LocalLlmClient
-} from "./chunk-IDSSDL4W.js";
+} from "./chunk-JXSYWTFK.js";
 import {
   REDACTION_RULES_SUBDIR
 } from "./chunk-LTHVM4XN.js";
@@ -163,6 +163,9 @@ import {
   composeRecallContext,
   renderAuthorityBoundContent
 } from "./chunk-NVKO5YKP.js";
+import {
+  callDeepRecallPolicyLlm
+} from "./chunk-JNLEJE4A.js";
 import {
   renderDeepRecallResult
 } from "./chunk-RF2SMMPP.js";
@@ -176,9 +179,6 @@ import {
   CrossNamespaceBudget,
   toBudgetWarning
 } from "./chunk-UFGFMWAD.js";
-import {
-  callDeepRecallPolicyLlm
-} from "./chunk-JNLEJE4A.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -186,11 +186,11 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-IXYIW3MZ.js";
+} from "./chunk-4K2H4KTR.js";
 import {
   CorpusWatermarkCache,
   computeServiceCorpusCensus
-} from "./chunk-CGOKNQDK.js";
+} from "./chunk-ANZXWOYD.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
@@ -200,19 +200,31 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-6AA7XFMO.js";
+} from "./chunk-GF4H3B3R.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-NLYOOGZ7.js";
+} from "./chunk-KE5PWLI6.js";
+import {
+  meetingsBuild,
+  meetingsGet,
+  meetingsList,
+  wearablesStatus,
+  wearablesSync,
+  wearablesTranscriptDay,
+  wearablesTranscriptMemories,
+  wearablesTranscriptSearch
+} from "./chunk-SYOIVK7K.js";
 import {
   CORRECTION_TEXT_MAX,
   CorrectionContractError,
+  DEFAULT_CORRECTION_CLASSIFY_TIMEOUT_MS,
+  MAX_CORRECTION_CLASSIFY_TIMEOUT_MS,
   deterministicFallbackPlan,
   newPlanId,
   validateCorrectionAction,
   validateCorrectionRequest,
   validateRedactionPattern
-} from "./chunk-QLK3SL7Q.js";
+} from "./chunk-ETSJD5IV.js";
 import {
   isCodingKnowledgeFeatureEnabled
 } from "./chunk-FEHIOYML.js";
@@ -244,10 +256,10 @@ import {
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-6JIHC5AS.js";
+} from "./chunk-37HCPM56.js";
 import {
   namespaceCollectionName
-} from "./chunk-GUD6FYQG.js";
+} from "./chunk-RSMIRLKM.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -270,28 +282,33 @@ import {
   supersessionKeysForFact
 } from "./chunk-5WITETWU.js";
 import {
-  FallbackLlmClient
+  FallbackLlmClient,
+  gatewayTaskChainOptions
 } from "./chunk-TKC5LZ43.js";
+import {
+  fallbackLlmRuntimeContextFromConfig
+} from "./chunk-EP6BA7VV.js";
+import {
+  DEFAULT_RECALL_DISCLOSURE,
+  isRecallDisclosure
+} from "./chunk-QWWMS4AE.js";
+import {
+  extractJsonCandidates
+} from "./chunk-YBA52OKG.js";
 import {
   delegateExtractionForceFlush
 } from "./chunk-RMMA44HE.js";
 import {
-  meetingsBuild,
-  meetingsGet,
-  meetingsList,
-  wearablesStatus,
-  wearablesSync,
-  wearablesTranscriptDay,
-  wearablesTranscriptMemories,
-  wearablesTranscriptSearch
-} from "./chunk-SYOIVK7K.js";
+  ObserveTranscriptPersister,
+  observeTranscriptSessionKey
+} from "./chunk-T2JSUEH6.js";
 import {
   splitCanonicalWriteRequest
 } from "./chunk-HRZZJ4XB.js";
 import {
   applyBriefingLocationContext,
   daySummaryAutoOptions
-} from "./chunk-MY7B3HYC.js";
+} from "./chunk-CLCMDKTB.js";
 import {
   STRUCTURED_ATTRIBUTE_LIMITS,
   buildAccessWriteRequestFingerprint,
@@ -318,10 +335,10 @@ import {
 } from "./chunk-Z2YFLXHU.js";
 import {
   createOfflineSyncManifestStream
-} from "./chunk-WI37MWRZ.js";
+} from "./chunk-63UNVGZW.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-2JRB3Z5N.js";
+} from "./chunk-EP5WXE2G.js";
 import {
   resolveScopePlan,
   resolveScopedWritableNamespaceValue,
@@ -342,49 +359,6 @@ import {
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
-import {
-  assertOperationAuthorizationAllowed,
-  capabilityAllowsOp,
-  enforceNamespaceAllowList,
-  isNamespaceAllowed,
-  tokenCapabilityStore
-} from "./chunk-IG747LRN.js";
-import {
-  writeFileAtomically
-} from "./chunk-AW4QUFQF.js";
-import {
-  computeContentHash
-} from "./chunk-5FVVY2EB.js";
-import {
-  applyOfflineSyncChangeset,
-  applyOfflineSyncFileContentChunk,
-  buildOfflineSyncSnapshot,
-  buildOfflineSyncSnapshotForPaths,
-  buildOfflineSyncSnapshotFromBase,
-  normalizeOfflineSyncChangeset,
-  readOfflineSyncFileContentChunk
-} from "./chunk-TGF43K66.js";
-import {
-  compileOfflineSyncExcludeGlobs
-} from "./chunk-63LFM77Z.js";
-import {
-  validateArchiveRelativePath
-} from "./chunk-GCGJW34D.js";
-import {
-  serializeMutations,
-  withHeldFileLock
-} from "./chunk-FFAZ2XFU.js";
-import {
-  createRecallCorpusVersionCapture,
-  mergeRecallCorpusVersions
-} from "./chunk-YVRQ5JRA.js";
-import {
-  DEFAULT_RECALL_DISCLOSURE,
-  isRecallDisclosure
-} from "./chunk-RKDSELA3.js";
-import {
-  extractJsonCandidates
-} from "./chunk-YBA52OKG.js";
 import {
   SUPPORT_PASSPORT_ATTRIBUTE_KEYS,
   SUPPORT_PASSPORT_CARD_TAG,
@@ -408,6 +382,19 @@ import {
   isSupportPassportPrivateMemory,
   projectSupportPassportCard
 } from "./chunk-PWPIERBM.js";
+import {
+  assertOperationAuthorizationAllowed,
+  capabilityAllowsOp,
+  enforceNamespaceAllowList,
+  isNamespaceAllowed,
+  tokenCapabilityStore
+} from "./chunk-IG747LRN.js";
+import {
+  writeFileAtomically
+} from "./chunk-BTNNL7ZW.js";
+import {
+  computeContentHash
+} from "./chunk-5FVVY2EB.js";
 import {
   stripAttributesSuffix
 } from "./chunk-JDSVLVCG.js";
@@ -420,9 +407,32 @@ import {
   parseIdOrHandle,
   resolveHandle
 } from "./chunk-JAKIDQB2.js";
+import {
+  applyOfflineSyncChangeset,
+  applyOfflineSyncFileContentChunk,
+  buildOfflineSyncSnapshot,
+  buildOfflineSyncSnapshotForPaths,
+  buildOfflineSyncSnapshotFromBase,
+  normalizeOfflineSyncChangeset,
+  readOfflineSyncFileContentChunk
+} from "./chunk-TGF43K66.js";
+import {
+  compileOfflineSyncExcludeGlobs
+} from "./chunk-63LFM77Z.js";
+import {
+  validateArchiveRelativePath
+} from "./chunk-GCGJW34D.js";
+import {
+  serializeMutations,
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
 import {
   parseIsoOffsetTimestamp
 } from "./chunk-P7FMDTKL.js";
+import {
+  createRecallCorpusVersionCapture,
+  mergeRecallCorpusVersions
+} from "./chunk-YVRQ5JRA.js";
 import {
   defaultNamespaceAtFlatRoot,
   memorySearchThroughScope,
@@ -461,10 +471,6 @@ import {
   PendingObserveExtractionTracker,
   pendingObserveScopeHint
 } from "./chunk-LNEWDF2A.js";
-import {
-  ObserveTranscriptPersister,
-  observeTranscriptSessionKey
-} from "./chunk-T2JSUEH6.js";
 import {
   AccessIdempotencyStore,
   hashAccessIdempotencyPayload
@@ -1431,17 +1437,19 @@ var CorrectionPlanner = class _CorrectionPlanner {
         "Correction requires at least one readable namespace \u2014 principal has no read scope."
       );
     }
-    const located = await this.locateCandidates(cleaned, namespaces, abortSignal);
+    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) {
       return this.persist(
         this.emptyPlan(cleaned, namespaces[0], "no matching memories found for the correction text"),
         abortSignal
       );
     }
-    const llm = await this.deps.classifyAndDraft({
+    const llm = explicitDuplicate ? explicitDuplicate.llm : await this.deps.classifyAndDraft({
       text: cleaned.text,
-      candidates: located.candidates
+      candidates: located.candidates,
+      abortSignal
     });
     throwIfAborted(abortSignal, "correction planning aborted");
     for (const action of llm.actions) {
@@ -1463,9 +1471,14 @@ var CorrectionPlanner = class _CorrectionPlanner {
     }
     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" ? action.loserId : 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;
+        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;
@@ -1503,6 +1516,57 @@ var CorrectionPlanner = class _CorrectionPlanner {
     throwIfAborted(abortSignal, "correction planning aborted");
     return this.persist(plan, abortSignal);
   }
+  async planExplicitDuplicate(request, namespaces, abortSignal) {
+    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: []
+      }
+    };
+  }
+  async inspectDuplicateParty(memoryId, namespaces, role) {
+    const notFound = role === "target" ? `target memory not found: ${memoryId}` : `duplicateOf memory not found: ${memoryId}`;
+    const inactive = (status) => 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;
+    }
+  }
   async locateCandidates(request, namespaces, abortSignal) {
     if (request.targetIds && request.targetIds.length > 0) {
       const targets = await this.deps.resolveTargets({
@@ -2055,13 +2119,27 @@ var CorrectionExecutor = class {
           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" : void 0;
+            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") {
@@ -2370,6 +2448,94 @@ var CorrectionService = class {
 // src/correction/correction-access-wiring.ts
 import path3 from "path";
 import { createHash } from "crypto";
+
+// src/correction/correction-classify.ts
+async function completeCorrectionClassify(messages, deps, abortSignal) {
+  throwIfAborted(abortSignal, "correction classify aborted");
+  const timeoutMs = classifyTimeoutMs(deps.config);
+  const gatewayPrimary = deps.config.modelSource === "gateway";
+  const localEnabled = resolveLocalLlmCapabilities(deps.config).localLlm === true && !gatewayPrimary;
+  if (localEnabled) {
+    const localAttempt = startAttempt(abortSignal, timeoutMs);
+    try {
+      const local = await deps.localLlm.chatCompletion(messages, {
+        operation: "correction-classify",
+        priority: "background",
+        timeoutMs,
+        temperature: 0.2,
+        signal: localAttempt.signal
+      });
+      if (abortSignal?.aborted) throw abortError("correction classify aborted");
+      if (local?.content) return local.content;
+      if (deps.config.localLlmFallback === false) {
+        throw new Error("correction classify: local LLM unavailable and fallback disabled");
+      }
+    } catch (err) {
+      if (abortSignal?.aborted) {
+        throw isAbortError(err) ? err : abortError("correction classify aborted");
+      }
+      if (deps.config.localLlmFallback === false) {
+        if (isAbortError(err)) {
+          throw new Error("correction classify: local LLM timed out and fallback disabled");
+        }
+        throw err;
+      }
+    } finally {
+      localAttempt.dispose();
+    }
+  } else if (!gatewayPrimary && deps.config.localLlmFallback === false) {
+    throw new Error("correction classify: local LLM disabled and fallback disabled");
+  }
+  throwIfAborted(abortSignal, "correction classify aborted");
+  const fallbackAttempt = startAttempt(abortSignal, timeoutMs);
+  try {
+    const fallbackOptions = {
+      temperature: 0.2,
+      timeoutMs,
+      signal: fallbackAttempt.signal,
+      ...gatewayTaskChainOptions(deps.config)
+    };
+    const fallback = deps.fallbackChat ? await deps.fallbackChat(messages, fallbackOptions) : await new FallbackLlmClient(
+      deps.config.gatewayConfig,
+      fallbackLlmRuntimeContextFromConfig(deps.config)
+    ).chatCompletion(messages, fallbackOptions);
+    if (abortSignal?.aborted) throw abortError("correction classify aborted");
+    return fallback?.content ?? null;
+  } catch (err) {
+    if (abortSignal?.aborted) {
+      throw isAbortError(err) ? err : abortError("correction classify aborted");
+    }
+    if (isAbortError(err)) return null;
+    throw err;
+  } finally {
+    fallbackAttempt.dispose();
+  }
+}
+function classifyTimeoutMs(config) {
+  const configured = config.correctionClassifyTimeoutMs;
+  if (typeof configured === "number" && Number.isInteger(configured) && configured >= 1 && configured <= MAX_CORRECTION_CLASSIFY_TIMEOUT_MS) {
+    return configured;
+  }
+  return DEFAULT_CORRECTION_CLASSIFY_TIMEOUT_MS;
+}
+function startAttempt(caller, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onCaller = () => controller.abort();
+  if (caller?.aborted) controller.abort();
+  else caller?.addEventListener("abort", onCaller, { once: true });
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearTimeout(timer);
+    caller?.removeEventListener("abort", onCaller);
+  };
+  controller.signal.addEventListener("abort", dispose, { once: true });
+  return { signal: controller.signal, dispose };
+}
+
+// src/correction/correction-access-wiring.ts
 function createCorrectionService(wiring) {
   const cfg = wiring.orchestrator.config;
   const correctionEnabled = isCorrectionFeatureEnabled(cfg);
@@ -2394,8 +2560,9 @@ function makePlannerDeps(wiring, opts) {
   return {
     searchCorpus: async ({ text, namespaces, limit }) => searchMemories(wiring, text, namespaces, limit),
     resolveTargets: async ({ targetIds, namespaces }) => resolveTargetMemories(wiring, targetIds, namespaces),
+    inspectMemory: async ({ memoryId, namespaces }) => inspectCorrectionMemory(wiring, memoryId, namespaces),
     expandNeighbors: async ({ seedIds, namespaces, limit }) => expandEntityNeighbors(wiring, seedIds, namespaces, limit),
-    classifyAndDraft: async ({ text, candidates }) => classifyAndDraft(wiring, text, candidates),
+    classifyAndDraft: async ({ text, candidates, abortSignal }) => classifyAndDraft(wiring, text, candidates, abortSignal),
     renderDiff: async ({ candidates, actions }) => renderCorrectionDiff(wiring, candidates, actions),
     storageDir: async (namespace) => (await wiring.orchestrator.getStorage(namespace)).dir,
     maxAffected: opts.maxAffected,
@@ -2568,18 +2735,42 @@ async function expandEntityNeighbors(wiring, seedIds, namespaces, limit) {
   }
   return out;
 }
-async function classifyAndDraft(wiring, text, candidates) {
+async function classifyAndDraft(wiring, text, candidates, abortSignal) {
   try {
-    if (!wiring.llmComplete) {
-      return fallbackClassification(candidates, "no LLM client available");
-    }
+    throwIfAborted(abortSignal, "correction classify aborted");
     const user = buildClassifyPrompt(text, candidates);
-    const raw = await wiring.llmComplete({ system: CLASSIFY_SYSTEM_PROMPT, user });
+    const raw = wiring.llmComplete ? await wiring.llmComplete({ system: CLASSIFY_SYSTEM_PROMPT, user, abortSignal }) : await completeCorrectionClassify(
+      [
+        { role: "system", content: CLASSIFY_SYSTEM_PROMPT },
+        { role: "user", content: user }
+      ],
+      { config: wiring.orchestrator.config, localLlm: wiring.orchestrator.localLlm },
+      abortSignal
+    );
+    if (raw == null) return fallbackClassification(candidates, "correction classify unavailable");
+    throwIfAborted(abortSignal, "correction classify aborted");
     return parseClassifyResponse(raw, candidates);
   } catch (err) {
+    if (isAbortError(err) || abortSignal?.aborted) {
+      throw isAbortError(err) ? err : abortError("correction classify aborted");
+    }
     return fallbackClassification(candidates, `LLM unavailable: ${errMsg2(err)}`);
   }
 }
+async function inspectCorrectionMemory(wiring, memoryId, namespaces) {
+  for (const ns of namespaces) {
+    const storage = await wiring.orchestrator.getStorage(ns);
+    const memory = await storage.getMemoryByIdIncludingArchived(memoryId);
+    if (!memory || memory.frontmatter.id !== memoryId) continue;
+    const candidate = toCandidate(memory, ns, 1);
+    if (isSupportPassportPrivateMemory(memory)) return { candidate, status: "ineligible" };
+    if (typeof memory.frontmatter.archivedAt === "string" && memory.frontmatter.archivedAt.length > 0) {
+      return { candidate, status: "archived" };
+    }
+    return { candidate, status: memory.frontmatter.status ?? "active" };
+  }
+  return null;
+}
 async function renderCorrectionDiff(_wiring, candidates, actions) {
   const lines = [];
   for (const action of actions) {
@@ -2596,7 +2787,7 @@ async function renderCorrectionDiff(_wiring, candidates, actions) {
 function describeAfterState(action) {
   switch (action.kind) {
     case "supersede":
-      return action.replacement?.content ?? "(superseded without replacement)";
+      return action.replacement?.content ?? (action.winnerId ? `(superseded by ${action.winnerId}; recoverable)` : "(superseded without replacement)");
     case "edit":
       return action.patch;
     case "retract":
@@ -2912,7 +3103,8 @@ function toExecutorMemory(m) {
     ...fm.entityRef ? { entityRef: fm.entityRef } : {},
     ...supersessionKeys.length > 0 ? { supersessionKeys } : {},
     ...supersessionKeys.length > 0 ? { supersessionKey: supersessionKeys[0] } : {},
-    ...typeof fm.contentHash === "string" && fm.contentHash.length > 0 ? { contentHash: fm.contentHash } : {}
+    ...typeof fm.contentHash === "string" && fm.contentHash.length > 0 ? { contentHash: fm.contentHash } : {},
+    status: fm.status ?? "active"
   };
 }
 function isCorrectionFeatureEnabled(config) {
@@ -2968,6 +3160,7 @@ Given a correction statement and candidate memories, respond with a JSON object:
 
 Action shapes:
 - {"kind":"supersede","loserId":"<id>","replacement":{"content":"<new fact>"}}
+- {"kind":"supersede","loserId":"<id>","winnerId":"<existing id>"}
 - {"kind":"edit","memoryId":"<id>","patch":"<new full content>"}
 - {"kind":"retract","memoryId":"<id>"}
 - {"kind":"rescope","memoryId":"<id>","toNamespace":"<ns>"}
@@ -6992,21 +7185,6 @@ var SessionContextCoordinator = class {
       canWriteNamespace: async (req) => {
         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;
@@ -16346,24 +16524,6 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
         } catch {
           return Promise.resolve(false);
         }
-      },
-      // Wire the orchestrator's extraction LLM so classify+draft actually
-      // drafts actions instead of always hitting the deterministic fallback
-      // (review thread PG5). The planner's classifyAndDraft already falls back
-      // on any LLM outage, so returning null (LLM disabled/cooldown) or a
-      // thrown error both degrade safely to the deterministic path (rule 13).
-      llmComplete: async ({ system, user }) => {
-        const result = await this.orchestrator.localLlm.chatCompletion(
-          [
-            { role: "system", content: system },
-            { role: "user", content: user }
-          ],
-          { operation: "correction-classify", priority: "background" }
-        );
-        if (!result) {
-          throw new Error("correction classify+draft: local LLM unavailable (disabled or in cooldown)");
-        }
-        return result.content;
       }
     });
     this._correctionService = service;
@@ -16385,11 +16545,20 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
     }
   }
   async correctionPlan(request, opts) {
+    let next = request;
     if (request.targetIds?.some((id) => isHandleToken(id))) {
-      const targetIds = request.targetIds.map((id) => this.resolveMemoryIdOrHandleInput(id, request.sessionKey));
-      return this.correctionService().plan({ ...request, targetIds }, opts);
+      next = {
+        ...next,
+        targetIds: request.targetIds.map((id) => this.resolveMemoryIdOrHandleInput(id, request.sessionKey))
+      };
+    }
+    if (request.duplicateOf && isHandleToken(request.duplicateOf)) {
+      next = {
+        ...next,
+        duplicateOf: this.resolveMemoryIdOrHandleInput(request.duplicateOf, request.sessionKey)
+      };
     }
-    return this.correctionService().plan(request, opts);
+    return this.correctionService().plan(next, opts);
   }
   async correctionApply(planId, opts) {
     return this.correctionService().apply(planId, opts);
@@ -18565,4 +18734,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-NGOZH7R5.js.map
+//# sourceMappingURL=chunk-GVUW5XK5.js.map