@remnic/core 9.45.3 → 9.45.5

package/dist/{chunk-CJ2ZR7UA.js → chunk-QUENPGWZ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-3CE77VAP.js";
+} from "./chunk-A4JMGKCD.js";
 import {
   WriteQuarantineStore
 } from "./chunk-PJSK6OJM.js";
@@ -30,25 +30,22 @@ import {
 import {
   planSessionTranscriptMigration
 } from "./chunk-P5FPO2BR.js";
-import {
-  boundRecallContextComposition,
-  composeRecallContext
-} from "./chunk-AHVEHR6K.js";
 import {
   decideDisclosureEscalation
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-3TBLDMJA.js";
+} from "./chunk-O4KMGRXE.js";
 import {
   estimateRecallTokens
-} from "./chunk-TDHTVMPG.js";
+} from "./chunk-HFPASSFV.js";
 import {
-  readAggregateExtractionWatermark
-} from "./chunk-D3J5SLQK.js";
+  boundRecallContextComposition,
+  composeRecallContext
+} from "./chunk-AHVEHR6K.js";
 import {
-  ReplicaDivergenceMonitor
-} from "./chunk-XOQSEF7X.js";
+  readAggregateExtractionWatermark
+} from "./chunk-FR27HBBA.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-ICP53SKG.js";
@@ -56,28 +53,26 @@ import {
   objectiveStateStoreOverrideForNamespace
 } from "./chunk-6HMYUWXR.js";
 import {
-  offlineSyncStorageForSnapshot
-} from "./chunk-6CZPDBJS.js";
-import {
-  resolveScopePlan,
-  resolveScopedWritableNamespaceValue,
-  resolveWritableNamespaceValue
-} from "./chunk-ULARSG5Z.js";
+  ReplicaDivergenceMonitor
+} from "./chunk-CVILPI77.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
 import {
   buildGraphSnapshot
 } from "./chunk-JYIFGGEM.js";
+import {
+  REDACTION_RULES_SUBDIR
+} from "./chunk-LTHVM4XN.js";
 import {
   wrapWorkLayerContext
 } from "./chunk-EI6V5UXY.js";
 import {
   CONNECTOR_LABEL_MAX_LENGTH
-} from "./chunk-T2TTP3KU.js";
+} from "./chunk-X4IDNPOS.js";
 import {
   isValidConnectorId
-} from "./chunk-7TWUCYER.js";
+} from "./chunk-PNRA7FAD.js";
 import {
   formatProfileTraceAscii
 } from "./chunk-NLE6TSLG.js";
@@ -89,7 +84,7 @@ import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
-} from "./chunk-5SM35XZR.js";
+} from "./chunk-S5NZBKKQ.js";
 import {
   lcmEvidenceIdentity
 } from "./chunk-C37ZRXX7.js";
@@ -100,67 +95,44 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-PDLBLTOK.js";
+} from "./chunk-HC3PBX23.js";
 import {
   CorpusWatermarkCache,
   computeServiceCorpusCensus
-} from "./chunk-JE7EK33X.js";
+} from "./chunk-W2V7UESE.js";
 import {
   namespaceCollectionName
-} from "./chunk-HLPD7B7P.js";
+} from "./chunk-JZH4LWHB.js";
 import {
   CrossNamespaceBudget,
   toBudgetWarning
 } from "./chunk-UFGFMWAD.js";
-import {
-  ExtractionDeadlineError
-} from "./chunk-ECK75GDJ.js";
-import {
-  combineNamespaces,
-  defaultGitInvoker,
-  expandScopeProfileReadNamespaces,
-  lcmSessionKeyForNamespace,
-  projectTagProjectId,
-  resolveCodingNamespaceOverlay,
-  resolveGitContext,
-  resolveScopeProfilePlan,
-  sanitizeFragment
-} from "./chunk-BUE5E2HL.js";
-import {
-  defaultCapsulesDir
-} from "./chunk-ZY2MNJR6.js";
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-NRV4Y3PM.js";
+} from "./chunk-W4FBGYGK.js";
 import {
   FileCalendarSource,
   buildBriefing,
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-QN25OCUF.js";
+} from "./chunk-LPYDOLSM.js";
 import {
   parseEntityFile,
+  parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-E6PNLPGJ.js";
+} from "./chunk-FUCYDRE5.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-J7VGGECD.js";
-import {
-  namespaceIdentityFromToken
-} from "./chunk-EGGE52UU.js";
+} from "./chunk-DZPFMQZ7.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
-import {
-  inferMemoryStatus,
-  toMemoryPathRel
-} from "./chunk-7RJUVTVF.js";
 import {
   STRUCTURED_ATTRIBUTE_LIMITS,
   buildAccessWriteRequestFingerprint,
@@ -176,34 +148,38 @@ import {
   normalizeTags,
   parseTagMatch
 } from "./chunk-BT7NVCML.js";
-import {
-  getMemoryProjectionPath
-} from "./chunk-3CSX3ETE.js";
-import {
-  displayErrorDetail
-} from "./chunk-RL6NEVXT.js";
-import {
-  computeContentHash
-} from "./chunk-W5H6ZRPT.js";
 import {
   createVersion
-} from "./chunk-DLVPUX7U.js";
+} from "./chunk-7YKVM5H3.js";
 import {
   supersessionKeysForFact
 } from "./chunk-DNHVPZOD.js";
 import {
-  serializeMutations
-} from "./chunk-FFAZ2XFU.js";
+  ExtractionDeadlineError
+} from "./chunk-N3LL5NEU.js";
+import {
+  defaultCapsulesDir
+} from "./chunk-ZY2MNJR6.js";
+import {
+  ExtractionLivenessWarnThrottle,
+  computeExtractionLivenessStatus
+} from "./chunk-3SG4FGDV.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  buildHandleIndexForResults,
+  isHandleToken
+} from "./chunk-JAKIDQB2.js";
+import {
+  exportCapsule
+} from "./chunk-KQAFEZQX.js";
+import {
+  evaluateActionConfidence
+} from "./chunk-Z2YFLXHU.js";
 import {
   delegateExtractionForceFlush
 } from "./chunk-3QL24R5Y.js";
-import {
-  assertOperationAuthorizationAllowed,
-  capabilityAllowsOp,
-  enforceNamespaceAllowList,
-  isNamespaceAllowed,
-  tokenCapabilityStore
-} from "./chunk-MZWSOLMT.js";
 import {
   meetingsBuild,
   meetingsGet,
@@ -215,29 +191,52 @@ import {
   wearablesTranscriptSearch
 } from "./chunk-SYOIVK7K.js";
 import {
-  ExtractionLivenessWarnThrottle,
-  computeExtractionLivenessStatus
-} from "./chunk-3SG4FGDV.js";
+  defaultNamespaceAtFlatRoot,
+  mergeMemorySearchDefaultFallback,
+  resolveMemorySearchDefaultFallback,
+  runMemorySearchFanout
+} from "./chunk-7HXCF4RE.js";
 import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
+  PendingObserveExtractionTracker,
+  pendingObserveScopeHint
+} from "./chunk-LNEWDF2A.js";
 import {
-  expandTildePath
-} from "./chunk-EYIEWJNI.js";
+  createOfflineSyncManifestStream
+} from "./chunk-BIPBQQFI.js";
 import {
-  buildHandleIndexForResults,
-  isHandleToken
-} from "./chunk-JAKIDQB2.js";
+  offlineSyncStorageForSnapshot
+} from "./chunk-5U7ID3EZ.js";
 import {
-  PendingObserveExtractionTracker,
-  pendingObserveScopeHint
-} from "./chunk-N5Z4EVOR.js";
+  resolveScopePlan,
+  resolveScopedWritableNamespaceValue,
+  resolveWritableNamespaceValue
+} from "./chunk-YN6ASZUG.js";
 import {
-  exportCapsule
-} from "./chunk-KQAFEZQX.js";
+  writeFileAtomically
+} from "./chunk-R6YJI3HE.js";
 import {
-  evaluateActionConfidence
-} from "./chunk-Z2YFLXHU.js";
+  namespaceIdentityFromToken
+} from "./chunk-EGGE52UU.js";
+import {
+  inferMemoryStatus,
+  toMemoryPathRel
+} from "./chunk-7RJUVTVF.js";
+import {
+  getMemoryProjectionPath
+} from "./chunk-3CSX3ETE.js";
+import {
+  displayErrorDetail
+} from "./chunk-RL6NEVXT.js";
+import {
+  serializeMutations
+} from "./chunk-FFAZ2XFU.js";
+import {
+  computeContentHash
+} from "./chunk-W5H6ZRPT.js";
+import {
+  expandScopeProfileReadNamespaces,
+  resolveScopeProfilePlan
+} from "./chunk-BGLY7EEM.js";
 import {
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   applyOfflineSyncChangeset,
@@ -246,19 +245,17 @@ import {
   buildOfflineSyncSnapshotForPaths,
   buildOfflineSyncSnapshotFromBase,
   compileOfflineSyncExcludeGlobs,
+  filterOfflineSyncDeletionRevisions,
   iterateOfflineSyncSnapshotFileRecords,
   readOfflineSyncFileContentChunk
-} from "./chunk-7XC2HX75.js";
+} from "./chunk-GYPQL6XN.js";
 import {
-  AccessIdempotencyStore,
-  hashAccessIdempotencyPayload
-} from "./chunk-VFUEZZBS.js";
-import {
-  defaultNamespaceAtFlatRoot,
-  mergeMemorySearchDefaultFallback,
-  resolveMemorySearchDefaultFallback,
-  runMemorySearchFanout
-} from "./chunk-7HXCF4RE.js";
+  assertOperationAuthorizationAllowed,
+  capabilityAllowsOp,
+  enforceNamespaceAllowList,
+  isNamespaceAllowed,
+  tokenCapabilityStore
+} from "./chunk-MZWSOLMT.js";
 import {
   canReadNamespace,
   canWriteNamespace,
@@ -282,6 +279,25 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities
 } from "./chunk-2XRE6FLM.js";
+import {
+  AccessIdempotencyStore,
+  hashAccessIdempotencyPayload
+} from "./chunk-VFUEZZBS.js";
+import {
+  resolveCodingContextFromOptions
+} from "./chunk-773TRRGT.js";
+import {
+  combineNamespaces,
+  defaultGitInvokerSync,
+  lcmSessionKeyForNamespace,
+  projectTagProjectId,
+  resolveCodingNamespaceOverlay,
+  resolveGitContext,
+  sanitizeFragment
+} from "./chunk-J2WC5LF4.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
 import {
   EngramAccessForbiddenError,
   EngramAccessInputError,
@@ -290,20 +306,21 @@ import {
 import {
   abortError,
   isAbortError,
+  raceAbort,
   throwIfAborted
-} from "./chunk-PVGDJXVK.js";
+} from "./chunk-BTTPKDIL.js";
 import {
   AccessAuditAdapter
-} from "./chunk-7K5Q6COX.js";
+} from "./chunk-TVVEYCNW.js";
 import {
   decodeCitationNamespace
-} from "./chunk-KXB4VXHY.js";
+} from "./chunk-JIYDRBVZ.js";
 import {
   isPathInsideStorageRoot
 } from "./chunk-FF4KLI5W.js";
 import {
   SecureStoreLockedError
-} from "./chunk-5TFP4CUL.js";
+} from "./chunk-XQ3HXAQH.js";
 import {
   recordCitationUsage
 } from "./chunk-NINSR6LX.js";
@@ -2863,7 +2880,7 @@ var CorrectionContractError = class extends Error {
 };
 
 // src/correction/correction-planner.ts
-import { mkdir as mkdir2, readFile as readFile4, rename as rename2, unlink, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, readdir as readdir2, unlink } from "fs/promises";
 import path4 from "path";
 var REDACTED_REQUEST_TEXT = "[redacted \u2014 never-store/redaction correction text withheld from the pending-plan file]";
 var CorrectionPlanner = class _CorrectionPlanner {
@@ -3066,13 +3083,9 @@ var CorrectionPlanner = class _CorrectionPlanner {
     const persistedPlan = sensitive ? { ...plan, request: { ...plan.request, text: REDACTED_REQUEST_TEXT } } : plan;
     await serializeMutations(`correction-plan:${target}`, async () => {
       throwIfAborted(abortSignal, "correction planning aborted");
-      await mkdir2(dir, { recursive: true });
-      const tmp = `${target}.${process.pid}.${Date.now().toString(36)}.tmp`;
-      throwIfAborted(abortSignal, "correction planning aborted");
-      await writeFile2(tmp, `${JSON.stringify(persistedPlan)}
-`, "utf-8");
-      throwIfAborted(abortSignal, "correction planning aborted");
-      await rename2(tmp, target);
+      const writePlanFile = this.deps.writePlanFile ?? writeFileAtomically;
+      await writePlanFile(target, `${JSON.stringify(persistedPlan)}
+`);
     });
     return plan;
   }
@@ -3142,10 +3155,8 @@ var CorrectionPlanner = class _CorrectionPlanner {
           (a) => a.kind === "redaction_rule" ? { ...a, pattern: "[redacted \u2014 pattern applied]" } : a
         );
       }
-      const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
-      await writeFile2(tmp, `${JSON.stringify(plan)}
-`, "utf-8");
-      await rename2(tmp, file);
+      await writeFileAtomically(file, `${JSON.stringify(plan)}
+`);
     });
   }
   /**
@@ -3168,10 +3179,8 @@ var CorrectionPlanner = class _CorrectionPlanner {
       if (!plan || plan.status !== "applying") return;
       plan.status = "pending";
       delete plan.applyingAt;
-      const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
-      await writeFile2(tmp, `${JSON.stringify(plan)}
-`, "utf-8");
-      await rename2(tmp, file);
+      await writeFileAtomically(file, `${JSON.stringify(plan)}
+`);
     });
   }
   async deletePlan(namespace, planId) {
@@ -3375,10 +3384,9 @@ var CorrectionExecutor = class {
       }
     };
     let mutationCommitted = false;
-    let cancellationSafeAfterCommit = false;
     let cancellationRequestedAfterCommit = false;
     const throwIfAbortedBeforeCommit = () => {
-      if (!mutationCommitted || !cancellationSafeAfterCommit) {
+      if (!mutationCommitted) {
         throwIfAborted(abortSignal, "correction apply aborted");
       }
     };
@@ -3456,7 +3464,6 @@ var CorrectionExecutor = class {
           const retirementResult = results.at(-1);
           if (retirementResult !== retirementResultBeforePhase2 && retirementResult?.action === action && retirementResult.status === "applied") {
             retiredReplacementActions.add(action);
-            cancellationSafeAfterCommit = true;
           }
         } catch (err) {
           if (abortSignal?.aborted) {
@@ -3482,7 +3489,6 @@ var CorrectionExecutor = class {
             abortSignal
           );
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
           results.push({ action, status: "applied", memoryId: editedId });
           appliedTouched.push(editedId);
         } catch (err) {
@@ -3504,7 +3510,6 @@ var CorrectionExecutor = class {
             abortSignal
           );
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
           results.push({ action, status: "applied" });
         } catch (err) {
           if (abortSignal?.aborted) {
@@ -3540,7 +3545,6 @@ var CorrectionExecutor = class {
           );
           if (results.at(-1)?.status === "applied") {
             mutationCommitted = true;
-            cancellationSafeAfterCommit = true;
           }
           if (results.at(-1)?.action === action && results.at(-1)?.status === "applied") {
             removeFailedResultsFor(action);
@@ -3557,14 +3561,17 @@ var CorrectionExecutor = class {
           );
           if (results.at(-1)?.status === "applied") {
             mutationCommitted = true;
-            cancellationSafeAfterCommit = true;
           }
           if (results.at(-1)?.action === action && results.at(-1)?.status === "applied") {
             removeFailedResultsFor(action);
           }
         } else if (action.kind === "rescope") {
           try {
-            const allowed = canWriteDestination ? await canWriteDestination(action.toNamespace) : true;
+            const allowed = canWriteDestination ? await raceAbort(
+              canWriteDestination(action.toNamespace, abortSignal),
+              abortSignal,
+              "correction apply aborted"
+            ) : true;
             if (!allowed) {
               results.push({
                 action,
@@ -3580,7 +3587,6 @@ var CorrectionExecutor = class {
               abortSignal
             );
             mutationCommitted = true;
-            cancellationSafeAfterCommit = true;
             results.push({ action, status: "applied", memoryId: destId });
             appliedTouched.push(action.memoryId);
             try {
@@ -3612,13 +3618,24 @@ var CorrectionExecutor = class {
     const propagationWarnings = [];
     if (appliedTouched.length > 0) {
       try {
-        await this.deps.propagate(namespace, appliedTouched, cancellationSafeAfterCommit ? void 0 : abortSignal);
+        await this.deps.propagate(namespace, appliedTouched, mutationCommitted ? void 0 : abortSignal);
       } catch (err) {
-        if ((!mutationCommitted || !cancellationSafeAfterCommit) && abortSignal?.aborted) throw err;
+        if (!mutationCommitted && abortSignal?.aborted) throw err;
         propagationWarnings.push(`propagation failed (non-fatal): ${errMsg(err)}`);
       }
     }
     await throwIfAbortedBeforeCommitAndReset();
+    if (cancellationRequestedAfterCommit) {
+      const recordedActions = new Set(results.map((result) => result.action));
+      for (const action of plan.actions) {
+        if (recordedActions.has(action)) continue;
+        results.push({
+          action,
+          status: "skipped",
+          error: "correction apply cancelled before action started"
+        });
+      }
+    }
     const anyFailed = results.some((r) => r.status === "failed");
     const status = anyFailed || cancellationRequestedAfterCommit ? "partial" : "applied";
     const appliedAt = this.deps.now().toISOString();
@@ -3642,17 +3659,19 @@ var CorrectionExecutor = class {
           outcome,
           requestText: plan.request.text
         },
-        cancellationSafeAfterCommit ? void 0 : abortSignal
+        mutationCommitted ? void 0 : abortSignal
       );
       outcome.auditMemoryId = auditId;
     } catch (err) {
-      if ((!mutationCommitted || !cancellationSafeAfterCommit) && abortSignal?.aborted) throw err;
+      if (!mutationCommitted && abortSignal?.aborted) {
+        await resetApplying();
+        throw err;
+      }
       outcome.warnings = [
         ...propagationWarnings,
         `audit record write failed (non-fatal): ${errMsg(err)}`
       ];
     }
-    await throwIfAbortedBeforeCommitAndReset();
     try {
       await this.planner.markConsumed(namespace, planId, status);
     } catch (err) {
@@ -3775,10 +3794,11 @@ var CorrectionService = class {
       abortSignal: opts.abortSignal,
       // Authorize rescope destinations through the namespace policy bound to
       // THIS caller's principal (review thread: authorize-rescope-destination).
-      canWriteDestination: (dest) => this.deps.policy.canWriteNamespace({
+      canWriteDestination: (dest, abortSignal) => this.deps.policy.canWriteNamespace({
         namespace: dest,
         ...opts.sessionKey ? { sessionKey: opts.sessionKey } : {},
-        ...opts.principal ? { principal: opts.principal } : {}
+        ...opts.principal ? { principal: opts.principal } : {},
+        ...abortSignal ? { abortSignal } : {}
       })
     });
   }
@@ -3829,7 +3849,6 @@ var CorrectionService = class {
 // src/correction/correction-access-wiring.ts
 import path5 from "path";
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 function createCorrectionService(wiring) {
   const cfg = wiring.orchestrator.config;
   const correctionEnabled = isCorrectionFeatureEnabled(cfg);
@@ -4188,7 +4207,8 @@ async function rescopeMemoryFn(wiring, namespace, memoryId, toNamespace, abortSi
       ...Array.isArray(fm.tags) ? { tags: fm.tags } : {},
       ...fm.entityRef ? { entityRef: fm.entityRef } : {},
       ...fm.structuredAttributes ? { structuredAttributes: fm.structuredAttributes } : {},
-      ...fm.valid_at ? { validAt: fm.valid_at } : {}
+      ...fm.valid_at ? { validAt: fm.valid_at } : {},
+      ...fm.sourceConnector ? { sourceConnector: fm.sourceConnector } : {}
     },
     { source: `correction:rescope:${namespace}` },
     { salvage: true }
@@ -4201,7 +4221,8 @@ async function rescopeMemoryFn(wiring, namespace, memoryId, toNamespace, abortSi
     ...fm.observedAt ? { observedAt: fm.observedAt } : {},
     ...fm.memoryKind ? { memoryKind: fm.memoryKind } : {},
     ...Array.isArray(fm.links) ? { links: fm.links } : {},
-    ...fm.intentGoal ? { intentGoal: fm.intentGoal } : {}
+    ...fm.intentGoal ? { intentGoal: fm.intentGoal } : {},
+    ...fm.toolScoped ? { toolScoped: true } : {}
   });
   if (destBlocked) {
     throw new CorrectionContractError(
@@ -4267,24 +4288,21 @@ async function appendTombstoneFn(wiring, namespace, input, abortSignal) {
   }
   return firstId;
 }
-async function registerRedactionRuleFn(wiring, namespace, pattern, abortSignal) {
+async function registerRedactionRuleFn(wiring, namespace, pattern, abortSignal, writeRule = writeFileAtomically) {
   throwIfAborted(abortSignal, "correction apply aborted");
   const storage = await wiring.orchestrator.getStorage(namespace);
   throwIfAborted(abortSignal, "correction apply aborted");
-  const dir = path5.join(storage.dir, "state", "corrections", "redaction-rules");
-  await mkdir3(dir, { recursive: true });
+  const dir = path5.join(storage.dir, REDACTION_RULES_SUBDIR);
   throwIfAborted(abortSignal, "correction apply aborted");
   const slugBase = pattern.replace(/[^a-zA-Z0-9]+/g, "-").slice(0, 48) || "rule";
   const patternHash = createHash2("sha256").update(pattern).digest("hex").slice(0, 16);
   const slug = `${slugBase}-${patternHash}`;
   throwIfAborted(abortSignal, "correction apply aborted");
-  await writeFile3(
+  await writeRule(
     path5.join(dir, `${slug}.json`),
     `${JSON.stringify({ pattern, namespace, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
-`,
-    "utf-8"
+`
   );
-  throwIfAborted(abortSignal, "correction apply aborted");
 }
 async function appendAuditRecordFn(wiring, namespace, record, abortSignal) {
   throwIfAborted(abortSignal, "correction apply aborted");
@@ -4303,7 +4321,6 @@ async function appendAuditRecordFn(wiring, namespace, record, abortSignal) {
     ),
     {}
   );
-  throwIfAborted(abortSignal, "correction apply aborted");
   return id;
 }
 function buildAuditBody(record) {
@@ -4716,9 +4733,12 @@ async function capturePassiveCorrections(corrections, ctx, config, deps, dedupSt
       );
       continue;
     }
-    if (ctx.abortSignal?.aborted) return { telemetry, plans };
     plans.push(plan);
     dedupState.add(fp);
+    if (ctx.abortSignal?.aborted) {
+      telemetry.queued += 1;
+      return { telemetry, plans };
+    }
     if (config.mode === "queue") {
       telemetry.queued += 1;
       continue;
@@ -4775,7 +4795,7 @@ function buildNotificationSummary(plan) {
 
 // src/procedural/procedure-miner.ts
 import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir4, rm, stat } from "fs/promises";
+import { mkdir as mkdir2, rm, stat } from "fs/promises";
 import path6 from "path";
 
 // src/procedural/reinforcement-core.ts
@@ -4831,12 +4851,12 @@ function sleep(ms) {
 async function acquireClusterWriteLock(memoryDir, clusterHash) {
   const lockRoot = path6.join(path6.resolve(memoryDir), "state", "procedure-miner-locks");
   const lockDir = path6.join(lockRoot, `${clusterHash}.lock`);
-  await mkdir4(lockRoot, { recursive: true });
+  await mkdir2(lockRoot, { recursive: true });
   const startedAt = Date.now();
   let attempts = 0;
   while (true) {
     try {
-      await mkdir4(lockDir);
+      await mkdir2(lockDir);
       return async () => {
         await rm(lockDir, { recursive: true, force: true });
       };
@@ -5123,6 +5143,7 @@ import { z } from "zod";
 var OPERATION_NAMES = [
   "memory_get",
   "memory_search",
+  "external_wiki_search",
   "memory_store",
   "coding_decision",
   "coding_architecture",
@@ -5851,7 +5872,8 @@ async function promoteMemory(options) {
         actor: options.actor,
         validAt: sourceMemory.frontmatter.valid_at,
         lineage: [options.sourceMemoryId],
-        ...sourceMemory.frontmatter.sourceConnector ? { sourceConnector: sourceMemory.frontmatter.sourceConnector } : {}
+        ...sourceMemory.frontmatter.sourceConnector ? { sourceConnector: sourceMemory.frontmatter.sourceConnector } : {},
+        ...sourceMemory.frontmatter.toolScoped ? { toolScoped: true } : {}
       });
       target.promoted = true;
       target.promotedMemoryId = promotedId;
@@ -6284,9 +6306,43 @@ async function extractionForceFlush(deps, request, waitForPendingObserveExtracti
     request.onCommitted?.();
   };
   let abortHandler;
+  const reservationScopeHint = pendingObserveScopeHint(request);
+  const cancelBeforeScopeResolution = () => {
+    const explicitNamespace = request.namespace?.trim();
+    if (explicitNamespace) {
+      deps.cancelPendingObserveExtractions?.(
+        request.sessionKey,
+        authenticatedPrincipal ?? sessionPrincipal,
+        explicitNamespace,
+        reservationScopeHint
+      );
+      return;
+    }
+    if (reservationScopeHint !== void 0) {
+      deps.cancelPendingObservePreparations?.(request.sessionKey, reservationScopeHint);
+      return;
+    }
+    if (!namespacesEnabled) {
+      deps.cancelPendingObserveExtractions?.(request.sessionKey);
+    }
+  };
   try {
-    const scope = await deps.resolveMemoryScopePlan(request);
-    const reservationScopeHint = pendingObserveScopeHint(request);
+    let scope;
+    try {
+      scope = await awaitSessionFlushPhase(
+        () => deps.resolveMemoryScopePlan(request),
+        {
+          abortSignal: request.abortSignal,
+          extractionDeadlineMs: request.deadlineMs,
+          reason: "access_force_flush",
+          deadlineStage: "scope_resolution",
+          onDeadline: cancelBeforeScopeResolution
+        }
+      );
+    } catch (error) {
+      if (request.abortSignal?.aborted) cancelBeforeScopeResolution();
+      throw error;
+    }
     const cancelScopedPendingObserveExtractions = () => {
       deps.cancelPendingObserveExtractions?.(
         request.sessionKey,
@@ -6399,6 +6455,9 @@ var AccessObserveWriteSurface = class {
   deps;
   quarantineStoreInstance;
   pendingObserveExtractions = new PendingObserveExtractionTracker();
+  cancelPendingObservePreparations(sessionKey, scopeHint) {
+    this.pendingObserveExtractions.cancelPreparations(sessionKey, scopeHint);
+  }
   cancelPendingObserveExtractions(sessionKey, principal, namespace, scopeHint) {
     this.pendingObserveExtractions.cancel(sessionKey, principal, namespace, scopeHint);
   }
@@ -8033,7 +8092,8 @@ var AccessAdminOpsSurface = class {
         const { id, tombstoneBlocked } = await resolved.writeSealedMemory(promotionEnvelope, {
           lineage: memory.lineage,
           sourceMemoryId: memory.sourceMemoryId,
-          actor: memory.actor
+          actor: memory.actor,
+          ...memory.toolScoped ? { toolScoped: true } : {}
         });
         if (tombstoneBlocked) {
           throw new Error(
@@ -9049,6 +9109,7 @@ var AccessRecallSurface = class {
         contextComposition = composition;
       },
       ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+      ...request.sourceConnector ? { sourceConnector: request.sourceConnector } : {},
       ...asOf !== void 0 ? { asOf } : {},
       ...request.includeLowConfidence === true ? { includeLowConfidence: true } : {},
       ...request.abortSignal ? { abortSignal: request.abortSignal } : {},
@@ -9170,6 +9231,7 @@ var AccessRecallSurface = class {
           // wrong-scope serving despite the pre-check passing
           // (CLAUDE.md rule 42).
           ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+          ...request.sourceConnector ? { sourceConnector: request.sourceConnector } : {},
           ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {},
           ...request.abortSignal ? { abortSignal: request.abortSignal } : {}
         }
@@ -9844,34 +9906,6 @@ var EngramAccessService = class {
     }
     return result.namespace;
   }
-  /**
-   * Resolve a coding context from `cwd`/`projectTag` WITHOUT persisting it to
-   * any session — the read-only half of `maybeAttachCodingContext`. Returns
-   * null when project scoping is off or nothing resolves. `projectTag` takes
-   * priority over `cwd` (matching `maybeAttachCodingContext`).
-   */
-  async resolveCodingContextFromOptions(options) {
-    if (!this.orchestrator.config.codingMode?.projectScope) return null;
-    if (typeof options.projectTag === "string" && options.projectTag.trim().length > 0) {
-      const projectId = projectTagProjectId(options.projectTag);
-      return { projectId, branch: null, rootPath: projectId, defaultBranch: null };
-    }
-    if (typeof options.cwd === "string" && options.cwd.trim().length > 0) {
-      try {
-        const gitCtx = await resolveGitContext(options.cwd);
-        if (gitCtx) {
-          return {
-            projectId: gitCtx.projectId,
-            branch: gitCtx.branch,
-            rootPath: gitCtx.rootPath,
-            defaultBranch: gitCtx.defaultBranch
-          };
-        }
-      } catch {
-      }
-    }
-    return null;
-  }
   /** Shared coding-scope derivation for the read/write resolvers below —
    *  coding context, overlay, principal, scope-profile plan for an IMPLICIT
    *  request, IDENTICAL to recall precedence (session-first, per-call fallback)
@@ -9880,7 +9914,7 @@ var EngramAccessService = class {
    *  scattered-config-read ratchet flat). READ-ONLY: never mutates session. */
   async resolveCodingScopeInputs(request) {
     const hasSession = typeof request.sessionKey === "string" && request.sessionKey.length > 0;
-    const codingContext = hasSession && resolveNamespaceCapabilities(this.orchestrator.config).namespaces && this.orchestrator.config.codingMode?.projectScope ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? await this.resolveCodingContextFromOptions(request) : null;
+    const codingContext = hasSession && resolveNamespaceCapabilities(this.orchestrator.config).namespaces && this.orchestrator.config.codingMode?.projectScope ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? await resolveCodingContextFromOptions(request) : null;
     const overlay = hasSession && resolveNamespaceCapabilities(this.orchestrator.config).namespaces && this.orchestrator.config.codingMode?.projectScope ? resolveCodingNamespaceOverlay(
       codingContext,
       this.orchestrator.config.codingMode,
@@ -10452,13 +10486,20 @@ var EngramAccessService = class {
       extractionWatermark,
       caps?.namespaces !== void 0 ? void 0 : this.extractionLivenessWarn
     );
+    let scopedDegradedReason = null;
+    if (extraction.degraded) {
+      if (extraction.degradedReason?.includes("watermark unreadable")) {
+        scopedDegradedReason = "daemon extraction pipeline degraded; extraction watermark unreadable";
+      } else if (extraction.degradedReason?.includes("buffer unreadable")) {
+        scopedDegradedReason = "daemon extraction pipeline degraded; extraction buffer unreadable";
+      } else {
+        scopedDegradedReason = `${extraction.bufferedSessionCount} buffered session(s), ${extraction.pendingTurnCount} turn(s) pending extraction`;
+      }
+    }
     const visibleExtraction = caps?.namespaces !== void 0 ? {
       ...extraction,
       lastExtractionAt: null,
-      bufferedSessionCount: 0,
-      pendingTurnCount: 0,
-      oldestBufferedTurnAgeMs: null,
-      degradedReason: extraction.degraded ? "daemon extraction pipeline degraded" : null
+      degradedReason: scopedDegradedReason
     } : extraction;
     const corpusCensus = await computeServiceCorpusCensus(this.orchestrator, {
       cache: this.corpusWatermarkCache,
@@ -11079,8 +11120,7 @@ var EngramAccessService = class {
         };
       },
       gitInvoker: (cwd, args) => {
-        const invoker = defaultGitInvoker();
-        return invoker(cwd, args);
+        return defaultGitInvokerSync()(cwd, args);
       },
       throwInputError: (msg) => {
         throw new EngramAccessInputError(msg);
@@ -11155,14 +11195,14 @@ var EngramAccessService = class {
       );
     }
   }
-  async correctionPlan(request) {
+  async correctionPlan(request, opts) {
     if (request.targetIds?.some((id) => isHandleToken(id))) {
       const targetIds = request.targetIds.map(
         (id) => this.resolveMemoryIdOrHandleInput(id, request.sessionKey)
       );
-      return this.correctionService().plan({ ...request, targetIds });
+      return this.correctionService().plan({ ...request, targetIds }, opts);
     }
-    return this.correctionService().plan(request);
+    return this.correctionService().plan(request, opts);
   }
   async correctionApply(planId, opts) {
     return this.correctionService().apply(planId, opts);
@@ -11657,7 +11697,7 @@ var EngramAccessService = class {
     const idempotencyKey = request.idempotencyKey?.trim();
     let effectiveCodingContext;
     if (idempotencyKey && !(typeof request.namespace === "string" && request.namespace.trim().length > 0)) {
-      effectiveCodingContext = (typeof this.orchestrator.getCodingContextForSession === "function" ? this.orchestrator.getCodingContextForSession(request.sessionKey) : null) ?? await this.resolveCodingContextFromOptions(request);
+      effectiveCodingContext = (await this.resolveCodingScopeInputs(request)).codingContext;
     }
     return this.handleIdempotentWrite({
       operation: "observe",
@@ -11894,6 +11934,9 @@ var EngramAccessService = class {
   async extractionForceFlush(request) {
     return delegateExtractionForceFlush(this.accessObserveWriteSurface, request);
   }
+  cancelPendingObservePreparations(sessionKey, scopeHint) {
+    this.accessObserveWriteSurface.cancelPendingObservePreparations(sessionKey, scopeHint);
+  }
   cancelPendingObserveExtractions(sessionKey, principal, namespace, scopeHint) {
     this.accessObserveWriteSurface.cancelPendingObserveExtractions(sessionKey, principal, namespace, scopeHint);
   }
@@ -12249,7 +12292,7 @@ var EngramAccessService = class {
     const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
-    const { writeFile: writeFile4, mkdir: mkdir5 } = await import("fs/promises");
+    const { writeFile: writeFile2, mkdir: mkdir3 } = await import("fs/promises");
     const { join: join4, resolve: resolve4 } = await import("path");
     const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
     if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
@@ -12258,10 +12301,10 @@ var EngramAccessService = class {
     if (!resolved.startsWith(resolve4(storageDir))) {
       throw new EngramAccessInputError("Invalid sessionKey");
     }
-    await mkdir5(checkpointDir, { recursive: true });
+    await mkdir3(checkpointDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = join4(checkpointDir, `checkpoint-${ts}.md`);
-    await writeFile4(filePath, request.context, "utf-8");
+    await writeFile2(filePath, request.context, "utf-8");
     return { saved: true };
   }
   async lcmStatus() {
@@ -12659,6 +12702,7 @@ var EngramAccessService = class {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash6("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const deletions = [...await storage.readDeletionRevisions()].map(([path9, mtimeMs]) => ({ path: path9, mtimeMs }));
     const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
     const snapshot = await snapshotBuilder({
       root: storage.dir,
@@ -12669,7 +12713,8 @@ var EngramAccessService = class {
       readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
       readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
       signal: options.signal,
-      userExcludeRegexps: this.offlineSyncUserExcludes
+      userExcludeRegexps: this.offlineSyncUserExcludes,
+      deletions
     });
     return {
       namespace: resolvedNamespace,
@@ -12680,6 +12725,12 @@ var EngramAccessService = class {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash6("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const deletions = await filterOfflineSyncDeletionRevisions({
+      root: storage.dir,
+      deletions: [...await storage.readDeletionRevisions()].map(([path9, mtimeMs]) => ({ path: path9, mtimeMs })),
+      includeTranscripts: options.includeTranscripts !== false,
+      userExcludeRegexps: this.offlineSyncUserExcludes
+    });
     return {
       namespace: resolvedNamespace,
       format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -12687,6 +12738,7 @@ var EngramAccessService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
       includeTranscripts: options.includeTranscripts !== false,
+      deletions,
       files: iterateOfflineSyncSnapshotFileRecords({
         root: storage.dir,
         includeContent: options.includeContent === true,
@@ -12698,6 +12750,16 @@ var EngramAccessService = class {
       })
     };
   }
+  async offlineSyncManifestStream(options = {}) {
+    const namespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    return createOfflineSyncManifestStream(
+      this.orchestrator,
+      namespace,
+      this.offlineSyncUserExcludes,
+      options,
+      parseFrontmatter
+    );
+  }
   async offlineSyncFiles(options) {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
@@ -12819,7 +12881,8 @@ var EngramAccessService = class {
         readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
         readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
         writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
-        deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath)
+        deleteFile: async ({ filePath, mtimeMs }) => storage.deleteOfflineSyncFile(filePath, mtimeMs ?? null),
+        recordDeletionRevision: async ({ filePath, mtimeMs }) => storage.recordReplicatedDeletionRevision(filePath, mtimeMs)
       });
       return {
         namespace: resolvedNamespace,
@@ -13034,18 +13097,6 @@ async function withRecallConcurrency(host, principal, signal, fn) {
     release();
   }
 }
-function raceAbort(p, signal) {
-  if (!signal) return p;
-  if (signal.aborted) return Promise.reject(abortError("operation aborted"));
-  let onAbort;
-  const racer = new Promise((_resolve, reject) => {
-    onAbort = () => reject(abortError("operation aborted"));
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-  return Promise.race([p, racer]).finally(() => {
-    if (onAbort) signal.removeEventListener("abort", onAbort);
-  });
-}
 function attachFlightAbort(flight, signal, cancelOnAbort) {
   flight.live += 1;
   let settled = false;
@@ -13315,7 +13366,6 @@ function coordinateRecall(host, request, normalizedRequest, requestFingerprint,
 
 export {
   withRecallConcurrency,
-  raceAbort,
   consumeFlight,
   createAndStartFlight,
   leadRecallFlight,
@@ -13362,4 +13412,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-CJ2ZR7UA.js.map
+//# sourceMappingURL=chunk-QUENPGWZ.js.map