@cortexkit/pi-magic-context 0.40.1 → 0.41.1

package/dist/index.js

@@ -52,6 +52,7 @@ import {
   bumpProjectUserProfileVersion,
   byteSize,
   canonicalizeInMemoryChunkTextForEmbedding,
+  captureChannel1PostReduceGraceBaseline,
   casChannel2NudgeClaim,
   casChannel2NudgeState,
   chunkCanonicalText,
@@ -100,6 +101,7 @@ import {
   deriveTagLoadFloor,
   deriveWindowGeometry,
   describeError,
+  describeProtectedTailDrainBudgetSkip,
   dismissUserMemory,
   drainCommitBacklogForProject,
   effectiveTailHygiene,
@@ -124,6 +126,7 @@ import {
   extractM0Block,
   extractTexts,
   extractToolCallSummaries,
+  fenceBoundaryForCompletedToolArcs,
   fenceBoundaryForToolArcs,
   findAdoptableFallbackTags,
   findLastModelKeyFromBranch,
@@ -187,6 +190,7 @@ import {
   getOverflowState,
   getPendingCompactionMarkerState,
   getPendingOps,
+  getPendingOpsCount,
   getPendingPiCompactionMarkerState,
   getPendingSmartNotes,
   getPersistedNoteNudge,
@@ -230,7 +234,6 @@ import {
   hasMuralCueColumns,
   hasPiFallbackMessageTags,
   hasPiFallbackToolOwnerTags,
-  hasShareabilitySensitiveText,
   incrementHistorianFailure,
   indexCommitsForProject,
   indexMessagesAfterOrdinal,
@@ -256,6 +259,8 @@ import {
   isWrapupInProgress,
   loadPiConfig,
   loadProtectedTailMeta,
+  logSlowWriteTransaction,
+  markChannel1PostReduceGracePending,
   markGitSweepSuccessAndRelease,
   markNoteChecked,
   markNoteReady,
@@ -298,9 +303,11 @@ import {
   readGitFileChangeTimesSince,
   readGitHead,
   readPiSessionMessages,
+  readPiSessionSnapshot,
   readProjectDocsCanonical,
   readRawSessionMessages,
   readSessionChunk,
+  reclaimableToolOutputCount,
   recordHistorianDrainFailure,
   recordMemoryMapping,
   recordMemoryVerifications,
@@ -327,8 +334,6 @@ import {
   replaceCompartmentChunkEmbeddings,
   replaceSourceContent,
   reserveProtectedTailDrainTokens,
-  resetLastNudgeCycle,
-  resetLastNudgeCycleIfTailShrank,
   resolveCompactionModeRecord,
   resolveGitTopLevel,
   resolveModelConfigOrDefault,
@@ -368,7 +373,6 @@ import {
   setStoragePrivatePermissionEnforcement,
   setTodoSnapshot,
   shouldBypassFailClosedBlock,
-  shouldUseStickyChannel1Reminder,
   sourceNameForMemory,
   stripChannel1ReminderSpans,
   stripMemoryMuralBlock,
@@ -403,7 +407,7 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-fre7qcqg.js";
+} from "./index-0jgz8yja.js";
 import {
   pushNotification
 } from "./index-hw34xmzk.js";
@@ -411,19 +415,22 @@ import {
   ensureCortexKitArtifactGitignore,
   getHarness,
   getMagicContextStorageDir,
+  getMagicContextStorageResolution,
   getProjectMagicContextHistorianDir,
+  hasShareabilitySensitiveText,
   log,
   sessionLog,
   setHarness
-} from "./index-hk6sj7dn.js";
+} from "./index-q2vgz0j1.js";
 import {
   __require,
   __toESM
 } from "./index-1yh8g550.js";
 
 // src/index.ts
-import { createRequire as createRequire3 } from "node:module";
-import { join as join5, resolve as resolve2 } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join6, resolve as resolve3 } from "node:path";
 
 // ../plugin/src/shared/model-resolution.ts
 function asRecord(value) {
@@ -1432,7 +1439,7 @@ function resolveHistorianContextLimit(historianModelOverride) {
 }
 
 // ../plugin/src/hooks/magic-context/event-resolvers.ts
-var DEFAULT_CONTEXT_LIMIT = 128000;
+var DEFAULT_CONTEXT_LIMIT = 200000;
 function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
     return cacheTtl;
@@ -2065,7 +2072,9 @@ import {
   existsSync as existsSync3,
   mkdtempSync,
   readFileSync as readFileSync2,
+  realpathSync as realpathSync2,
   rmSync,
+  statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { createRequire } from "node:module";
@@ -2075,7 +2084,8 @@ import {
   dirname,
   isAbsolute,
   join as join2,
-  resolve as resolvePath
+  resolve as resolvePath,
+  sep
 } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
@@ -2223,48 +2233,235 @@ function recordChildInvocation(input) {
 }
 
 // src/subagent-runner.ts
-function resolveBundledPiCli() {
+var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
+var PI_CODING_AGENT_PACKAGE_NAMES = new Set([
+  PI_CODING_AGENT_MODULE,
+  "@oh-my-pi/pi-coding-agent"
+]);
+var BUN_VIRTUAL_SCRIPT_PREFIX = "/$bunfs/root/";
+var WINDOWS_PI_EXTENSIONS = [".EXE", ".COM", ".CMD", ".BAT", ".PS1"];
+var DEFAULT_PI_RESOLUTION_FS = {
+  existsSync: existsSync3,
+  statSync,
+  realpathSync: realpathSync2,
+  readFileSync: readFileSync2
+};
+function readPiManifest(packageJsonPath, fs2) {
   try {
-    const require_ = createRequire(import.meta.url);
-    const pkgJson = require_.resolve("@earendil-works/pi-coding-agent/package.json");
-    const cliPath = join2(dirname(pkgJson), "dist/cli.js");
-    if (existsSync3(cliPath))
-      return cliPath;
+    const manifest = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    return manifest && typeof manifest === "object" ? manifest : null;
+  } catch {
+    return null;
+  }
+}
+function findPiPackageRoot(startDir, fs2) {
+  let dir = startDir;
+  while (dir !== dirname(dir)) {
+    const manifest = readPiManifest(join2(dir, "package.json"), fs2);
+    if (manifest?.name && typeof manifest.name === "string" && PI_CODING_AGENT_PACKAGE_NAMES.has(manifest.name)) {
+      if (basename(dir) === "dist") {
+        const parentDir = dirname(dir);
+        const parentManifest = readPiManifest(join2(parentDir, "package.json"), fs2);
+        if (typeof parentManifest?.name === "string" && parentManifest.name === manifest.name) {
+          return { dir: parentDir, manifest: parentManifest };
+        }
+      }
+      return { dir, manifest };
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function pathIsInside(root, candidate) {
+  return candidate !== root && candidate.startsWith(`${root}${sep}`);
+}
+function resolvePiBin(found, fs2, checkedPaths) {
+  const bin = found.manifest.bin;
+  const binEntry = typeof bin === "string" ? bin : bin && typeof bin === "object" && typeof bin.pi === "string" ? bin.pi : undefined;
+  if (!binEntry)
     return null;
+  const packageRoot = resolvePath(found.dir);
+  const candidate = resolvePath(packageRoot, binEntry);
+  checkedPaths.push(candidate);
+  if (isAbsolute(binEntry) || !pathIsInside(packageRoot, candidate)) {
+    return null;
+  }
+  try {
+    if (!fs2.existsSync(candidate) || !fs2.statSync(candidate).isFile()) {
+      return null;
+    }
+    const realRoot = fs2.realpathSync(packageRoot);
+    const realCandidate = fs2.realpathSync(candidate);
+    return pathIsInside(realRoot, realCandidate) ? realCandidate : null;
   } catch {
     return null;
   }
 }
-function resolvePiInvocation() {
-  const execPath = process.execPath;
-  const currentScript = process.argv[1];
-  const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/") ?? false;
-  if (currentScript && !isBunVirtualScript && existsSync3(currentScript)) {
-    return { command: execPath, prefixArgs: [currentScript] };
+function resolvePiCliFromPackageJson(packageJsonPath, fs2, checkedPaths) {
+  checkedPaths.push(packageJsonPath);
+  const manifest = readPiManifest(packageJsonPath, fs2);
+  if (typeof manifest?.name !== "string" || !PI_CODING_AGENT_PACKAGE_NAMES.has(manifest.name)) {
+    return null;
+  }
+  return resolvePiBin({ dir: dirname(packageJsonPath), manifest }, fs2, checkedPaths);
+}
+function resolvePiCliFromRunningEntry(entry, fs2) {
+  const checkedPaths = [entry ?? "process.argv[1] (missing)"];
+  if (!entry || entry.startsWith(BUN_VIRTUAL_SCRIPT_PREFIX)) {
+    return { cliPath: null, checkedPaths };
   }
-  const execName = basename(execPath).toLowerCase();
-  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
-  if (!isGenericRuntime) {
+  try {
+    if (!fs2.existsSync(entry) || !fs2.statSync(entry).isFile()) {
+      return { cliPath: null, checkedPaths };
+    }
+    const realEntry = fs2.realpathSync(entry);
+    if (realEntry !== entry)
+      checkedPaths.push(realEntry);
+    const found = findPiPackageRoot(dirname(realEntry), fs2);
+    if (!found)
+      return { cliPath: null, checkedPaths };
+    return {
+      cliPath: resolvePiBin(found, fs2, checkedPaths),
+      checkedPaths
+    };
+  } catch {
+    return { cliPath: null, checkedPaths };
+  }
+}
+function defaultResolvePiPackageJson(from) {
+  const requesters = [from, import.meta.url];
+  for (const requester of requesters) {
+    try {
+      const require_ = requester ? createRequire(requester.startsWith("file:") ? requester : resolvePath(requester)) : createRequire(import.meta.url);
+      return require_.resolve(`${PI_CODING_AGENT_MODULE}/package.json`);
+    } catch {}
+  }
+  return null;
+}
+function resolveBundledPiCli(from, fs2, resolvePackageJson, checkedPaths) {
+  const packageJsonPath = resolvePackageJson(from);
+  if (!packageJsonPath) {
+    checkedPaths.push(`${PI_CODING_AGENT_MODULE}/package.json (unresolvable from running module paths)`);
+    return null;
+  }
+  return resolvePiCliFromPackageJson(packageJsonPath, fs2, checkedPaths);
+}
+function resolveWindowsPiCommand(env, fs2) {
+  const pathValue = env.PATH ?? env.Path;
+  if (!pathValue)
+    return { path: null, extension: null, checkedPaths: [] };
+  const pathExt = env.PATHEXT ?? env.PathExt ?? "";
+  const extensions = [];
+  for (const value of pathExt.split(";")) {
+    const extension = value.trim().toUpperCase();
+    if (WINDOWS_PI_EXTENSIONS.includes(extension) && !extensions.includes(extension)) {
+      extensions.push(extension);
+    }
+  }
+  for (const extension of WINDOWS_PI_EXTENSIONS) {
+    if (!extensions.includes(extension))
+      extensions.push(extension);
+  }
+  const checkedPaths = [];
+  for (const rawDir of pathValue.split(";")) {
+    const dir = rawDir.trim().replace(/^"(.*)"$/, "$1");
+    if (!dir)
+      continue;
+    for (const extension of extensions) {
+      const candidate = join2(dir, `pi${extension.toLowerCase()}`);
+      checkedPaths.push(candidate);
+      try {
+        if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+          return { path: candidate, extension, checkedPaths };
+        }
+      } catch {}
+    }
+  }
+  return { path: null, extension: null, checkedPaths };
+}
+function isGenericRuntimeExecutable(execPath) {
+  return /^(node(?:js)?\d*|bun)(\.exe)?$/.test(basename(execPath).toLowerCase());
+}
+function formatCheckedPaths(checkedPaths) {
+  const unique = [...new Set(checkedPaths)];
+  const visible = unique.slice(0, 12);
+  return unique.length > visible.length ? `${visible.join(", ")} (+${unique.length - visible.length} more)` : visible.join(", ");
+}
+function resolvePiInvocation(options = {}) {
+  const fs2 = { ...DEFAULT_PI_RESOLUTION_FS, ...options.fs };
+  const execPath = options.execPath ?? process.execPath;
+  const currentScript = options.argv1 ?? process.argv[1];
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const resolvePackageJson = options.resolvePackageJson ?? defaultResolvePiPackageJson;
+  const running = resolvePiCliFromRunningEntry(currentScript, fs2);
+  const checkedPaths = [...running.checkedPaths];
+  if (running.cliPath) {
+    return { command: execPath, prefixArgs: [running.cliPath] };
+  }
+  if (!isGenericRuntimeExecutable(execPath)) {
     return { command: execPath, prefixArgs: [] };
   }
-  const bundled = resolveBundledPiCli();
+  const bundled = resolveBundledPiCli(currentScript, fs2, resolvePackageJson, checkedPaths);
   if (bundled) {
     return { command: execPath, prefixArgs: [bundled] };
   }
-  return { command: "pi", prefixArgs: [] };
+  const detectionMiss = `script-detection miss on ${formatCheckedPaths(checkedPaths)}`;
+  if (platform === "win32") {
+    const resolved = resolveWindowsPiCommand(env, fs2);
+    if (resolved.path && resolved.extension) {
+      const diagnostic = `${detectionMiss}; Windows PATHEXT resolved ${resolved.path}`;
+      if (resolved.extension === ".CMD" || resolved.extension === ".BAT") {
+        const command = env.ComSpec?.trim() || env.COMSPEC?.trim() || "cmd.exe";
+        return {
+          command,
+          prefixArgs: ["/d", "/s", "/c", resolved.path],
+          fallbackDiagnostic: diagnostic
+        };
+      }
+      if (resolved.extension === ".PS1") {
+        const command = env.SystemRoot ? join2(env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+        return {
+          command,
+          prefixArgs: [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-File",
+            resolved.path
+          ],
+          fallbackDiagnostic: diagnostic
+        };
+      }
+      return {
+        command: resolved.path,
+        prefixArgs: [],
+        fallbackDiagnostic: diagnostic
+      };
+    }
+    checkedPaths.push(...resolved.checkedPaths);
+  }
+  return {
+    command: "pi",
+    prefixArgs: [],
+    fallbackDiagnostic: `script-detection miss on ${formatCheckedPaths(checkedPaths)}`
+  };
 }
-function resolveSubagentEntryPath() {
+function describeSpawnFailure(error, invocation) {
+  const message = error instanceof Error ? error.message : String(error);
+  return invocation.fallbackDiagnostic ? `${message} after ${invocation.fallbackDiagnostic}` : message;
+}
+function resolveSiblingEntryPath(fileName) {
   try {
     const here = dirname(fileURLToPath(import.meta.url));
-    const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync3(candidate))
-      return candidate;
-    return;
+    const candidate = resolvePath(here, fileName);
+    return existsSync3(candidate) ? candidate : undefined;
   } catch {
     return;
   }
 }
-var SUBAGENT_ENTRY_PATH = resolveSubagentEntryPath();
+var SUBAGENT_ENTRY_PATH = resolveSiblingEntryPath("subagent-entry.js");
+var HISTORIAN_CALIBRATION_ENTRY_PATH = resolveSiblingEntryPath("historian-calibration-extension.js");
 var TERMINAL_DRAIN_GRACE_MS = 2000;
 var MAGIC_CONTEXT_PI_SUBAGENT_ENV = "MAGIC_CONTEXT_PI_SUBAGENT";
 function packageRootIsOmp(packageRoot) {
@@ -2338,6 +2535,12 @@ var DREAMER_ACTION_AGENTS = new Set([
   "dreamer",
   "magic-context-dreamer"
 ]);
+var HISTORIAN_AGENTS = new Set([
+  "magic-context-historian",
+  "historian",
+  "historian-recomp",
+  "historian-editor"
+]);
 var SEARCH_ONLY_SUBAGENT_TOOL_AGENTS = new Set([
   "sidekick",
   "dreamer-retrospective",
@@ -2429,7 +2632,7 @@ class PiSubagentRunner {
   extraArgs;
   subagentExtensions;
   constructor(options = {}) {
-    this.invocation = options.piBinary ? { command: options.piBinary, prefixArgs: [] } : resolvePiInvocation();
+    this.invocation = options.invocation ?? (options.piBinary ? { command: options.piBinary, prefixArgs: [] } : resolvePiInvocation({ platform: options.platform }));
     this.spawnImpl = options.spawnImpl ?? childProcess.spawn;
     this.platform = options.platform ?? process.platform;
     this.extraArgs = options.extraArgs ?? [];
@@ -2644,7 +2847,13 @@ class PiSubagentRunner {
           cwd: options.cwd,
           env: {
             ...process.env,
-            [MAGIC_CONTEXT_PI_SUBAGENT_ENV]: "1"
+            [MAGIC_CONTEXT_PI_SUBAGENT_ENV]: "1",
+            ...options.temperature !== undefined ? {
+              MAGIC_CONTEXT_HISTORIAN_TEMPERATURE: String(options.temperature)
+            } : {},
+            ...options.maxOutputTokens !== undefined ? {
+              MAGIC_CONTEXT_HISTORIAN_MAX_OUTPUT_TOKENS: String(options.maxOutputTokens)
+            } : {}
           },
           stdio: [deliverViaStdin ? "pipe" : "ignore", "pipe", "pipe"]
         });
@@ -2653,7 +2862,7 @@ class PiSubagentRunner {
         settle({
           ok: false,
           reason: "spawn_failed",
-          error: error instanceof Error ? error.message : String(error),
+          error: describeSpawnFailure(error, this.invocation),
           durationMs: Date.now() - startTime
         });
         return;
@@ -2842,7 +3051,7 @@ class PiSubagentRunner {
         settle({
           ok: false,
           reason: "spawn_failed",
-          error: error instanceof Error ? error.message : String(error),
+          error: describeSpawnFailure(error, this.invocation),
           durationMs: Date.now() - startTime
         });
       });
@@ -2863,10 +3072,11 @@ class PiSubagentRunner {
         if (sawAgentEnd) {
           const trimmedAssistantText = finalAssistantText?.trim() ?? null;
           if (trimmedAssistantText === null || trimmedAssistantText.length === 0) {
+            const emptyAssistantReason = trimmedAssistantText === null ? "pi agent_end did not include an assistant message" : "pi assistant produced empty text";
             settle({
               ok: false,
               reason: "no_assistant",
-              error: trimmedAssistantText === null ? "pi agent_end did not include an assistant message" : "pi assistant produced empty text",
+              error: finalErrorMessage ? `${emptyAssistantReason} (provider error: ${finalErrorMessage})` : emptyAssistantReason,
               durationMs: Date.now() - startTime,
               meta: {
                 stderr: stderr.length > 0 ? stderr : undefined,
@@ -3036,6 +3246,10 @@ function buildArgs(options, opts) {
       args.push("--magic-context-dreamer-actions");
     }
   }
+  const historianCalibrationEntryPath = opts?.historianCalibrationEntryPath === undefined ? HISTORIAN_CALIBRATION_ENTRY_PATH : opts.historianCalibrationEntryPath;
+  if (HISTORIAN_AGENTS.has(options.agent) && historianCalibrationEntryPath) {
+    args.push("--extension", historianCalibrationEntryPath);
+  }
   const strictTools = STRICT_TOOL_ALLOWLIST.get(options.agent);
   if (strictTools === undefined) {
     sessionLog(options.accountingSessionId ?? "pi-subagent", `Pi subagent agent "${options.agent}" has no strict tool allow-list; forcing --no-tools`);
@@ -3772,7 +3986,7 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
     queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
     return "queued";
   }
-  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-q00qgjm6.js");
+  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-hjcb423r.js");
   if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
     sessionLog(sessionId, "notification skipped (session not titled yet)");
     return "skipped";
@@ -4380,13 +4594,17 @@ function peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey = DREAMING_LEASE_
 function leaseOwnershipMatches(db, expectedHolder, expectedGeneration, leaseKey = DREAMING_LEASE_KEY) {
   return getLeaseGeneration(db, leaseKey) === expectedGeneration && peekLeaseHolderAndExpiry(db, expectedHolder, leaseKey);
 }
-function runImmediate(db, body) {
+function runImmediate(db, body, site, slowWriteThresholdMs) {
+  const transactionStartedAt = site === undefined ? undefined : performance.now();
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
   try {
     const result = body();
     db.exec("COMMIT");
     committed = true;
+    if (site !== undefined && transactionStartedAt !== undefined) {
+      logSlowWriteTransaction(site, transactionStartedAt, slowWriteThresholdMs);
+    }
     return result;
   } finally {
     if (!committed) {
@@ -4428,13 +4646,13 @@ function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY, expectedGenerat
     return true;
   });
 }
-function runLeaseGuardedWrite(db, holderId, leaseKey, fn) {
+function runLeaseGuardedWrite(db, holderId, leaseKey, fn, slowWriteThresholdMs) {
   return runImmediate(db, () => {
     if (!peekLeaseHolderAndExpiry(db, holderId, leaseKey)) {
       throw new Error("Dream lease lost before guarded write");
     }
     return fn();
-  });
+  }, `lease-guarded-write:${leaseKey}`, slowWriteThresholdMs);
 }
 var LEASE_HEARTBEAT_INTERVAL_MS = 60 * 1000;
 function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalOrAcquisition = LEASE_HEARTBEAT_INTERVAL_MS) {
@@ -5966,7 +6184,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       query: { directory: args.sessionDirectory },
       body: {
         agent: DREAMER_CLASSIFIER_AGENT,
-        system: CLASSIFY_SYSTEM_PROMPT,
+        system: withContentLanguageDirective(CLASSIFY_SYSTEM_PROMPT, args.language),
         ...modelBodyField(args.model),
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
@@ -6029,6 +6247,8 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
     memories: chunk.map(toPromptMemory2),
     anchors
   });
+  const modelChain = [args.model, ...args.fallbackModels ?? []].map(toModelEntry).filter((entry) => entry !== undefined).map((entry) => entry.model);
+  const resolvedModelChain = [...new Set(modelChain)];
   const response = await args.moduleClient?.call({
     sessionId: args.moduleSessionId,
     projectRoot: args.moduleProjectRoot,
@@ -6040,6 +6260,7 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
       task: "classify",
       command_id: `classify:${args.moduleCommandId ?? Date.now()}:${createHash4("sha256").update(chunk.map((candidate) => candidate.id).join(",")).digest("hex").slice(0, 24)}`,
       authority_generation: args.moduleAuthorityGeneration,
+      ...resolvedModelChain.length > 0 ? { model_chain: resolvedModelChain } : {},
       payload: {
         prompt_body: prompt,
         items: chunk.map((candidate) => ({
@@ -6713,7 +6934,7 @@ function getAsyncModule() {
   asyncModulePromise ??= (async () => {
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await Promise.all([
       import("./index-rgdqj8nj.js").then((m)=>__toESM(m.default,1)),
-      import("./index-8sseka65.js")
+      import("./index-y63nbvkk.js")
     ]);
     return newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
   })();
@@ -7843,7 +8064,7 @@ function enforceMaintainDocsProtectedRegions(args) {
 import { createHash as createHash6 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync6, statSync } from "node:fs";
+import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
 import path4 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -7853,7 +8074,7 @@ Tools (read-only): read, grep, glob, aft_search, aft_outline, aft_zoom. Each mem
 
 For each memory decide ONE of:
 - Backing files found → the COMPLETE set of repo-relative paths whose code the memory is about.
-- File-independent → the memory describes EXTERNAL behavior (a provider / API / platform / protocol limit, e.g. "Anthropic returns 400 on empty content"), or a pure process / workflow / philosophy rule, with NO specific local file that backs it.
+- File-independent → the memory describes EXTERNAL behavior (a provider / API / platform / protocol limit, e.g. "Anthropic returns 400 on empty content"), or a pure process / workflow / philosophy rule, with NO specific local file that backs it. A BEHAVIORAL claim (when to act, how to work, who decides, or tool-usage discipline) is file-independent even when it cites file paths or commands as examples: a named file is not the file backing the rule.
 
 Output ONE XML manifest at the very end and NOTHING else — no narration, no per-memory commentary, no reasoning:
 <mappings>
@@ -7864,7 +8085,7 @@ Output ONE XML manifest at the very end and NOTHING else — no narration, no pe
 Rules:
 - Every input memory id MUST appear exactly once.
 - files: repo-relative, comma-separated, no spaces inside a path. Only files that actually exist and genuinely back the memory.
-- A BACKING FILE is CODE that implements or handles the claim — not a file that merely mentions it. A markdown doc (.md), a PARITY/notes file, or a test that only DESCRIBES an external fact is NOT a backing file. If the only place a memory's fact appears is prose/docs/a test (no code implements or handles it), mark it independent="true".
+- A BACKING FILE is CODE that implements or handles the claim — not a file that merely mentions it. A path named inside a process directive is an action target or example, not evidence that the file backs the directive. A markdown doc (.md), a PARITY/notes file, or a test that only DESCRIBES an external fact is NOT a backing file. If the only place a memory's fact appears is prose/docs/a test (no code implements or handles it), mark it independent="true".
 - Many CONSTRAINTS are HYBRID: "external system does X, and OUR code handles it here." Map those to the HANDLING code (you can verify the handling, even though you can't verify the external behavior). Only mark independent when there is NO local code that implements or handles the fact.
 - Prefer the most specific file(s); do not pad with tangential files. Most memories map to one file; some to a few.
 - When you genuinely cannot find any local backing and it is not clearly external, still emit the memory with independent="true" (do not drop it).`;
@@ -7881,7 +8102,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync6(abs) && statSync(abs).isFile())
+      if (existsSync6(abs) && statSync2(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -7902,7 +8123,7 @@ ${m.content}${seed}`;
 
 Project: ${projectPath}
 
-For each memory below, find the repo file(s) it makes a claim about, or mark it file-independent. When "Likely files" are listed, those paths are named in the memory and confirmed to exist — START there: confirm each actually backs the claim (a quick read/outline), drop any that don't, add others only if genuinely needed. Search from scratch only when no likely files are given. Then output ONE <mappings> manifest covering every id.
+For each memory below, find the repo file(s) it makes a claim about, or mark it file-independent. Behavioral process/workflow directives stay file-independent even when they name files. When "Likely files" are listed, those paths are named in the memory and confirmed to exist — START there only for code claims: confirm each actually backs the claim (a quick read/outline), drop any that don't, add others only if genuinely needed. Search from scratch only when no likely files are given. Then output ONE <mappings> manifest covering every id.
 
 <memories>
 ${list}
@@ -7967,6 +8188,21 @@ function validateMapMemoriesManifest(text, expectedIds) {
   return parsed;
 }
 
+// ../plugin/src/features/magic-context/dreamer/memory-claim-safety.ts
+var POLICY_SENTENCE_START = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:you\s+|we\s+)?(?:must(?:\s+not)?|never|always|do\s+not|don't|shall\s+not)\b/i;
+var ACTOR_POLICY = /\b(?:you|we|agents?|masons?|workers?|operators?|users?|maintainers?)\s+(?:must(?:\s+not)?|should(?:\s+not)?|need\s+to|shall(?:\s+not)?|cannot|can't|may\s+not)\b/i;
+var BEHAVIORAL_WHEN_CLAUSE = /\bwhen\s+(?:you(?:'re|\s+are)?|we(?:'re|\s+are)?|told|asked|requested|working|debugging|reviewing|checking|verifying|investigating|using|running|editing|changing)\b/i;
+var WORKFLOW_IMPERATIVE = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:please\s+)?(?:run|use|check|ask|avoid|prefer|ensure|keep|follow|brief|report|inspect|search|open|read|review|validate|confirm|delegate|stop|start|remember)\b/i;
+var DECISION_AUTHORITY = /\b(?:the\s+)?(?:user|operator|maintainer|owner)\s+(?:decides|chooses|approves|has\s+(?:the\s+)?final\s+say)\b/i;
+function isDirectiveShapedProjectRule(category, content) {
+  if (category !== "PROJECT_RULES")
+    return false;
+  const text = content.trim();
+  if (!text)
+    return false;
+  return POLICY_SENTENCE_START.test(text) || ACTOR_POLICY.test(text) || BEHAVIORAL_WHEN_CLAUSE.test(text) || WORKFLOW_IMPERATIVE.test(text) || DECISION_AUTHORITY.test(text);
+}
+
 // ../plugin/src/features/magic-context/dreamer/map-memories.ts
 var MAP_BATCH_SIZE = 80;
 var MAP_BATCH_FLOOR_MS = 240000;
@@ -7981,6 +8217,8 @@ function isTimeoutClassError2(error) {
 function shouldRequeueIndependentMapping(state2, content, repoDir) {
   if (!state2.hasSentinel || state2.files.length > 0)
     return false;
+  if (state2.mappingOrigin === "host_rejected_fallback")
+    return false;
   return extractMemoryCandidatePaths(content, repoDir).length > 0;
 }
 function toMapInput(memory, repoDir) {
@@ -8187,9 +8425,26 @@ async function applyParsedBatchMappings(args, batch, parsed) {
   if (valid.length === 0)
     return { mapped: 0, independent: 0 };
   const planned = [];
+  const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   for (const p of valid) {
+    const memory = batchById.get(p.id);
+    if (!p.independent && p.files.length > 0 && memory && isDirectiveShapedProjectRule(memory.category, memory.content)) {
+      log(`[dreamer] map-memories safety override: memory_id=${p.id} verdict=file-mapping replacement=independent mapping_origin=host_rejected_fallback reason=directive-shaped-project-rule`);
+      planned.push({
+        id: p.id,
+        files: [],
+        independent: true,
+        mappingOrigin: "host_rejected_fallback"
+      });
+      continue;
+    }
     if (p.independent) {
-      planned.push({ id: p.id, files: [], independent: true });
+      planned.push({
+        id: p.id,
+        files: [],
+        independent: true,
+        mappingOrigin: "mapper"
+      });
       continue;
     }
     if (p.files.length === 0) {
@@ -8199,9 +8454,22 @@ async function applyParsedBatchMappings(args, batch, parsed) {
       cwd: args.sessionDirectory,
       files: p.files
     });
-    if (normalized.files.length === 0)
+    if (normalized.files.length === 0) {
+      log(`[dreamer] map-memories: all ${p.files.length} path(s) for memory ${p.id} were rejected; recording host_rejected_fallback`);
+      planned.push({
+        id: p.id,
+        files: [],
+        independent: true,
+        mappingOrigin: "host_rejected_fallback"
+      });
       continue;
-    planned.push({ id: p.id, files: normalized.files, independent: false });
+    }
+    planned.push({
+      id: p.id,
+      files: normalized.files,
+      independent: false,
+      mappingOrigin: "mapper"
+    });
   }
   if (planned.length === 0)
     return { mapped: 0, independent: 0 };
@@ -8216,7 +8484,8 @@ async function applyParsedBatchMappings(args, batch, parsed) {
       return {
         memory_id: identity.moduleId,
         content_hash_at_prompt: identity.normalizedHash,
-        mapped_files: item.independent ? null : item.files
+        mapped_files: item.independent ? null : item.files,
+        mapping_origin: item.mappingOrigin
       };
     });
     let response;
@@ -8253,7 +8522,7 @@ async function applyParsedBatchMappings(args, batch, parsed) {
   const now = Date.now();
   runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const item of planned) {
-      recordMemoryMapping(args.db, item.id, item.files, now);
+      recordMemoryMapping(args.db, item.id, item.files, now, item.mappingOrigin);
       item.independent ? independent += 1 : mapped += 1;
     }
   });
@@ -9414,24 +9683,29 @@ Each memory below comes with its backing file(s) — the code it makes a claim a
 
 Tools (read-only): read, grep, glob, aft_search, aft_outline, aft_zoom. You read code to check claims; you change nothing.
 
-Decide ONE of three outcomes per memory:
+Decide ONE of four outcomes per memory:
 - VERIFIED — still accurate. Keep it as-is.
-- UPDATE — the underlying fact is still true but a DETAIL drifted (a renamed symbol, moved file, changed number/name). Provide corrected content in terse present tense ("X uses Y", not "X was changed to Y"). Only update for genuine drift, not style.
-- ARCHIVE — the code CLEARLY contradicts the memory, or the thing it describes no longer exists.
+- UPDATE — a CODE FACT is still true but a file-falsifiable DETAIL drifted (a renamed symbol, moved file, changed number/name). Provide corrected content in terse present tense ("X uses Y", not "X was changed to Y"). Only update for genuine drift, not style. If a legitimate update intentionally consolidates the old claim into much shorter content, set consolidation="true" explicitly.
+- ARCHIVE — a CODE FACT is positively falsified: the code clearly contradicts it, or the API/symbol/path it describes no longer exists.
+- SKIP — the claim is not a code fact, or code cannot decide it. Keep it unchanged and do not claim verification.
+
+UPDATE and ARCHIVE are ONLY for claims a repository file can falsify, such as an API that no longer exists, a path that moved, or a constant that changed. Behavioral directives (when to act, how to work, who decides, tool-usage discipline) can only be VERIFIED or SKIPPED. A named path inside a directive does not make the directive a code fact, and a file's failure to corroborate a behavioral rule is never grounds to update or archive it.
 
-BE CONSERVATIVE ABOUT ARCHIVING. Wrong archival of a TRUE memory is the worst possible outcome — far worse than leaving a slightly-stale memory. If you cannot find the code, or you are unsure, or it might still be true somewhere you didn't look: mark it VERIFIED, never archived. Archive ONLY when you have positive evidence the code contradicts it.
+BE CONSERVATIVE ABOUT ARCHIVING. Wrong archival of a TRUE memory is the worst possible outcome — far worse than leaving a slightly-stale memory. If you cannot find the code, or you are unsure, or it might still be true somewhere you didn't look: mark it VERIFIED or SKIPPED, never archived. Archive ONLY when you have positive evidence the code contradicts a code fact.
 
 Output ONE XML manifest at the very end and NOTHING else — no narration, no per-memory commentary, no reasoning:
 <verify>
 <verified id="N" files="path/a.ts,path/b.ts"/>
 <update id="M" files="path/c.ts">corrected present-tense content</update>
+<update id="C" files="path/d.ts" consolidation="true">intentionally consolidated content</update>
 <archive id="K" reason="specific evidence the code contradicts it"/>
+<skip id="S" reason="behavioral directive; code cannot decide it"/>
 </verify>
 
 Rules:
-- Every input memory id MUST appear exactly once, in exactly one of verified/update/archive.
+- Every input memory id MUST appear exactly once, in exactly one of verified/update/archive/skip.
 - files = the COMPLETE current backing set (repo-relative, comma-separated). It may differ from the given mapping if a file moved — record what you actually verified against.
-- Default to VERIFIED. update and archive are the exceptions, not the norm.`;
+- Default to VERIFIED. skip when code cannot decide the claim. update and archive are the exceptions, not the norm.`;
 function buildVerifyPrompt(projectPath, memories) {
   const list = memories.map((m) => `[${m.id}] ${m.category}
 Content: ${m.content}
@@ -9442,7 +9716,7 @@ Backing files: ${m.mappedFiles.join(", ")}`).join(`
 
 Project: ${projectPath}
 
-Read each memory's backing files, decide verified / update / archive (default verified; be conservative about archiving), then output ONE <verify> manifest covering every id.
+Read each memory's backing files, decide verified / update / archive / skip (default verified; behavioral directives only permit verified or skip), then output ONE <verify> manifest covering every id.
 
 <memories>
 ${list}
@@ -9456,7 +9730,7 @@ function filesOf(s) {
   return (attrOf(s, "files") ?? "").split(",").map((f) => f.trim()).filter(Boolean);
 }
 function verifyIds(parsed) {
-  return [...parsed.verified, ...parsed.updated, ...parsed.archived].map((entry) => entry.id);
+  return [...parsed.verified, ...parsed.updated, ...parsed.archived, ...parsed.skipped].map((entry) => entry.id);
 }
 function verifyBody(text) {
   try {
@@ -9469,7 +9743,7 @@ function verifyBody(text) {
   }
 }
 function parseVerifyManifest(text) {
-  const out = { verified: [], updated: [], archived: [] };
+  const out = { verified: [], updated: [], archived: [], skipped: [] };
   const body = verifyBody(text);
   for (const m of body.matchAll(/<verified\b([^>]*)\/?>/g)) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
@@ -9481,7 +9755,12 @@ function parseVerifyManifest(text) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
     if (!Number.isInteger(id))
       throw new Error("verify manifest entry missing numeric id");
-    out.updated.push({ id, files: filesOf(m[1]), content: (m[2] ?? "").trim() });
+    out.updated.push({
+      id,
+      files: filesOf(m[1]),
+      content: (m[2] ?? "").trim(),
+      consolidation: attrOf(m[1], "consolidation")?.toLowerCase() === "true"
+    });
   }
   for (const m of body.matchAll(/<archive\b([^>]*)\/?>/g)) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
@@ -9489,6 +9768,12 @@ function parseVerifyManifest(text) {
       throw new Error("verify manifest entry missing numeric id");
     out.archived.push({ id, reason: attrOf(m[1], "reason") ?? "" });
   }
+  for (const m of body.matchAll(/<skip\b([^>]*)\/?>/g)) {
+    const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
+    if (!Number.isInteger(id))
+      throw new Error("verify manifest entry missing numeric id");
+    out.skipped.push({ id, reason: attrOf(m[1], "reason") ?? "" });
+  }
   if (verifyIds(out).length === 0 && body.trim().length > 0) {
     throw new Error(describeUnrecognizedManifestShape(text, "verify", "verified"));
   }
@@ -9528,6 +9813,8 @@ async function runVerify(args) {
     verified: 0,
     updated: 0,
     archived: 0,
+    skipped: 0,
+    refused: 0,
     batches: 0,
     inScope: 0,
     remaining: 0,
@@ -9572,9 +9859,12 @@ async function runVerify(args) {
       result.verified += counts.verified;
       result.updated += counts.updated;
       result.archived += counts.archived;
-      result.remaining -= counts.verified + counts.updated + counts.archived;
+      result.skipped += counts.skipped;
+      result.refused += counts.refused;
+      const batchProcessed = counts.verified + counts.updated + counts.archived + counts.skipped + counts.refused;
+      result.remaining -= batchProcessed;
       result.batches += 1;
-      args.onProgress?.(result.verified + result.updated + result.archived);
+      args.onProgress?.(result.verified + result.updated + result.archived + result.skipped + result.refused, result.refused);
       if (counts.providerFailure) {
         lastProviderFailure = counts.providerFailure;
         if (counts.providerFailure.fingerprint === priorProviderFailureFingerprint) {
@@ -9597,7 +9887,7 @@ async function runVerify(args) {
     result.complete = result.remaining === 0;
     if (result.complete)
       closeBroadCycle(args, gate.broadCycleStartAt);
-    log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
+    log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} skipped=${result.skipped} refused=${result.refused} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
     return result;
   } finally {
     heartbeat.stop();
@@ -9666,7 +9956,14 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     recordInvocation4(args, startedAt, { status: "failed", error });
     if (error instanceof DreamerModuleFailureError || signal.aborted)
       throw error;
-    return { verified: 0, updated: 0, archived: 0, providerFailure };
+    return {
+      verified: 0,
+      updated: 0,
+      archived: 0,
+      skipped: 0,
+      refused: 0,
+      providerFailure
+    };
   } finally {
     if (agentSessionId && !shouldKeepSubagents()) {
       await args.client.session.delete({
@@ -9680,35 +9977,59 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
 }
 async function applyParsedVerifyManifest(args, batch, parsed) {
   const batchIds = new Set(batch.map((m) => m.id));
+  const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   const valid = {
     verified: parsed.verified.filter((entry) => batchIds.has(entry.id)),
     updated: parsed.updated.filter((entry) => batchIds.has(entry.id)),
-    archived: parsed.archived.filter((entry) => batchIds.has(entry.id))
+    archived: parsed.archived.filter((entry) => batchIds.has(entry.id)),
+    skipped: parsed.skipped.filter((entry) => batchIds.has(entry.id))
   };
-  const unknown = [...parsed.verified, ...parsed.updated, ...parsed.archived].filter((entry) => !batchIds.has(entry.id));
+  const unknown = [
+    ...parsed.verified,
+    ...parsed.updated,
+    ...parsed.archived,
+    ...parsed.skipped
+  ].filter((entry) => !batchIds.has(entry.id));
   if (unknown.length > 0) {
     log(`[dreamer] verify warning: dropping ${unknown.length} unknown verification entr${unknown.length === 1 ? "y" : "ies"} outside the current batch (${unknown.map((entry) => entry.id).join(", ")})`);
   }
-  const validIds = [...valid.verified, ...valid.updated, ...valid.archived].map((entry) => entry.id);
+  const validIds = [...valid.verified, ...valid.updated, ...valid.archived, ...valid.skipped].map((entry) => entry.id);
   assertNoDuplicateManifestIds(validIds, "verify");
   if (validIds.length * 2 < batch.length) {
     throw new Error(`verify manifest covers ${validIds.length}/${batch.length} batch ids after filtering unknown entries; rejecting mostly-wrong manifest`);
   }
-  if (validIds.length === 0)
-    return { verified: 0, updated: 0, archived: 0 };
+  if (validIds.length === 0) {
+    return { verified: 0, updated: 0, archived: 0, skipped: 0, refused: 0 };
+  }
   const now = Date.now();
   const writes = [];
+  let refused = 0;
+  const skipped = valid.skipped.length;
   for (const v of valid.verified) {
     const files = await normalizeFiles(args, v.files);
     writes.push({ kind: "verify", id: v.id, files });
   }
   for (const u of valid.updated) {
+    const original = batchById.get(u.id);
+    if (!original)
+      continue;
+    if (isDirectiveShapedProjectRule(original.category, original.content)) {
+      log(`[dreamer] verify safety refusal: memory_id=${u.id} verdict=update reason=directive-shaped-project-rule`);
+      refused += 1;
+      continue;
+    }
     const content = u.content.trim();
     if (!content || content.length > 20000) {
       const files2 = await normalizeFiles(args, u.files);
       writes.push({ kind: "verify", id: u.id, files: files2 });
       continue;
     }
+    const originalLength = original.content.trim().length;
+    if (!u.consolidation && content.length * 2 < originalLength) {
+      log(`[dreamer] verify safety refusal: memory_id=${u.id} verdict=update reason=content-loss original_chars=${originalLength} replacement_chars=${content.length}`);
+      refused += 1;
+      continue;
+    }
     const files = await normalizeFiles(args, u.files);
     writes.push({
       kind: "update",
@@ -9719,13 +10040,21 @@ async function applyParsedVerifyManifest(args, batch, parsed) {
     });
   }
   for (const a of valid.archived) {
+    const original = batchById.get(a.id);
+    if (!original)
+      continue;
+    if (isDirectiveShapedProjectRule(original.category, original.content)) {
+      log(`[dreamer] verify safety refusal: memory_id=${a.id} verdict=archive reason=directive-shaped-project-rule`);
+      refused += 1;
+      continue;
+    }
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
-  if (writes.length === 0)
-    return { verified: 0, updated: 0, archived: 0 };
   let verified = 0;
   let updated = 0;
   let archived = 0;
+  if (writes.length === 0)
+    return { verified, updated, archived, skipped, refused };
   if (args.moduleRoute) {
     const identities = getModuleMemoryIdentities(args.db, args.projectIdentity, writes.map((write) => write.id));
     const rows = writes.map((write) => {
@@ -9775,7 +10104,7 @@ async function applyParsedVerifyManifest(args, batch, parsed) {
       else
         archived += 1;
     }
-    return { verified, updated, archived };
+    return { verified, updated, archived, skipped, refused };
   }
   runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const w of writes) {
@@ -9806,7 +10135,7 @@ async function applyParsedVerifyManifest(args, batch, parsed) {
       }
     }
   });
-  return { verified, updated, archived };
+  return { verified, updated, archived, skipped, refused };
 }
 async function normalizeFiles(args, rawFiles) {
   if (rawFiles.length === 0)
@@ -9919,12 +10248,13 @@ function createDreamTaskExecutor(deps) {
     })();
     const deadline = startedAt + config.timeoutMinutes * 60 * 1000;
     const backlogAtStart = getDreamTaskBacklog(db, projectIdentity, config.task);
-    const reportProgress = (processed) => {
+    const reportProgress = (processed, refused) => {
       deps.onProgress?.({
         task: config.task,
         processed: Math.max(0, processed),
         total: backlogAtStart.pending,
-        startedAt
+        startedAt,
+        ...refused === undefined ? {} : { refused: Math.max(0, refused) }
       });
     };
     reportProgress(0);
@@ -10111,10 +10441,11 @@ function createDreamTaskExecutor(deps) {
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
           moduleRoute,
-          onProgress: (processed2) => reportProgress(processed2)
+          onProgress: (processed2, refused) => reportProgress(processed2, refused)
         });
-        const processed = result.verified + result.updated + result.archived;
-        const broadProgress = config.task === "verify-broad" ? `verify-broad cycle ${result.broadCycleStartAt ?? "open"}: verified ${processed}, ${result.remaining} remain` : null;
+        const processed = result.verified + result.updated + result.archived + result.skipped + result.refused;
+        const verificationProgress = `${config.task}${config.task === "verify-broad" ? ` cycle ${result.broadCycleStartAt ?? "open"}` : ""}: processed ${processed} (verified ${result.verified}, updated ${result.updated}, archived ${result.archived}, skipped ${result.skipped}, refused ${result.refused}); ${result.remaining} remain`;
+        const broadProgress = config.task === "verify-broad" ? verificationProgress : null;
         const backlogAfter = config.task === "verify-broad" ? { pending: result.remaining, total: backlogAtStart.total } : undefined;
         if (!result.complete) {
           if (broadProgress && processed > 0) {
@@ -10127,13 +10458,14 @@ function createDreamTaskExecutor(deps) {
           }
           const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
+            progress: verificationProgress,
             memoryChanges: computeMemoryDelta(memoryBefore),
             backlogAfter
           });
           return { status: "failed", transient: true, error };
         }
         recordRun("completed", null, {
-          progress: broadProgress,
+          progress: verificationProgress,
           memoryChanges: computeMemoryDelta(memoryBefore),
           backlogAfter
         });
@@ -10163,6 +10495,7 @@ function createDreamTaskExecutor(deps) {
           leaseAcquisition,
           model: config.model,
           fallbackModels: config.fallbackModels,
+          language: config.language ?? deps.language,
           ...moduleArgs,
           onProgress: (processed) => reportProgress(processed)
         });
@@ -10910,7 +11243,7 @@ async function runDueTasksForProject(deps) {
 }
 
 // ../plugin/src/plugin/dream-timer.ts
-import { statSync as statSync2 } from "node:fs";
+import { statSync as statSync3 } from "node:fs";
 
 // ../plugin/src/features/magic-context/dreamer/retrospective-orphan-sweep.ts
 var HISTORIAN_CHILD_TITLE = "magic-context-compartment";
@@ -11014,12 +11347,13 @@ var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 var GIT_COMMIT_BACKLOG_DRAIN_MAX_MS = 5 * 60 * 1000;
 var BOOT_PROJECT_JITTER_SLOT_MS = 1000;
 var activeTimer = null;
+var startupTickTimer = null;
 var startupTimers = new Map;
 var startupJitters = new Map;
 var nextStartupJitterSlot = 0;
 function directoryStillExists(directory) {
   try {
-    return statSync2(directory).isDirectory();
+    return statSync3(directory).isDirectory();
   } catch {
     return false;
   }
@@ -11039,6 +11373,23 @@ function openTimerDatabaseOrNull(context) {
   return db;
 }
 var registeredProjects = new Map;
+function stopDreamScheduleTimerIfIdle() {
+  if (registeredProjects.size !== 0)
+    return;
+  const stopped = activeTimer !== null || startupTickTimer !== null;
+  if (activeTimer) {
+    clearInterval(activeTimer);
+    activeTimer = null;
+  }
+  if (startupTickTimer) {
+    clearTimeout(startupTickTimer);
+    startupTickTimer = null;
+  }
+  startupJitters.clear();
+  nextStartupJitterSlot = 0;
+  if (stopped)
+    log("[dreamer] stopped dream schedule timer (no projects left)");
+}
 async function startDreamScheduleTimer(args) {
   beginBootQuietPeriod();
   const db = openTimerDatabaseOrNull("schedule timer registration");
@@ -11062,7 +11413,10 @@ async function startDreamScheduleTimer(args) {
   }
   if (!activeTimer) {
     log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
-    scheduleAfterBootQuiet(() => runTick("startup"));
+    startupTickTimer = scheduleAfterBootQuiet(() => {
+      startupTickTimer = null;
+      runTick("startup");
+    });
     const timer = setInterval(() => runTick("interval"), DREAM_TIMER_INTERVAL_MS);
     if (typeof timer === "object" && "unref" in timer) {
       timer.unref();
@@ -11072,6 +11426,10 @@ async function startDreamScheduleTimer(args) {
     scheduleInitialProjectRun(args, db);
   }
   return () => {
+    if (registeredProjects.get(args.directory) !== args) {
+      stopDreamScheduleTimerIfIdle();
+      return;
+    }
     registeredProjects.delete(args.directory);
     const startupTimer = startupTimers.get(args.directory);
     if (startupTimer) {
@@ -11079,13 +11437,7 @@ async function startDreamScheduleTimer(args) {
       startupTimers.delete(args.directory);
     }
     log(`[dreamer] unregistered project ${args.projectIdentity} (remaining=${registeredProjects.size})`);
-    if (registeredProjects.size === 0 && activeTimer) {
-      clearInterval(activeTimer);
-      activeTimer = null;
-      startupJitters.clear();
-      nextStartupJitterSlot = 0;
-      log("[dreamer] stopped dream schedule timer (no projects left)");
-    }
+    stopDreamScheduleTimerIfIdle();
   };
 }
 function runTick(origin) {
@@ -11170,7 +11522,15 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
         log(`[dreamer] orphan schedule GC failed for ${reg.projectIdentity}:`, error);
       }
     }
-    registeredProjects.delete(reg.directory);
+    if (registeredProjects.get(reg.directory) === reg) {
+      registeredProjects.delete(reg.directory);
+      const startupTimer = startupTimers.get(reg.directory);
+      if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimers.delete(reg.directory);
+      }
+    }
+    stopDreamScheduleTimerIfIdle();
     return;
   }
   await reg.ensureRegistered(reg.directory, db);
@@ -11350,25 +11710,145 @@ async function sweepGitCommits(args) {
 }
 
 // src/dreamer/pi-session-api.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
+import { existsSync as existsSync8, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync4 } from "node:fs";
+import {
+  basename as basename2,
+  dirname as dirname2,
+  extname,
+  join as join4,
+  relative,
+  resolve,
+  sep as sep2
+} from "node:path";
 import { pathToFileURL } from "node:url";
-var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
+var PI_CODING_AGENT_MODULE2 = "@earendil-works/pi-coding-agent";
+var SCRIPT_ENTRY_PATTERN = /\.(mjs|cjs|mts|cts|js|ts|tsx|jsx)$/i;
+var TS_ENTRY_PATTERN = /\.(mts|cts|ts|tsx)$/i;
+function isScriptEntry(filePath) {
+  return SCRIPT_ENTRY_PATTERN.test(filePath) || extname(filePath) === "";
+}
+function readManifest(pkgJsonPath) {
+  try {
+    const pkg = JSON.parse(readFileSync4(pkgJsonPath, "utf8"));
+    return pkg && typeof pkg === "object" ? pkg : null;
+  } catch {
+    return null;
+  }
+}
+function isCompiledBunBinary() {
+  if (!process.versions.bun) {
+    return false;
+  }
+  const exe = basename2(process.execPath).toLowerCase();
+  return exe !== "bun" && exe !== "bun.exe";
+}
+function resolveRunningEntry() {
+  const argv1 = process.argv[1];
+  if (argv1 && existsSync8(argv1) && statSync4(argv1).isFile()) {
+    const real = realpathSync3(argv1);
+    if (isScriptEntry(real)) {
+      return real;
+    }
+  }
+  return null;
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (dir !== dirname2(dir)) {
+    const pkg = readManifest(join4(dir, "package.json"));
+    if (pkg?.name === PI_CODING_AGENT_MODULE2) {
+      if (basename2(dir) === "dist") {
+        const parentDir = dirname2(dir);
+        const parentPkg = readManifest(join4(parentDir, "package.json"));
+        if (parentPkg?.name === PI_CODING_AGENT_MODULE2) {
+          return { dir: parentDir, pkg: parentPkg };
+        }
+      }
+      return { dir, pkg };
+    }
+    dir = dirname2(dir);
+  }
+  return null;
+}
+function resolveExportsTarget(target) {
+  if (typeof target === "string") {
+    return target;
+  }
+  if (Array.isArray(target)) {
+    for (const item of target) {
+      const resolved = resolveExportsTarget(item);
+      if (resolved !== undefined) {
+        return resolved;
+      }
+    }
+    return;
+  }
+  if (target && typeof target === "object") {
+    const conditions = target;
+    for (const condition of ["import", "node", "default"]) {
+      if (condition in conditions) {
+        const resolved = resolveExportsTarget(conditions[condition]);
+        if (resolved !== undefined) {
+          return resolved;
+        }
+      }
+    }
+  }
+  return;
+}
+function resolveManifestEntry(found) {
+  const pkg = found.pkg;
+  const entryRel = resolveExportsTarget(pkg.exports?.["."]) ?? (typeof pkg.module === "string" ? pkg.module : undefined) ?? (typeof pkg.main === "string" ? pkg.main : undefined);
+  if (!entryRel) {
+    throw new Error(`No ESM entry found in ${found.dir}/package.json`);
+  }
+  if (!entryRel.startsWith("./")) {
+    throw new Error(`Invalid entry "${entryRel}" in ${found.dir}/package.json: targets must start with "./"`);
+  }
+  const root = resolve(found.dir);
+  const resolved = resolve(root, entryRel);
+  if (resolved !== root && !resolved.startsWith(root + sep2)) {
+    throw new Error(`Invalid entry "${entryRel}" in ${found.dir}/package.json: target escapes the package root`);
+  }
+  return resolved;
+}
+function toSourceEntry(entryPath, pkgDir) {
+  const rel = relative(pkgDir, entryPath);
+  const srcRel = rel.replace(/^dist[/\\]/, "src/").replace(/\.mjs$/, ".mts").replace(/\.cjs$/, ".cts").replace(/\.jsx$/, ".tsx").replace(/\.js$/, ".ts");
+  if (srcRel === rel) {
+    return null;
+  }
+  return join4(pkgDir, srcRel);
+}
 var defaultLoaders = [
-  {
-    name: "Bare import",
-    load: async () => await import(PI_CODING_AGENT_MODULE)
-  },
   {
     name: "Resolve from running Pi binary entry",
     load: async () => {
-      if (!process.argv[1]) {
-        throw new Error("process.argv[1] is undefined");
+      if (isCompiledBunBinary()) {
+        throw new Error("Running inside a compiled Bun binary: pi-coding-agent is embedded in the executable and argv[1] is a user CLI argument, so there is no on-disk package entry to resolve");
+      }
+      const entry = resolveRunningEntry() ?? process.execPath;
+      if (!entry) {
+        throw new Error("Neither process.argv[1] nor process.execPath is available");
+      }
+      const found = findPackageRoot(dirname2(entry));
+      if (!found) {
+        throw new Error(`Could not locate ${PI_CODING_AGENT_MODULE2} package.json from ${entry}`);
+      }
+      const entryPath = resolveManifestEntry(found);
+      if (TS_ENTRY_PATTERN.test(entry)) {
+        const srcEntry = toSourceEntry(entryPath, found.dir);
+        if (srcEntry && existsSync8(srcEntry)) {
+          return await import(pathToFileURL(srcEntry).href);
+        }
+        throw new Error(`Pi is running from TypeScript source (${entry}) but no source counterpart of ${entryPath} exists; refusing to load possibly stale build output`);
       }
-      const require2 = createRequire2(process.argv[1]);
-      const resolved = require2.resolve(PI_CODING_AGENT_MODULE);
-      return await import(pathToFileURL(resolved).href);
+      return await import(pathToFileURL(entryPath).href);
     }
+  },
+  {
+    name: "Bare import",
+    load: async () => await import(PI_CODING_AGENT_MODULE2)
   }
 ];
 var cachedModulePromise = null;
@@ -11386,7 +11866,7 @@ async function resolvePiCodingAgentModule(loaders) {
         errors.push(err);
       }
     }
-    throw new Error(`Failed to resolve ${PI_CODING_AGENT_MODULE} via all strategies:
+    throw new Error(`Failed to resolve ${PI_CODING_AGENT_MODULE2} via all strategies:
 ` + errors.map((e, i) => `  - ${activeLoaders[i].name}: ${e.message || e}`).join(`
 `) + `
 Likely cause: symlinked or nonstandard install layout.`);
@@ -11454,7 +11934,7 @@ function createPiPrimerRawProviderFactory(deps = {}) {
 }
 
 // src/dreamer/retrospective-raw-provider-pi.ts
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 class PiRetrospectiveRawProvider {
   deps;
   sessionPathById = new Map;
@@ -11465,7 +11945,7 @@ class PiRetrospectiveRawProvider {
   async listProjectSessions(_projectIdentity) {
     const deps = await this.resolveDeps();
     const sessions = await deps.listSessions(this.deps.sessionDir);
-    const projectCwd = resolve(this.deps.projectCwd);
+    const projectCwd = resolve2(this.deps.projectCwd);
     const result = [];
     this.sessionPathById.clear();
     for (const raw of sessions) {
@@ -11474,7 +11954,7 @@ class PiRetrospectiveRawProvider {
         continue;
       if (typeof info.id !== "string" || typeof info.path !== "string")
         continue;
-      if (typeof info.cwd !== "string" || resolve(info.cwd) !== projectCwd)
+      if (typeof info.cwd !== "string" || resolve2(info.cwd) !== projectCwd)
         continue;
       this.sessionPathById.set(info.id, info.path);
       result.push({
@@ -11568,9 +12048,30 @@ function extractPiTextContent(content) {
 }
 
 // src/dreamer/index.ts
-var registeredProjects2 = new Map;
+var PI_DREAMER_PROJECTS = Symbol.for("magic-context.pi.dreamer-registered-projects");
+function getRegisteredProjects() {
+  const globals = globalThis;
+  const existing = globals[PI_DREAMER_PROJECTS];
+  if (existing instanceof Map) {
+    return existing;
+  }
+  const projects = new Map;
+  globals[PI_DREAMER_PROJECTS] = projects;
+  return projects;
+}
+var registeredProjects2 = getRegisteredProjects();
 var sessionsById = new Map;
-var inFlightDreams = new Set;
+var PI_DREAMER_IN_FLIGHT = Symbol.for("magic-context.pi.dreamer-in-flight");
+var inFlightDreams = (() => {
+  const globals = globalThis;
+  const existing = globals[PI_DREAMER_IN_FLIGHT];
+  if (existing instanceof Map) {
+    return existing;
+  }
+  const dreams = new Map;
+  globals[PI_DREAMER_IN_FLIGHT] = dreams;
+  return dreams;
+})();
 var sessionCounter = 0;
 var piSubagentRunnerFactory = () => new PiSubagentRunner;
 var startDreamScheduleTimerFn = startDreamScheduleTimer;
@@ -11579,14 +12080,26 @@ function registerPiDreamerProject(opts) {
     return;
   }
   const existing = registeredProjects2.get(opts.projectIdentity);
+  const owners = existing?.owners ?? new Map;
+  owners.delete(opts.registrationOwner);
+  owners.set(opts.registrationOwner, opts);
+  const notifyOwnersOfAdjunctRefresh = (projectIdentity) => {
+    const callbacks = new Set([...owners.values()].map((owner) => owner.onAdjunctsRefreshNeeded).filter((callback) => callback !== undefined));
+    for (const callback of callbacks)
+      callback(projectIdentity);
+  };
   if (existing) {
-    if (existing.projectDir === opts.projectDir) {
+    if (existing.generation && existing.projectDir === opts.projectDir) {
       return;
     }
     existing.cleanup();
     registeredProjects2.delete(opts.projectIdentity);
   }
-  const client = createPiDreamerClient(opts);
+  const generation = {};
+  const client = createPiDreamerClient(opts, notifyOwnersOfAdjunctRefresh, () => {
+    const current = registeredProjects2.get(opts.projectIdentity);
+    return current?.generation === generation && current.owners.get(opts.registrationOwner)?.projectDir === opts.projectDir;
+  });
   let cleanup;
   let cancelled = false;
   startDreamScheduleTimerFn({
@@ -11597,6 +12110,8 @@ function registerPiDreamerProject(opts) {
     dreamerConfig: opts.config,
     language: opts.language,
     gitCommitIndexing: opts.gitCommitIndexing,
+    memoryEnabled: opts.memoryEnabled,
+    embeddingConfig: opts.embeddingConfig,
     retinaHandoff: opts.retinaHandoff,
     mural: opts.mural,
     ensureRegistered: ensureProjectRegisteredFromPiDirectory,
@@ -11604,32 +12119,50 @@ function registerPiDreamerProject(opts) {
     primerRawProviderFactory: createPiPrimerRawProviderFactory()
   }).then((timerCleanup) => {
     if (cancelled) {
-      timerCleanup?.();
+      if (registeredProjects2.get(opts.projectIdentity)?.generation !== generation) {
+        timerCleanup?.();
+      }
       return;
     }
     cleanup = timerCleanup;
   });
-  const runManual = async (task) => runManualDream({
-    db: opts.db,
-    projectIdentity: opts.projectIdentity,
-    tasks: buildDreamTaskRuntimeConfigs(opts.config, "pi", opts.language, opts.mural?.model),
-    executor: createDreamTaskExecutor({
-      client,
-      sessionDirectory: opts.projectDir,
-      openOpenCodeDb,
-      retrospectiveRawProvider: new PiRetrospectiveRawProvider({
-        projectCwd: opts.projectDir
+  const runManual = async (task, registrationOwner) => {
+    const manualOpts = owners.get(registrationOwner);
+    if (!manualOpts) {
+      throw new Error(`Pi dreamer registration owner is no longer active for project ${opts.projectIdentity}`);
+    }
+    const manualClient = createPiDreamerClient(manualOpts, notifyOwnersOfAdjunctRefresh, () => owners.get(manualOpts.registrationOwner)?.projectDir === manualOpts.projectDir);
+    const manualRun = runManualDream({
+      db: manualOpts.db,
+      projectIdentity: manualOpts.projectIdentity,
+      tasks: buildDreamTaskRuntimeConfigs(manualOpts.config, "pi", manualOpts.language, manualOpts.mural?.model),
+      executor: createDreamTaskExecutor({
+        client: manualClient,
+        sessionDirectory: manualOpts.projectDir,
+        openOpenCodeDb,
+        retrospectiveRawProvider: new PiRetrospectiveRawProvider({
+          projectCwd: manualOpts.projectDir
+        }),
+        primerRawProviderFactory: createPiPrimerRawProviderFactory(),
+        userMemoryCollectionEnabled: userMemoryCollectionEnabled(manualOpts.config),
+        ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
+        language: manualOpts.language,
+        retinaHandoff: manualOpts.retinaHandoff,
+        mural: manualOpts.mural
       }),
-      primerRawProviderFactory: createPiPrimerRawProviderFactory(),
-      userMemoryCollectionEnabled: userMemoryCollectionEnabled(opts.config),
-      ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
-      language: opts.language,
-      retinaHandoff: opts.retinaHandoff,
-      mural: opts.mural
-    }),
-    task
-  });
+      task
+    });
+    inFlightDreams.set(manualRun, manualOpts.registrationOwner);
+    try {
+      return await manualRun;
+    } finally {
+      inFlightDreams.delete(manualRun);
+    }
+  };
   registeredProjects2.set(opts.projectIdentity, {
+    generation,
+    activeOwner: opts.registrationOwner,
+    owners,
     cleanup: () => {
       cancelled = true;
       cleanup?.();
@@ -11638,31 +12171,55 @@ function registerPiDreamerProject(opts) {
     projectDir: opts.projectDir
   });
 }
-async function runPiDreamForProject(projectIdentity, task) {
+async function runPiDreamForProject(projectIdentity, task, registrationOwner) {
   const registration = registeredProjects2.get(projectIdentity);
   if (!registration) {
     throw new Error(`Pi dreamer not registered for project ${projectIdentity}; call registerPiDreamerProject() first`);
   }
-  return registration.runManual(task);
+  return registration.runManual(task, registrationOwner);
 }
 function unregisterPiDreamerProject(opts) {
   const registration = registeredProjects2.get(opts.projectIdentity);
-  if (!registration) {
+  if (!registration?.owners.delete(opts.registrationOwner)) {
+    return;
+  }
+  if (registration.owners.size > 0) {
+    if (registration.activeOwner !== opts.registrationOwner)
+      return;
+    const remaining = [...registration.owners.values()];
+    const replacementOptions = remaining[remaining.length - 1];
+    if (!replacementOptions)
+      return;
+    registration.cleanup();
+    registeredProjects2.delete(opts.projectIdentity);
+    registerPiDreamerProject(replacementOptions);
+    const replacement = registeredProjects2.get(opts.projectIdentity);
+    if (replacement) {
+      for (const remainingOptions of remaining) {
+        replacement.owners.set(remainingOptions.registrationOwner, remainingOptions);
+      }
+    }
     return;
   }
   registration.cleanup();
   registeredProjects2.delete(opts.projectIdentity);
 }
-async function awaitInFlightDreamers() {
-  if (inFlightDreams.size === 0) {
+async function awaitInFlightDreamers(registrationOwner) {
+  const runs = registrationOwner === undefined ? [...inFlightDreams.keys()] : [...inFlightDreams.entries()].filter(([, owner]) => owner === registrationOwner).map(([run]) => run);
+  if (runs.length === 0)
     return;
-  }
-  await Promise.allSettled(Array.from(inFlightDreams));
+  await Promise.allSettled(runs);
 }
-function createPiDreamerClient(opts) {
+function createPiDreamerClient(opts, onAdjunctsRefreshNeeded = opts.onAdjunctsRefreshNeeded, isRegistrationOwnerActive = () => true) {
   const runner = piSubagentRunnerFactory();
+  const assertRegistrationOwnerActive = () => {
+    if (!isRegistrationOwnerActive()) {
+      throw new Error(`Pi dreamer registration is no longer active for project ${opts.projectIdentity}`);
+    }
+  };
   const session = {
     create: async (args) => {
+      assertRegistrationOwnerActive();
       const sessionId = `magic-context-pi-dream-${++sessionCounter}`;
       sessionsById.set(sessionId, {
         id: sessionId,
@@ -11679,6 +12236,7 @@ function createPiDreamerClient(opts) {
       if (!dreamSession) {
         throw new Error(`Pi dreamer session not found: ${sessionId}`);
       }
+      assertRegistrationOwnerActive();
       const userMessage = extractUserMessage(args);
       const systemPrompt = extractSystemPrompt(args);
       const perTaskModel = extractBodyModel(args);
@@ -11694,9 +12252,10 @@ function createPiDreamerClient(opts) {
         signal: args.signal ?? undefined,
         thinkingLevel: extractBodyVariant(args)
       });
-      inFlightDreams.add(runPromise);
+      inFlightDreams.set(runPromise, opts.registrationOwner);
       try {
         const result = await runPromise;
+        assertRegistrationOwnerActive();
         if (!result.ok) {
           const error = new Error(`Pi dreamer subagent failed (${result.reason}): ${result.error}`);
           if (result.transient) {
@@ -11711,12 +12270,13 @@ function createPiDreamerClient(opts) {
             { type: "text", text: result.assistantText }
           ])
         ];
-        opts.onAdjunctsRefreshNeeded?.(opts.projectIdentity);
+        onAdjunctsRefreshNeeded?.(opts.projectIdentity);
       } finally {
         inFlightDreams.delete(runPromise);
       }
     },
     messages: async (args) => {
+      assertRegistrationOwnerActive();
       const dreamSession = sessionsById.get(args.path.id);
       return { data: dreamSession?.messages ?? [] };
     },
@@ -11816,8 +12376,15 @@ function makeMessage(role, parts) {
 }
 
 // src/commands/pi-command-utils.ts
-import { Box, Text } from "@earendil-works/pi-tui";
+import { Box, matchesKey, Text } from "@earendil-works/pi-tui";
 var CTX_STATUS_CUSTOM_TYPE = "ctx-status";
+var statusLifecycleSignals = new WeakMap;
+function registerCtxStatusLifecycleSignal(pi, signal) {
+  statusLifecycleSignals.set(pi, signal);
+}
+function shouldShowCtxStatusDialog(content) {
+  return content.rpcDisplay === "dialog" || content.rpcDisplay !== "notification" && content.level !== undefined && content.level !== "info";
+}
 function resolveSessionId(ctx) {
   const sm = ctx.sessionManager;
   const getSessionId = sm.getSessionId;
@@ -11830,6 +12397,41 @@ function resolveSessionId(ctx) {
     return;
   }
 }
+async function showCtxStatusDialog(ctx, content) {
+  let factoryInvoked = false;
+  await ctx.ui.custom((_tui, theme, _keybindings, done) => {
+    factoryInvoked = true;
+    return new CtxStatusDialog(content, theme, done);
+  }, { overlay: true, overlayOptions: { anchor: "center", width: 92 } });
+  return factoryInvoked;
+}
+
+class CtxStatusDialog {
+  content;
+  theme;
+  done;
+  constructor(content, theme, done) {
+    this.content = content;
+    this.theme = theme;
+    this.done = done;
+  }
+  handleInput(data) {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || matchesKey(data, "return")) {
+      this.done(undefined);
+    }
+  }
+  invalidate() {}
+  render(_width) {
+    return [
+      this.theme.bold(this.theme.fg(statusTitleColor(this.content.level), `[${this.content.title}]`)),
+      "",
+      ...this.content.text.split(`
+`),
+      "",
+      this.theme.fg("dim", "Press Enter or Escape to close")
+    ];
+  }
+}
 function statusTitleColor(level) {
   switch (level) {
     case "success":
@@ -11864,7 +12466,37 @@ function registerCtxStatusEntryRenderer(pi) {
     return false;
   }
 }
-function sendCtxStatusMessage(pi, content, details) {
+async function presentCtxStatusMessage(ctx, content, signal) {
+  if (ctx.mode !== "rpc" || signal?.aborted)
+    return;
+  const type = content.level === "error" || content.level === "warning" ? content.level : "info";
+  if (!shouldShowCtxStatusDialog(content)) {
+    if (!signal?.aborted)
+      ctx.ui.notify(content.text, type);
+    return;
+  }
+  try {
+    const shown = await showCtxStatusDialog(ctx, content);
+    if (!shown && !signal?.aborted)
+      ctx.ui.notify(content.text, type);
+  } catch (err) {
+    if (signal?.aborted)
+      return;
+    sessionLog("pi-status", `ctx status dialog failed: ${err instanceof Error ? err.message : String(err)}`);
+    ctx.ui.notify(content.text, type);
+  }
+}
+function createCtxStatusSender(pi, ctx, signal) {
+  const lifecycleSignal = statusLifecycleSignals.get(pi);
+  const effectiveSignal = signal && lifecycleSignal ? AbortSignal.any([signal, lifecycleSignal]) : signal ?? lifecycleSignal;
+  return (content, details) => {
+    if (!effectiveSignal?.aborted)
+      sendCtxStatusMessage(pi, content, details, ctx, effectiveSignal);
+  };
+}
+function sendCtxStatusMessage(pi, content, details, ctx, signal) {
+  if (signal?.aborted)
+    return;
   const data = {
     ...content,
     details: details ?? content.details
@@ -11872,6 +12504,8 @@ function sendCtxStatusMessage(pi, content, details) {
   if (typeof pi.appendEntry === "function") {
     pi.appendEntry(CTX_STATUS_CUSTOM_TYPE, data);
   }
+  if (ctx)
+    presentCtxStatusMessage(ctx, data, signal);
   sessionLog("pi-status", `${content.title}: ${content.text}`);
 }
 
@@ -11880,6 +12514,7 @@ function registerCtxDreamCommand(pi, deps) {
   pi.registerCommand("ctx-dream", {
     description: "Run Magic Context dreamer tasks for this project now",
     handler: async (args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const project = deps.resolveProject?.(ctx) ?? {
         projectDir: deps.projectDir,
         projectIdentity: deps.projectIdentity
@@ -11890,7 +12525,7 @@ function registerCtxDreamCommand(pi, deps) {
       let task;
       if (requested) {
         if (!isCanonicalDreamTask(requested)) {
-          sendCtxStatusMessage(pi, {
+          sendStatus({
             title: "/ctx-dream",
             text: `## /ctx-dream
 
@@ -11905,7 +12540,7 @@ Unknown task "${requested}".`,
         task = requested;
       }
       if (dreamerEnabled === false) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-dream",
           text: "## /ctx-dream\n\nDreamer is disabled for this project (`dreamer.disable=true`).",
           level: "info"
@@ -11917,7 +12552,7 @@ Unknown task "${requested}".`,
       }
       const backlogTasks = task ? [task] : CANONICAL_DREAM_TASKS;
       const backlogBefore = getDreamTaskBacklogs(deps.db, project.projectIdentity, backlogTasks);
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-dream",
         text: [
           "## /ctx-dream",
@@ -11935,7 +12570,8 @@ Unknown task "${requested}".`,
         projectIdentity: project.projectIdentity
       });
       try {
-        const result = await runPiDreamForProject(project.projectIdentity, task);
+        await deps.ensureRegistered?.(ctx);
+        const result = await runPiDreamForProject(project.projectIdentity, task, deps.registrationOwner);
         const lines = [];
         if (result.ran.length > 0)
           lines.push(`Ran: ${result.ran.join(", ")}`);
@@ -11953,11 +12589,12 @@ Unknown task "${requested}".`,
         }
         if (lines.length === 0)
           lines.push("No enabled dream tasks to run.");
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-dream",
           text: ["## /ctx-dream", "", ...lines].join(`
 `),
-          level: result.ran.length > 0 ? "success" : "info"
+          level: result.ran.length > 0 ? "success" : "info",
+          rpcDisplay: "dialog"
         }, {
           projectDir: project.projectDir,
           projectIdentity: project.projectIdentity
@@ -11965,7 +12602,7 @@ Unknown task "${requested}".`,
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         sessionLog(project.projectIdentity, `/ctx-dream failed: ${message}`);
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-dream",
           text: [
             "## /ctx-dream",
@@ -12005,6 +12642,10 @@ function formatEmbedFailureSummary(embedded, remaining, failure) {
     }
     case "invalid_envelope":
       return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: configure an OpenAI-compatible embedding endpoint that returns data[].embedding.`;
+    case "certification_refusal":
+      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: recertify SYNAPSE or configure embedding.fallback_provider, then run /ctx-embed start again.`;
+    case "credential_required":
+      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: reauthenticate SYNAPSE, then run /ctx-embed start again.`;
     case "empty_result":
     case "transport_error":
       return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${failure.retryable ? retry : ""}`;
@@ -12176,9 +12817,10 @@ function registerCtxEmbedCommand(pi, deps) {
   pi.registerCommand("ctx-embed", {
     description: "Embedding status, or start/pause history compartment embedding (start | pause)",
     handler: async (args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-embed",
           text: `## /ctx-embed
 
@@ -12199,7 +12841,7 @@ No active Pi session is available.`,
         if (ctrl)
           ctrl.abort();
         const cov = getEmbeddingCoverageStatus(deps.db, project.projectIdentity, sessionId);
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-embed",
           text: `## /ctx-embed
 
@@ -12209,7 +12851,7 @@ Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
         return;
       }
       if (memoryEnabled === false) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-embed",
           text: `## /ctx-embed
 
@@ -12221,16 +12863,16 @@ Memory is disabled for this project, so there is no semantic embedding to backfi
       await ensureProjectRegisteredFromPiDirectory(project.projectDir, deps.db);
       if (sub === "start") {
         const { text, level } = await runEmbedDrain(deps.db, project.projectIdentity, sessionId, {
-          onStatus: (status) => sendCtxStatusMessage(pi, {
+          onStatus: (status) => sendStatus({
             title: "/ctx-embed",
             ...status
           })
         });
-        sendCtxStatusMessage(pi, { title: "/ctx-embed", text, level });
+        sendStatus({ title: "/ctx-embed", text, level });
         return;
       }
       if (sub !== "") {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-embed",
           text: "## /ctx-embed\n\nUsage: `/ctx-embed` (status), `/ctx-embed start`, or `/ctx-embed pause`.",
           level: "info"
@@ -12239,12 +12881,13 @@ Memory is disabled for this project, so there is no semantic embedding to backfi
       }
       const coverage = getEmbeddingCoverageStatus(deps.db, project.projectIdentity, sessionId);
       const statusText = formatEmbedStatusText(coverage, { status: "idle" });
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-embed",
         text: `## Embedding Status
 
 ${statusText}`,
-        level: "info"
+        level: "info",
+        rpcDisplay: "dialog"
       });
     }
   });
@@ -12260,7 +12903,7 @@ function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity, n
   (async () => {
     let completedDrainWithWork = false;
     try {
-      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
       await ensureProjectRegisteredFromPiDirectory(projectDir, deps.db);
       const coverage = getEmbeddingCoverageStatus(deps.db, projectIdentity, sessionId);
       if (!coverage.enabled)
@@ -13151,15 +13794,31 @@ function detectMidTurnBypassReason(input) {
 }
 function applyMidTurnDeferral(input) {
   if (input.base === "defer") {
-    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "none" };
+    return {
+      midTurnAdjustedSchedulerDecision: "defer",
+      sideEffect: "none",
+      deferReason: "scheduler_defer"
+    };
   }
   if (input.bypassReason !== "none") {
-    return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+    return {
+      midTurnAdjustedSchedulerDecision: "execute",
+      sideEffect: "none",
+      deferReason: null
+    };
   }
   if (input.midTurn) {
-    return { midTurnAdjustedSchedulerDecision: "defer", sideEffect: "set-flag" };
+    return {
+      midTurnAdjustedSchedulerDecision: "defer",
+      sideEffect: "set-flag",
+      deferReason: "mid_turn_boundary"
+    };
   }
-  return { midTurnAdjustedSchedulerDecision: "execute", sideEffect: "none" };
+  return {
+    midTurnAdjustedSchedulerDecision: "execute",
+    sideEffect: "none",
+    deferReason: null
+  };
 }
 
 // ../plugin/src/hooks/magic-context/caveman.ts
@@ -13649,23 +14308,33 @@ function fenceWrapupBoundaryForToolArcs(args) {
   return boundary;
 }
 function applyHeadCap(args) {
-  const { index, protectedTailStart, offset, arcs, capTokens, recentOpenArcCutoff } = args;
+  const {
+    index,
+    protectedTailStart,
+    offset,
+    arcs,
+    lastCompartmentEndOrdinal,
+    capTokens,
+    recentOpenArcCutoff
+  } = args;
   if (offset >= protectedTailStart)
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit: false };
   let end = index.findHeadEndForCap(offset, protectedTailStart, capTokens);
   let oversizeAtomicUnit = end === offset + 1 && index.tokenForOrdinal(offset) > capTokens;
+  const completedFence = fenceBoundaryForCompletedToolArcs(end, arcs, lastCompartmentEndOrdinal + 1);
+  if (completedFence > end) {
+    end = Math.min(protectedTailStart, completedFence);
+    if (index.rangeTokens(offset, end) > capTokens)
+      oversizeAtomicUnit = true;
+  } else {
+    end = completedFence;
+  }
   for (const arc of arcs) {
     const resOrdinal = arc.resOrdinal;
     if (resOrdinal === null) {
       if (arc.invOrdinal >= recentOpenArcCutoff && arc.invOrdinal >= offset && arc.invOrdinal < end) {
         end = Math.min(end, arc.invOrdinal);
       }
-      continue;
-    }
-    if (arc.invOrdinal < end && end <= resOrdinal) {
-      end = Math.min(protectedTailStart, resOrdinal + 1);
-      if (index.rangeTokens(Math.max(offset, arc.invOrdinal), end) > capTokens)
-        oversizeAtomicUnit = true;
     }
   }
   if (end <= offset && offset < protectedTailStart) {
@@ -14267,6 +14936,9 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
     }
   });
 }
+function formatProjectedPostDropPercentage(value) {
+  return value === null ? "none" : `${value.toFixed(1)}%`;
+}
 function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
@@ -14327,10 +14999,10 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   const forceMaterializationPercentage = escalationBands(executeThresholdPercentage).forceMaterializationPercentage;
   if (usage.percentage >= forceMaterializationPercentage) {
     if (projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
-      sessionLog(sessionId, `compartment trigger: skipping force band ${forceMaterializationPercentage}% because projected post-drop usage is ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%)`);
+      sessionLog(sessionId, `historian redundancy skip: summarizer not needed this pass — force band is ${forceMaterializationPercentage}%; queued/automatic drops are projected to reclaim to ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%) on the next eligible execute pass`);
       return { shouldFire: false };
     }
-    sessionLog(sessionId, `compartment trigger: force-firing at ${usage.percentage.toFixed(1)}% (projected post-drop ${projectedPostDropPercentage?.toFixed(1) ?? "none"}%)`);
+    sessionLog(sessionId, `compartment trigger: force-firing at ${usage.percentage.toFixed(1)}% (projected post-drop ${formatProjectedPostDropPercentage(projectedPostDropPercentage)})`);
     if (tailInfo.boundarySnapshot && hasRunnableCompartmentWindow(tailInfo.boundarySnapshot)) {
       return {
         shouldFire: true,
@@ -14388,14 +15060,14 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   if (projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
-    sessionLog(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% because projected post-drop usage is ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%)`);
+    sessionLog(sessionId, `historian redundancy skip: summarizer not needed this pass — usage is ${usage.percentage.toFixed(1)}%; queued/automatic drops are projected to reclaim to ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%) on the next eligible execute pass`);
     return { shouldFire: false };
   }
   if (!tailInfo.hasProtectedEligibleHead || !tailInfo.isMeaningful) {
     sessionLog(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% because unsummarized tail from ${tailInfo.nextStartOrdinal} is too small`);
     return { shouldFire: false };
   }
-  sessionLog(sessionId, `compartment trigger: proactive fire at ${usage.percentage.toFixed(1)}% (floor=${proactiveTriggerPercentage}% projected post-drop=${projectedPostDropPercentage?.toFixed(1) ?? "none"}% target=${relativePostDropTarget.toFixed(1)}%)`);
+  sessionLog(sessionId, `compartment trigger: proactive fire at ${usage.percentage.toFixed(1)}% (floor=${proactiveTriggerPercentage}% projected post-drop=${formatProjectedPostDropPercentage(projectedPostDropPercentage)} target=${relativePostDropTarget.toFixed(1)}%)`);
   return {
     shouldFire: true,
     reason: "projected_headroom",
@@ -14436,8 +15108,9 @@ function buildSupersessionReclaimOps(input) {
       const action = input.targets.get(tag.tagNumber)?.readInput?.()?.action;
       isTarget = typeof action === "string" && CTX_NOTE_ZERO_VALUE_ACTIONS.has(action);
     }
-    if (isTarget)
+    if (isTarget && (!input.recentMessageIds || tag.toolOwnerMessageId !== null && !input.recentMessageIds.has(tag.toolOwnerMessageId))) {
       dropTagIds.push(tag.tagNumber);
+    }
   }
   const synthetic = [];
   for (const tagId of dropTagIds) {
@@ -14470,6 +15143,9 @@ function buildEditSupersessionReclaim(input) {
       seenFile.add(filePath);
       continue;
     }
+    if (input.recentMessageIds && (tag.toolOwnerMessageId === null || input.recentMessageIds.has(tag.toolOwnerMessageId))) {
+      continue;
+    }
     if (realPendingTagIds.has(tag.tagNumber))
       continue;
     if (input.targets.get(tag.tagNumber)?.canDrop?.() !== true)
@@ -15258,10 +15934,10 @@ var DEFAULT_MIN_PROMPT_CHARS = 20;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
   let timer;
-  const timeoutPromise = new Promise((resolve2) => {
+  const timeoutPromise = new Promise((resolve3) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve2(null);
+      resolve3(null);
     }, timeoutMs);
   });
   try {
@@ -16334,7 +17010,7 @@ function measurePiTailHygiene(input) {
           }
           continue;
         }
-        const content = part.text;
+        const content = stripChannel1ReminderSpans(part.text);
         const tag = parseVisibleTag(content, tagsByNumber) ?? messageTags.get(`${messageKey}:p${textOrdinal}`);
         textOrdinal += 1;
         if (!content || isDropSentinel(content)) {
@@ -16437,7 +17113,8 @@ function refreshPiTailHygieneBaseline(input) {
       evaluable: true,
       generationInvalidated: false,
       baselineParts: measured.parts,
-      contentSignature: measured.contentSignature
+      contentSignature: measured.contentSignature,
+      channel1PostReduceGrace: input.previous?.channel1PostReduceGrace
     };
   }
   const prefix = sameMeasuredPrefix(input.previous.baselineParts, measured.parts);
@@ -16511,8 +17188,15 @@ function markPiChannel1Reduced(sessionId, db) {
     state2.evaluable = false;
     state2.generationInvalidated = true;
   }
-  if (db)
-    resetLastNudgeCycle(db, sessionId);
+  if (!db)
+    return;
+  const grace = markChannel1PostReduceGracePending(db, sessionId);
+  if (state2) {
+    state2.channel1PostReduceGrace = {
+      pending: true,
+      preReduceLevel: grace.postReduceGracePreLevel ?? grace.level
+    };
+  }
 }
 function isPiTextContent(c) {
   return c !== null && typeof c === "object" && c.type === "text" && typeof c.text === "string";
@@ -16531,10 +17215,7 @@ function maybeChannel1ReminderForToolResult(args) {
   if (!state2)
     return null;
   if (toolName === "ctx_reduce") {
-    state2.reducedSinceRefresh = true;
-    state2.evaluable = false;
-    state2.generationInvalidated = true;
-    resetLastNudgeCycle(db, sessionId);
+    markPiChannel1Reduced(sessionId, db);
     return null;
   }
   const text = toolResultText(args.content);
@@ -16551,28 +17232,32 @@ function maybeChannel1ReminderForToolResult(args) {
     ...state2,
     lastNudgeUndropped: getLastNudgeUndropped(db, sessionId),
     lastNudgeLevel: nudgeState.level,
-    hasRecentReduce: state2.reducedSinceRefresh
+    lastFireOrdinal: nudgeState.ordinal,
+    currentRealUserTurnCount: state2.realUserTurnCount,
+    hasRecentReduce: state2.reducedSinceRefresh,
+    postReduceGracePending: nudgeState.postReduceGracePending,
+    postReduceGraceBaselineU: nudgeState.postReduceGraceBaselineU,
+    postReduceGracePreLevel: nudgeState.postReduceGracePreLevel
   });
   setLastNudgeUndropped(db, sessionId, decision.nextLastNudge);
+  const nextNudgeState = {
+    ...nudgeState,
+    level: decision.nextLastNudgeLevel,
+    ordinal: decision.nextLastNudgeLevel === "" ? 0 : nudgeState.ordinal,
+    postReduceGracePending: decision.clearPostReduceGrace ? undefined : nudgeState.postReduceGracePending,
+    postReduceGraceBaselineU: decision.clearPostReduceGrace ? undefined : nudgeState.postReduceGraceBaselineU,
+    postReduceGracePreLevel: decision.clearPostReduceGrace ? undefined : nudgeState.postReduceGracePreLevel
+  };
   if (!decision.fire) {
-    setChannel1NudgeState(db, sessionId, {
-      level: decision.nextLastNudgeLevel,
-      ordinal: decision.nextLastNudgeLevel === "" ? 0 : nudgeState.ordinal
-    });
+    setChannel1NudgeState(db, sessionId, nextNudgeState);
     return null;
   }
-  const sticky = shouldUseStickyChannel1Reminder({
-    lastLevel: nudgeState.level,
-    lastOrdinal: nudgeState.ordinal,
-    level: decision.level,
-    currentRealUserTurnCount: state2.realUserTurnCount
-  });
   const block = {
     type: "text",
-    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state2.usableWindow, state2.oldestReclaimableToolTags, sticky)
+    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, reclaimableToolOutputCount(state2.baselineParts), state2.oldestReclaimableToolTags, decision.sticky)
   };
   setChannel1NudgeState(db, sessionId, {
-    level: decision.level,
+    ...nextNudgeState,
     ordinal: state2.realUserTurnCount
   });
   return block;
@@ -16606,7 +17291,7 @@ function maybeDeliverChannel2Pi(pi, db, sessionId) {
   try {
     const message = {
       customType: CHANNEL2_NUDGE_CUSTOM_TYPE,
-      content: buildChannel2Reminder(undropped, baseline.usableWindow, baseline.oldestReclaimableToolTags),
+      content: buildChannel2Reminder(undropped, reclaimableToolOutputCount(baseline.baselineParts), baseline.oldestReclaimableToolTags),
       display: false,
       details: { kind: "channel-2-ceiling-nudge" }
     };
@@ -16896,6 +17581,8 @@ function piImageFromDataUrl(dataUrl) {
   return { type: "image", mimeType: match[1], data: match[2] };
 }
 function resolveMuralForM0Pi(state2, db, modelKey, budgetTokens) {
+  if (state2.memoryEnabled === false)
+    return;
   if (state2.mural)
     return state2.mural;
   if (!state2.muralEnabled)
@@ -17107,7 +17794,7 @@ function renderM0Pi(state2, db, projectDocs = readProjectDocsForPiM0(state2).ren
   const sections = [];
   if (projectDocs.length > 0)
     sections.push(projectDocs);
-  const trimmedProfile = trimUserMemoriesToBudget(userProfileOverride ?? safeGetActiveUserMemoriesPi(db), state2.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS);
+  const trimmedProfile = trimUserMemoriesToBudget(state2.memoryEnabled === false ? [] : userProfileOverride ?? safeGetActiveUserMemoriesPi(db), state2.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS);
   const userProfile = renderUserProfileBlock(db, "user-profile", trimmedProfile);
   if (userProfile.length > 0)
     sections.push(userProfile);
@@ -17167,7 +17854,7 @@ function readFrozenM0InputsPi(state2, db, docs = readProjectDocsForPiM0(state2),
     const workspace = resolveWorkspaceRenderContextPi(state2, db);
     const compartments = getRenderableCompartmentsPi(db, state2);
     const memories = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], memoryCutoff, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"], memoryCutoff) : [];
-    const userProfile = safeGetActiveUserMemoriesPi(db);
+    const userProfile = state2.memoryEnabled === false ? [] : safeGetActiveUserMemoriesPi(db);
     const projectState = memPath ? getProjectState(db, memPath) : undefined;
     const globalState = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH);
     const markers = {
@@ -17187,7 +17874,7 @@ function readFrozenM0InputsPi(state2, db, docs = readProjectDocsForPiM0(state2),
       systemHash: (state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
       modelKey: piModelRefToCanonical((state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey),
       projectIdentity: state2.projectIdentity,
-      muralEnabled: state2.muralEnabled === true,
+      muralEnabled: state2.memoryEnabled !== false && state2.muralEnabled === true,
       renderBudgetIdentity: renderBudgetIdentityPi(state2)
     };
     return { docs, markers, compartments, memories, userProfile, workspace };
@@ -17409,7 +18096,7 @@ ${body}
   if (newMemoriesBlock)
     sections.push(newMemoriesBlock);
   const currentUserProfileVersion = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH)?.projectUserProfileVersion ?? 0;
-  if (currentUserProfileVersion !== markers.projectUserProfileVersion) {
+  if (state2.memoryEnabled !== false && currentUserProfileVersion !== markers.projectUserProfileVersion) {
     const profileBudget = state2.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS;
     const trimmedProfile = trimUserMemoriesToBudget(safeGetActiveUserMemoriesPi(db), Math.max(1, Math.floor(profileBudget * 0.25)));
     const profileBlock = renderUserProfileBlock(db, "new-user-profile", trimmedProfile);
@@ -20994,7 +21681,7 @@ async function sleepWithAbort(ms, signal) {
     return true;
   if (ms <= 0)
     return signal?.aborted === true;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let settled = false;
     let timeout;
     const finish = (aborted) => {
@@ -21004,7 +21691,7 @@ async function sleepWithAbort(ms, signal) {
       if (timeout)
         clearTimeout(timeout);
       signal?.removeEventListener("abort", onAbort);
-      resolve2(aborted);
+      resolve3(aborted);
     };
     const onAbort = () => finish(true);
     signal?.addEventListener("abort", onAbort, { once: true });
@@ -21123,6 +21810,8 @@ async function runPiHistorian(deps) {
     refreshBoundarySnapshot,
     currentContextLimit,
     historianTimeoutMs = DEFAULT_HISTORIAN_TIMEOUT_MS2,
+    temperature,
+    maxOutputTokens = 32000,
     signal,
     retryBackoffMs,
     twoPass,
@@ -21235,9 +21924,9 @@ async function runPiHistorian(deps) {
         executeThresholdPercentage: boundarySnapshot.executeThresholdPercentage
       });
       if (!reserve.ok) {
-        sessionLog(sessionId, `historian rate-limit skip: ${reserve.skippedReason ?? "quota exhausted"}`);
+        sessionLog(sessionId, describeProtectedTailDrainBudgetSkip(reserve));
         telemetry.status = "noop";
-        telemetry.failureReason = "protected-tail drain quota exhausted";
+        telemetry.failureReason = "internal protected-tail drain budget spent";
         return;
       }
       drainReservation = reserve.reservation;
@@ -21350,6 +22039,8 @@ ${chunkText}`,
           cwd: directory,
           signal,
           thinkingLevel,
+          temperature,
+          maxOutputTokens,
           onProgress: buildProgressLogger("first"),
           accountingSessionId: sessionId,
           accountingSubagent: "historian"
@@ -21374,6 +22065,8 @@ ${chunkText}`,
             cwd: directory,
             signal,
             thinkingLevel,
+            temperature,
+            maxOutputTokens,
             onProgress: buildProgressLogger("repair"),
             accountingSessionId: sessionId,
             accountingSubagent: "historian"
@@ -21403,6 +22096,8 @@ ${chunkText}`,
               cwd: directory,
               signal,
               thinkingLevel: candidate.entry.qualifier,
+              temperature,
+              maxOutputTokens,
               onProgress: buildProgressLogger("fallback"),
               accountingSessionId: sessionId,
               accountingSubagent: "historian"
@@ -21449,6 +22144,8 @@ ${chunkText}`,
               cwd: directory,
               signal,
               thinkingLevel,
+              temperature,
+              maxOutputTokens,
               onProgress: buildProgressLogger("editor"),
               accountingSessionId: sessionId,
               accountingSubagent: "historian_editor"
@@ -21759,6 +22456,62 @@ function findFirstKeptEntryId(entries, lastCompactedOrdinal) {
   return boundary.id;
 }
 
+// src/pi-pressure.ts
+function extractAssistantUsage(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const m = message;
+  if (m.role !== "assistant")
+    return null;
+  if (!m.usage || typeof m.usage !== "object")
+    return null;
+  const u = m.usage;
+  const result = {};
+  if (typeof u.input === "number")
+    result.input = u.input;
+  if (typeof u.output === "number")
+    result.output = u.output;
+  if (typeof u.cacheRead === "number")
+    result.cacheRead = u.cacheRead;
+  if (typeof u.cacheWrite === "number")
+    result.cacheWrite = u.cacheWrite;
+  if (typeof u.totalTokens === "number")
+    result.totalTokens = u.totalTokens;
+  return result;
+}
+function computePiPressure(usage, contextLimit) {
+  if (!usage)
+    return null;
+  const input = usage.input ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const inputTokens = input + cacheRead + cacheWrite;
+  if (inputTokens === 0)
+    return null;
+  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
+  return { inputTokens, percentage };
+}
+function resolvePiPressureSnapshot(args) {
+  const persistedInputTokens = Number.isFinite(args.persistedInputTokens) && args.persistedInputTokens > 0 ? args.persistedInputTokens : 0;
+  const liveInputTokens = typeof args.liveInputTokens === "number" && Number.isFinite(args.liveInputTokens) && args.liveInputTokens > 0 ? args.liveInputTokens : 0;
+  const inputTokens = Math.max(persistedInputTokens, liveInputTokens);
+  const contextLimit = typeof args.usableContextLimit === "number" && Number.isFinite(args.usableContextLimit) && args.usableContextLimit > 0 ? args.usableContextLimit : undefined;
+  if (contextLimit !== undefined) {
+    return {
+      inputTokens,
+      percentage: inputTokens > 0 ? inputTokens / contextLimit * 100 : 0,
+      contextLimit
+    };
+  }
+  return {
+    inputTokens: persistedInputTokens,
+    percentage: Number.isFinite(args.persistedPercentage) && args.persistedPercentage > 0 ? args.persistedPercentage : 0
+  };
+}
+function formatPiPressureForLog(snapshot) {
+  return `usage=${snapshot.percentage.toFixed(1)}% (${snapshot.inputTokens} tokens, limit=${snapshot.contextLimit ?? "?"})`;
+}
+
 // src/pi-todo-inject.ts
 function getMessageId(message) {
   if (typeof message.responseId === "string" && message.responseId.length > 0) {
@@ -22585,8 +23338,8 @@ function injectPiTemporalMarkers(messages) {
 // src/timeout.ts
 function withTimeout(p, ms) {
   let handle;
-  const timeout = new Promise((resolve2) => {
-    handle = setTimeout(() => resolve2(undefined), ms);
+  const timeout = new Promise((resolve3) => {
+    handle = setTimeout(() => resolve3(undefined), ms);
     handle.unref?.();
   });
   return Promise.race([p, timeout]).finally(() => {
@@ -23300,26 +24053,14 @@ function extractStableId(msg, index, entryIds) {
 
 // src/context-handler.ts
 var EMERGENCY_BLOCK_PERCENTAGE = 95;
-var FORWARD_PRESSURE_LIMIT_FACTOR = 0.85;
 function isPiHardCacheExpired(lastResponseTime, ttlMs, now) {
   return lastResponseTime > 0 && now - lastResponseTime > ttlMs;
 }
-function applyForwardPressureFloor(trailingPercentage, trailingInputTokens, piUsageTokens, correctedLimit) {
-  const forwardTokens = typeof piUsageTokens === "number" && piUsageTokens > 0 ? piUsageTokens : 0;
-  if (forwardTokens === 0 || !isSaneLimit(correctedLimit)) {
-    return { percentage: trailingPercentage, inputTokens: trailingInputTokens };
-  }
-  const forwardPressureLimit = correctedLimit * FORWARD_PRESSURE_LIMIT_FACTOR;
-  const forwardPercentage = forwardTokens / forwardPressureLimit * 100;
-  return forwardPercentage > trailingPercentage ? {
-    percentage: forwardPercentage,
-    inputTokens: Math.max(trailingInputTokens, forwardTokens)
-  } : { percentage: trailingPercentage, inputTokens: trailingInputTokens };
-}
 var injectM0M1PiForRun = injectM0M1Pi;
 var persistReasoningWatermarkForRun = updateSessionMeta;
 var persistStableIdSchemeForRun = updateSessionMeta;
 var afterFallbackAdoptionForTests;
+var pendingDecisionLogObserverForTests;
 var mutationGateObserverForTests;
 var DEFAULT_CLEAR_REASONING_AGE = 50;
 var PI_STABLE_ID_SCHEME = 1;
@@ -24255,7 +24996,12 @@ function registerPiContextHandler(pi, baseOptions) {
       if (!usedPersistedUsage && isSaneLimit(usageContextLimit) && usageInputTokens > 0) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
-      ({ percentage: usagePercentage, inputTokens: usageInputTokens } = applyForwardPressureFloor(usagePercentage, usageInputTokens, piUsage?.tokens, usageContextLimit));
+      ({ percentage: usagePercentage, inputTokens: usageInputTokens } = resolvePiPressureSnapshot({
+        persistedPercentage: usagePercentage,
+        persistedInputTokens: usageInputTokens,
+        liveInputTokens: piUsage?.tokens,
+        usableContextLimit: usageContextLimit
+      }));
       const realUsagePercentageBeforeEmergencyBump = usagePercentage;
       if (needsEmergencyBump) {
         sessionLog(sessionId, `transform: overflow recovery flag set — bumping percentage to 95% (detectedLimit=${usageContextLimit ?? "unknown"})`);
@@ -24298,9 +25044,14 @@ function registerPiContextHandler(pi, baseOptions) {
         sessionId,
         effectiveExecuteThresholdPercentage
       });
-      const { midTurnAdjustedSchedulerDecision, sideEffect } = options.compactionOff ? {
+      const {
+        midTurnAdjustedSchedulerDecision,
+        sideEffect,
+        deferReason: schedulerDeferReason
+      } = options.compactionOff ? {
         midTurnAdjustedSchedulerDecision: "defer",
-        sideEffect: "none"
+        sideEffect: "none",
+        deferReason: "scheduler_defer"
       } : applyMidTurnDeferral({
         base: schedulerDecisionEarly,
         bypassReason,
@@ -24317,6 +25068,9 @@ function registerPiContextHandler(pi, baseOptions) {
       schedulerDecision = midTurnAdjustedSchedulerDecision;
       sessionLog(sessionId, `[boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
       const forceMaterialization = !options.compactionOff && usagePercentage >= forceMaterializationPercentage;
+      if (!forceMaterialization && getEmergencyInputSample(options.db, sessionId) > 0) {
+        clearEmergencyDropSample(options.db, sessionId);
+      }
       const hardUsagePercentage = needsEmergencyBump ? Math.max(EMERGENCY_BLOCK_PERCENTAGE, usagePercentage) : windowGeometry?.usableHard && usageInputTokens > 0 ? usageInputTokens / windowGeometry.usableHard * 100 : usagePercentage;
       const emergencyPercentage = ctx.model ? hardUsagePercentage : usagePercentage;
       const isEmergency = !options.compactionOff && emergencyPercentage >= EMERGENCY_BLOCK_PERCENTAGE;
@@ -24346,7 +25100,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       const isCacheBusting = historyRefreshSessions.has(sessionId);
       logTransformTiming(sessionId, "boundaryTriggerChecks", tBoundaryChecks);
-      sessionLog(sessionId, `transform: usage=${usagePercentage.toFixed(1)}% (${usageInputTokens} tokens, limit=${usageContextLimit ?? "?"}) decision=${schedulerDecision}${forceMaterialization ? " force=true" : ""}${isEmergency ? " EMERGENCY=true" : ""}${isCacheBusting ? " busting=true" : ""}`);
+      sessionLog(sessionId, `transform: ${formatPiPressureForLog({ percentage: usagePercentage, inputTokens: usageInputTokens, contextLimit: usageContextLimit })} decision=${schedulerDecision}${forceMaterialization ? " force=true" : ""}${isEmergency ? " EMERGENCY=true" : ""}${isCacheBusting ? " busting=true" : ""}`);
       logTransformTiming(sessionId, "emergencyRecoveryBlock", tEmergencyRecovery);
       const entryIds = strictEntryIds ?? undefined;
       const emergencyCeilingTokens = usageContextLimit && usageContextLimit > 0 ? Math.floor(usageContextLimit * (resolveExecuteThreshold(schedulerConfig.executeThresholdPercentage ?? 65, liveModelBySession.get(sessionId), 65, {
@@ -24386,6 +25140,7 @@ function registerPiContextHandler(pi, baseOptions) {
         reusableMessageIds,
         stableIdSchemeCutover,
         schedulerDecision,
+        schedulerDeferReason,
         forceMaterialization: forceMaterialization || isEmergency,
         forceMaterializationPercentage,
         contextUsage: {
@@ -24524,7 +25279,12 @@ function registerPiContextHandler(pi, baseOptions) {
             previous: getPiChannel1Baseline(sessionId)
           });
           const effective = effectivePiTailHygiene(baseline);
-          resetLastNudgeCycleIfTailShrank(options.db, sessionId, effective.u);
+          const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(options.db, sessionId, effective.u) : getChannel1NudgeState(options.db, sessionId);
+          baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
+            pending: durableGrace.postReduceGracePending === true,
+            baselineU: durableGrace.postReduceGraceBaselineU,
+            preReduceLevel: durableGrace.postReduceGracePreLevel ?? durableGrace.level
+          } : undefined;
           const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags(options.db, sessionId, protectedTags);
           const channelState = {
             ...baseline,
@@ -24631,10 +25391,11 @@ function registerPiContextHandler(pi, baseOptions) {
   log("[magic-context][pi] registered context handler (tagging + drops + nudges)");
 }
 var inFlightHistorian = new Map;
-async function awaitInFlightHistorians() {
-  if (inFlightHistorian.size === 0)
+async function awaitInFlightHistorians(sessionId) {
+  const runs = sessionId ? [inFlightHistorian.get(sessionId)].filter((run) => run !== undefined) : [...inFlightHistorian.values()];
+  if (runs.length === 0)
     return;
-  await Promise.allSettled(Array.from(inFlightHistorian.values()));
+  await Promise.allSettled(runs);
 }
 function resolvePiHistorianTriggerInputs(args) {
   const contextLimit = typeof args.usageContextLimit === "number" && Number.isFinite(args.usageContextLimit) && args.usageContextLimit > 0 ? args.usageContextLimit : DEFAULT_CONTEXT_LIMIT;
@@ -24771,6 +25532,8 @@ function spawnPiHistorianRun(args) {
         refreshBoundarySnapshot,
         currentContextLimit,
         historianTimeoutMs: historian.timeoutMs,
+        temperature: historian.temperature,
+        maxOutputTokens: historian.maxOutputTokens,
         twoPass: historian.twoPass,
         thinkingLevel: historian.thinkingLevel,
         memoryEnabled: historian.memoryEnabled,
@@ -24889,7 +25652,12 @@ function maybeFireHistorian(args) {
       };
       usageSource = "piUsage fallback";
     }
-    usage = applyForwardPressureFloor(usage.percentage, usage.inputTokens, piUsage?.tokens, usageContextLimit);
+    usage = resolvePiPressureSnapshot({
+      persistedPercentage: usage.percentage,
+      persistedInputTokens: usage.inputTokens,
+      liveInputTokens: piUsage?.tokens,
+      usableContextLimit: usageContextLimit
+    });
     sessionLog(sessionId, `historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [${usageSource}], checking trigger...`);
   } catch (err) {
     sessionLog(sessionId, `historian trigger eval: getContextUsage threw: ${err instanceof Error ? err.message : String(err)}`);
@@ -25270,7 +26038,10 @@ async function runPipeline(args) {
   });
   if (shouldApplyPendingOps) {
     const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : foldExecutedThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `scheduler_execute (scheduler=${args.schedulerDecision})`;
-    sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
+    const pendingOpsDepth = getPendingOpsCount(args.db, args.sessionId);
+    const pendingDecisionLog = `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOpsDepth === null ? "not loaded (deferred pass)" : pendingOpsDepth} context=${args.contextUsage.percentage.toFixed(1)}%`;
+    sessionLog(args.sessionId, pendingDecisionLog);
+    pendingDecisionLogObserverForTests?.(pendingDecisionLog);
     try {
       const tApplyPending = performance.now();
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, pendingOperationTags, pendingOps);
@@ -25291,7 +26062,11 @@ async function runPipeline(args) {
       throw err;
     }
   } else {
-    sessionLog(args.sessionId, `pending ops WILL NOT APPLY — reason=scheduler_defer pendingOps=${pendingOps.length} context=${args.contextUsage.percentage.toFixed(1)}%`);
+    const pendingOpsDepth = getPendingOpsCount(args.db, args.sessionId);
+    const refusalReason = args.schedulerDeferReason ?? (historianRunning ? "historian_in_flight" : "scheduler_defer");
+    const pendingDecisionLog = `pending ops WILL NOT APPLY — reason=${refusalReason} pendingOps=${pendingOpsDepth === null ? "not loaded (deferred pass)" : pendingOpsDepth} context=${args.contextUsage.percentage.toFixed(1)}%`;
+    sessionLog(args.sessionId, pendingDecisionLog);
+    pendingDecisionLogObserverForTests?.(pendingDecisionLog);
   }
   const targetTagNumbers = [...targets.keys()];
   const tGetTags = performance.now();
@@ -25348,14 +26123,22 @@ async function runPipeline(args) {
   logTransformTiming(args.sessionId, "getActiveTagsBySession", tActiveTags, `count=${activeTags.length}`);
   if (shouldRunHeuristics) {
     const reason = args.forceMaterialization ? "force_materialization" : foldExecutedThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
-    sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=n/a`);
+    const heuristicsDecisionLog = `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=n/a`;
+    sessionLog(args.sessionId, heuristicsDecisionLog);
+    pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
   } else {
-    const reason = args.heuristics === undefined ? "disabled" : "scheduler_defer";
-    sessionLog(args.sessionId, `heuristics WILL NOT RUN — reason=${reason}`);
+    const reason = args.heuristics === undefined ? "disabled" : args.schedulerDeferReason ?? (historianRunning ? "historian_in_flight" : alreadyRanHeuristicsThisTurn ? "already_ran_this_turn" : "scheduler_defer");
+    const heuristicsDecisionLog = `heuristics WILL NOT RUN — reason=${reason}`;
+    sessionLog(args.sessionId, heuristicsDecisionLog);
+    pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
   }
   if (shouldRunHeuristics && args.heuristics) {
     try {
       const tHeuristic = performance.now();
+      const independentMutationBeforeHeuristics = pendingOpsDidMutate || foldExecutedThisPass;
+      if (args.forceMaterialization === true && independentMutationBeforeHeuristics && getEmergencyInputSample(args.db, args.sessionId) > 0) {
+        clearEmergencyDropSample(args.db, args.sessionId);
+      }
       heuristicsResult = applyPiHeuristicCleanup(args.sessionId, args.db, targets, args.messages, {
         protectedTags: args.protectedTags,
         staleReduceStripEnabled: args.canUseEmptySentinels,
@@ -25875,9 +26658,10 @@ function registerCtxFlushCommand(pi, deps) {
   pi.registerCommand("ctx-flush", {
     description: "Force pending Magic Context drops to materialize on the next provider call",
     handler: async (_args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-flush",
           text: `## /ctx-flush
 
@@ -25887,7 +26671,7 @@ No active Pi session is available.`,
         return;
       }
       if (deps.compactionOff) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-flush",
           text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
           level: "warning"
@@ -25906,7 +26690,7 @@ Flushed ${pendingBefore} pending ops; next provider call will materialize.
 ${result}` : `## /ctx-flush
 
 ${result}`;
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-flush",
         text,
         level: result.startsWith("Error:") ? "error" : "success"
@@ -25926,7 +26710,7 @@ function cleanupHistorianStateFile(path6) {
 }
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // ../plugin/src/agents/historian.ts
 var HISTORIAN_AGENT = "historian";
@@ -26263,8 +27047,8 @@ function isTransientHistorianPromptError2(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -26286,7 +27070,7 @@ function dumpHistorianResponse(sessionId, directory, label, text) {
     ensureCortexKitArtifactGitignore(directory);
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join4(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join5(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync5(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -26319,6 +27103,7 @@ function insertRecompCompartmentRows(db, sessionId, compartments, now) {
 }
 function promoteRecompStagingWithM0Mutation(db, sessionId, holderId) {
   const now = Date.now();
+  const transactionStartedAt = performance.now();
   db.exec("BEGIN IMMEDIATE");
   let finished = false;
   try {
@@ -26347,6 +27132,7 @@ function promoteRecompStagingWithM0Mutation(db, sessionId, holderId) {
     clearCachedM0M1(db, sessionId);
     db.exec("COMMIT");
     finished = true;
+    logSlowWriteTransaction("historian-publish:recomp", transactionStartedAt);
     return { compartments: staging.compartments, facts: staging.facts };
   } finally {
     if (!finished) {
@@ -27130,6 +27916,8 @@ function createPiHistorianClient(args) {
   const sessions = new Map;
   let counter = 0;
   async function prompt(input) {
+    if (args.signal?.aborted)
+      throw new Error("prompt aborted by external signal");
     const body = readBody(input);
     const sessionId = readPathId(input);
     if (body.noReply) {
@@ -27150,8 +27938,11 @@ function createPiHistorianClient(args) {
       cwd: args.directory,
       thinkingLevel: modelOverride ? modelOverride.qualifier : args.thinkingLevel,
       accountingSessionId: args.accountingSessionId,
-      accountingSubagent: "recomp"
+      accountingSubagent: "recomp",
+      signal: args.signal
     });
+    if (args.signal?.aborted)
+      throw new Error("prompt aborted by external signal");
     if (!result.ok) {
       throw new Error(`Pi recomp historian failed (${result.reason}): ${result.error}`);
     }
@@ -27162,6 +27953,8 @@ function createPiHistorianClient(args) {
     session: {
       get: async () => ({ directory: args.directory }),
       create: async () => {
+        if (args.signal?.aborted)
+          throw new Error("prompt aborted by external signal");
         const id = `magic-context-pi-recomp-${++counter}`;
         sessions.set(id, []);
         return { id };
@@ -27218,16 +28011,13 @@ function makeMessage2(role, text) {
 
 // src/pi-recomp-marker.ts
 function stagePiRecompMarker(args) {
-  const readBranchEntries = resolvePiReadBranchEntries2(args.ctx);
-  if (!readBranchEntries)
-    return;
   const compartments = getCompartments(args.db, args.sessionId);
   const last = compartments[compartments.length - 1];
   if (!last)
     return;
   let firstKeptEntryId = null;
   try {
-    firstKeptEntryId = findFirstKeptEntryId(readBranchEntries(), last.endMessage);
+    firstKeptEntryId = findFirstKeptEntryId(args.branchEntries, last.endMessage);
   } catch {
     firstKeptEntryId = null;
   }
@@ -27243,19 +28033,6 @@ function stagePiRecompMarker(args) {
   });
   signalPiDeferredHistoryRefresh(args.sessionId);
 }
-function resolvePiReadBranchEntries2(ctx) {
-  const sm = ctx?.sessionManager;
-  if (typeof sm?.getBranch !== "function")
-    return;
-  return () => {
-    try {
-      const entries = sm.getBranch?.call(sm);
-      return Array.isArray(entries) ? entries : [];
-    } catch {
-      return [];
-    }
-  };
-}
 
 // src/status-line.ts
 var STATUS_KEY = "magic-context";
@@ -27301,7 +28078,6 @@ function renderStatusText(ctx, db, sessionId) {
   const meta = readSessionMetaStatus(db, sessionId);
   const liveInputTokens = typeof usage?.tokens === "number" && Number.isFinite(usage.tokens) ? usage.tokens : undefined;
   const persistedInputTokens = typeof meta?.last_input_tokens === "number" && Number.isFinite(meta.last_input_tokens) && meta.last_input_tokens >= 0 ? meta.last_input_tokens : undefined;
-  const inputTokens = liveInputTokens ?? persistedInputTokens;
   const windowGeometry = resolvePiWindowGeometry({
     rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
     model: ctx.model,
@@ -27309,8 +28085,14 @@ function renderStatusText(ctx, db, sessionId) {
     persistedInputTokens,
     persistedPercentage: typeof meta?.last_context_percentage === "number" ? meta.last_context_percentage : undefined
   });
-  const usableSoft = windowGeometry?.usableSoft;
-  const pct = inputTokens !== undefined && usableSoft !== undefined && usableSoft > 0 ? inputTokens / usableSoft * 100 : typeof meta?.last_context_percentage === "number" ? meta.last_context_percentage : undefined;
+  const pressure = liveInputTokens !== undefined || persistedInputTokens !== undefined ? resolvePiPressureSnapshot({
+    persistedPercentage: meta?.last_context_percentage ?? 0,
+    persistedInputTokens: persistedInputTokens ?? 0,
+    liveInputTokens,
+    usableContextLimit: windowGeometry?.usableSoft
+  }) : undefined;
+  const inputTokens = pressure?.inputTokens;
+  const pct = pressure?.percentage;
   const state2 = renderHistorianState(meta, recompSessions.has(sessionId));
   return `mc: ${inputTokens === undefined ? "--" : fmt(inputTokens)} (${pct === undefined ? "--" : `${Math.round(pct)}%`}) · ${state2}`;
 }
@@ -27367,29 +28149,41 @@ var inFlightRecomp = new Map;
 function isPiRecompInFlight(sessionId) {
   return inFlightRecomp.has(sessionId);
 }
-async function awaitInFlightRecomps() {
-  if (inFlightRecomp.size === 0)
+async function awaitInFlightRecomps(sessionId) {
+  const runs = sessionId ? [inFlightRecomp.get(sessionId)?.promise].filter((run) => run !== undefined) : [...inFlightRecomp.values()].map((run) => run.promise);
+  if (runs.length === 0)
     return;
-  await Promise.allSettled(Array.from(inFlightRecomp.values()));
+  await Promise.allSettled(runs);
+}
+function abortInFlightRecomps(sessionId) {
+  inFlightRecomp.get(sessionId)?.controller.abort();
 }
 function spawnPiRecompRun(args) {
   const { sessionId, provider, onStatusChange, work } = args;
+  const controller = new AbortController;
   const unregister = setRawMessageProvider(sessionId, provider);
   setMagicContextRecompActive(sessionId, true);
-  onStatusChange();
-  const runPromise = (async () => {
+  let run;
+  const runPromise = Promise.resolve().then(async () => {
     try {
-      await work();
+      await work(controller.signal);
     } catch (err) {
-      sessionLog(sessionId, `pi recomp run failed (detached): ${err instanceof Error ? err.message : String(err)}`);
+      if (!controller.signal.aborted) {
+        sessionLog(sessionId, `pi recomp run failed (detached): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }).finally(() => {
+    if (inFlightRecomp.get(sessionId) === run) {
+      inFlightRecomp.delete(sessionId);
     }
-  })().finally(() => {
-    inFlightRecomp.delete(sessionId);
     setMagicContextRecompActive(sessionId, false);
     unregister();
-    onStatusChange();
+    if (!controller.signal.aborted)
+      onStatusChange();
   });
-  inFlightRecomp.set(sessionId, runPromise);
+  run = { promise: runPromise, controller };
+  inFlightRecomp.set(sessionId, run);
+  onStatusChange();
 }
 
 // src/commands/ctx-recomp.ts
@@ -27406,9 +28200,10 @@ function registerCtxRecompCommand(pi, deps) {
   pi.registerCommand("ctx-recomp", {
     description: "Rebuild Magic Context compartments from raw Pi session history",
     handler: async (args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: `## Magic Recomp
 
@@ -27419,7 +28214,7 @@ No active Pi session is available.`,
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
       if (currentDeps.compactionOff) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
           level: "warning"
@@ -27428,7 +28223,7 @@ No active Pi session is available.`,
       }
       const parsed = parseRecompArgs(args);
       if (parsed.kind === "error") {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: `## Magic Recomp — Invalid Arguments
 
@@ -27438,15 +28233,16 @@ ${parsed.message}`,
         return;
       }
       if (parsed.kind === "upgrade") {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: executeRecompUpgradeStub(currentDeps.db, sessionId),
-          level: "info"
+          level: "info",
+          rpcDisplay: "dialog"
         });
         return;
       }
       if (!currentDeps.historianModel) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: "## Magic Recomp\n\n/ctx-recomp is unavailable because `historian.model` is not configured.",
           level: "error"
@@ -27463,7 +28259,7 @@ ${parsed.message}`,
           confirmationBySession.delete(sessionId);
         else
           confirmationBySession.set(sessionId, { timestamp: now, argsKey });
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: warning.text,
           level: warning.confirmable ? "warning" : "error"
@@ -27471,7 +28267,7 @@ ${parsed.message}`,
         return;
       }
       if (isWrapupInProgress(currentDeps.db, sessionId)) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: "## Magic Recomp\n\n/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-recomp` again.",
           level: "warning"
@@ -27479,7 +28275,7 @@ ${parsed.message}`,
         return;
       }
       if (isPiRecompInFlight(sessionId)) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-recomp",
           text: `## Magic Recomp
 
@@ -27489,7 +28285,7 @@ A recomp or upgrade is already running for this session in the background. Wait
         return;
       }
       confirmationBySession.delete(sessionId);
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-recomp",
         text: parsed.kind === "partial" ? `## Magic Recomp
 
@@ -27498,17 +28294,21 @@ Partial recomp started for range ${parsed.range.start}-${parsed.range.end}.` : `
 Historian recomp started. Rebuilding compartments and facts from raw Pi session history now.`,
         level: "info"
       });
+      const cwd = ctx.cwd;
+      const fallbackModelId = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+      const snapshot = readPiSessionSnapshot(ctx);
       const provider = {
-        readMessages: () => readPiSessionMessages(ctx)
+        readMessages: () => snapshot.rawMessages
       };
       spawnPiRecompRun({
         sessionId,
         provider,
         onStatusChange: () => updateStatusLine(ctx, {
           db: currentDeps.db,
-          projectIdentity: ctx.cwd
+          projectIdentity: cwd
         }),
-        work: async () => {
+        work: async (signal) => {
+          const detachedSendStatus = createCtxStatusSender(pi, ctx, signal);
           const result = await executeContextRecompWithResult({
             client: createPiHistorianClient({
               runner: currentDeps.runner,
@@ -27517,10 +28317,11 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
               fallbackModels: currentDeps.historianFallbacks,
               timeoutMs: currentDeps.historianTimeoutMs,
               thinkingLevel: currentDeps.historianThinkingLevel,
-              directory: ctx.cwd,
+              directory: cwd,
               accountingSessionId: sessionId,
+              signal,
               notify: (text) => {
-                sendCtxStatusMessage(pi, {
+                detachedSendStatus({
                   title: "/ctx-recomp",
                   text,
                   level: inferLevel(text)
@@ -27530,15 +28331,17 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
             db: currentDeps.db,
             sessionId,
             historianChunkTokens: currentDeps.historianChunkTokens,
-            directory: ctx.cwd,
+            directory: cwd,
             historianTimeoutMs: currentDeps.historianTimeoutMs,
             memoryEnabled: currentDeps.memoryEnabled,
             autoPromote: currentDeps.autoPromote,
             ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
             fallbackModels: currentDeps.historianFallbacks,
             language: currentDeps.language,
-            fallbackModelId: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined
+            fallbackModelId
           }, parsed.kind === "partial" ? { range: parsed.range } : {});
+          if (signal.aborted)
+            return;
           if (result.published) {
             try {
               clearEmergencyRecovery(currentDeps.db, sessionId);
@@ -27546,14 +28349,18 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
               sessionLog(sessionId, `/ctx-recomp: clearEmergencyRecovery failed (continuing): ${describeError(recoveryError).brief}`);
             }
             try {
-              stagePiRecompMarker({ db: currentDeps.db, sessionId, ctx });
+              stagePiRecompMarker({
+                db: currentDeps.db,
+                sessionId,
+                branchEntries: snapshot.branchEntries
+              });
             } catch (markerError) {
               sessionLog(sessionId, `/ctx-recomp: marker staging failed (recomp already published; continuing): ${describeError(markerError).brief}`);
             }
             signalPiDeferredHistoryRefresh(sessionId);
             signalPiDeferredMaterialization(sessionId);
           }
-          sendCtxStatusMessage(pi, {
+          detachedSendStatus({
             title: "/ctx-recomp",
             text: result.message,
             level: inferLevel(result.message)
@@ -27785,7 +28592,13 @@ function contextualizeUpgradeReason(reason) {
 
 // src/pi-memory-migration.ts
 var MIGRATION_SYSTEM_PROMPT2 = "You re-organize a software project's long-term memory into a stricter taxonomy. " + "Follow the user instructions exactly. Output ONLY the requested XML blocks, nothing else.";
+var CANCELLED_OUTCOME = {
+  ran: false,
+  summary: "Memory migration cancelled during session shutdown."
+};
 async function runPiMemoryMigration(deps) {
+  if (deps.signal?.aborted)
+    return CANCELLED_OUTCOME;
   const projectPath = resolveProjectIdentityForSession(deps.directory, deps.allowHomeProject);
   if (!projectPath) {
     return {
@@ -27823,6 +28636,8 @@ async function runPiMemoryMigration(deps) {
   let parsed = null;
   let lastFailReason = "no output";
   for (let i = 0;i < modelChain.length; i += 1) {
+    if (deps.signal?.aborted)
+      return CANCELLED_OUTCOME;
     const model = modelChain[i];
     if (i > 0) {
       sessionLog(deps.sessionId, `memory-migration: escalating to configured fallback model ${model.model} (${i}/${modelChain.length - 1})`);
@@ -27837,8 +28652,11 @@ async function runPiMemoryMigration(deps) {
       cwd: deps.directory,
       thinkingLevel: model.qualifier,
       accountingSessionId: deps.sessionId,
-      accountingSubagent: "recomp"
+      accountingSubagent: "recomp",
+      signal: deps.signal
     });
+    if (deps.signal?.aborted)
+      return CANCELLED_OUTCOME;
     if (!result.ok) {
       lastFailReason = `historian ${result.reason}`;
       continue;
@@ -27869,6 +28687,8 @@ async function runPiMemoryMigration(deps) {
       summary: "Memory migration skipped: the model extracted user traits but user memories are disabled. Enable `dreamer.user_memories` so they can be preserved, then re-run /ctx-session-upgrade."
     };
   }
+  if (deps.signal?.aborted)
+    return CANCELLED_OUTCOME;
   let routed = 0;
   if (deps.userMemoriesEnabled && parsed.userObservations.length > 0) {
     insertUserMemoryCandidates(deps.db, parsed.userObservations.map((content) => ({
@@ -27893,9 +28713,10 @@ function registerCtxSessionUpgradeCommand(pi, deps) {
   pi.registerCommand("ctx-session-upgrade", {
     description: "Upgrade this session to the current Magic Context history format and re-organize project memories",
     handler: async (_args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: `## Session Upgrade
 
@@ -27906,7 +28727,7 @@ No active Pi session is available.`,
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
       if (currentDeps.compactionOff) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
           level: "warning"
@@ -27914,7 +28735,7 @@ No active Pi session is available.`,
         return;
       }
       if (!currentDeps.historianModel) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: "## Session Upgrade\n\nUnavailable because `historian.model` is not configured.",
           level: "error"
@@ -27922,7 +28743,7 @@ No active Pi session is available.`,
         return;
       }
       if (isWrapupInProgress(currentDeps.db, sessionId)) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: `## Session Upgrade
 
@@ -27932,7 +28753,7 @@ No active Pi session is available.`,
         return;
       }
       if (isPiRecompInFlight(sessionId)) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: `## Session Upgrade
 
@@ -27943,9 +28764,10 @@ An upgrade or recomp is already running for this session in the background. Wait
       }
       const compartments = getCompartments(currentDeps.db, sessionId);
       const upgradableCount = compartments.filter((c) => c.legacy === 1 || !c.p1 || c.p1.trim() === "").length;
+      const cwd = ctx.cwd;
       const sessionMainModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
       const migrationEnabled = currentDeps.memoryEnabled;
-      const runMigration = async () => {
+      const runMigration = async (signal) => {
         if (!migrationEnabled) {
           return "Memory migration skipped (memory disabled).";
         }
@@ -27958,24 +28780,27 @@ An upgrade or recomp is already running for this session in the background. Wait
             fallbackModels: currentDeps.historianFallbacks,
             timeoutMs: currentDeps.historianTimeoutMs,
             thinkingLevel: currentDeps.historianThinkingLevel,
-            directory: ctx.cwd,
+            directory: cwd,
             allowHomeProject: currentDeps.allowHomeProject,
             sessionId,
             userMemoriesEnabled: currentDeps.userMemoriesEnabled,
-            language: currentDeps.language
+            language: currentDeps.language,
+            signal
           });
           return outcome.summary;
         } catch (error) {
+          if (signal.aborted)
+            return "Memory migration cancelled.";
           return `Memory migration skipped (error): ${describeError(error).brief}`;
         }
       };
       if (upgradableCount === 0) {
-        const projectPath = resolveProjectIdentityForSession(ctx.cwd, currentDeps.allowHomeProject);
+        const projectPath = resolveProjectIdentityForSession(cwd, currentDeps.allowHomeProject);
         if (!projectPath)
           return;
         const migrationPending = migrationEnabled && !isMemoryMigrationDone(currentDeps.db, projectPath);
         if (!migrationPending) {
-          sendCtxStatusMessage(pi, {
+          sendStatus({
             title: "/ctx-session-upgrade",
             text: [
               "## Session Upgrade — Already Up To Date",
@@ -27983,56 +28808,64 @@ An upgrade or recomp is already running for this session in the background. Wait
               compartments.length === 0 ? "This session has no compartment history to upgrade yet." : "This session's compartments are already in the current format."
             ].join(`
 `),
-            level: "info"
+            level: "info",
+            rpcDisplay: "dialog"
           });
           return;
         }
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-session-upgrade",
           text: `## Session Upgrade
 
 Compartments are already current. Re-organizing project memories. This may take a while.`,
           level: "info"
         });
+        const snapshot2 = readPiSessionSnapshot(ctx);
         spawnPiRecompRun({
           sessionId,
           provider: {
-            readMessages: () => readPiSessionMessages(ctx)
+            readMessages: () => snapshot2.rawMessages
           },
           onStatusChange: () => updateStatusLine(ctx, {
             db: currentDeps.db,
-            projectIdentity: ctx.cwd
+            projectIdentity: cwd
           }),
-          work: async () => {
-            const summary = await runMigration();
-            sendCtxStatusMessage(pi, {
+          work: async (signal) => {
+            const detachedSendStatus = createCtxStatusSender(pi, ctx, signal);
+            const summary = await runMigration(signal);
+            if (signal.aborted)
+              return;
+            detachedSendStatus({
               title: "/ctx-session-upgrade",
               text: ["## Session Upgrade — Complete", "", summary].join(`
 `),
-              level: "info"
+              level: "info",
+              rpcDisplay: "dialog"
             });
           }
         });
         return;
       }
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-session-upgrade",
         text: `## Session Upgrade
 
 Rebuilding compartments into the v2 format and re-organizing project memories. This may take a while.`,
         level: "info"
       });
+      const snapshot = readPiSessionSnapshot(ctx);
       const provider = {
-        readMessages: () => readPiSessionMessages(ctx)
+        readMessages: () => snapshot.rawMessages
       };
       spawnPiRecompRun({
         sessionId,
         provider,
         onStatusChange: () => updateStatusLine(ctx, {
           db: currentDeps.db,
-          projectIdentity: ctx.cwd
+          projectIdentity: cwd
         }),
-        work: async () => {
+        work: async (signal) => {
+          const detachedSendStatus = createCtxStatusSender(pi, ctx, signal);
           const recompResult = await executeContextRecompWithResult({
             client: createPiHistorianClient({
               runner: currentDeps.runner,
@@ -28040,10 +28873,11 @@ Rebuilding compartments into the v2 format and re-organizing project memories. T
               fallbackModels: currentDeps.historianFallbacks,
               timeoutMs: currentDeps.historianTimeoutMs,
               thinkingLevel: currentDeps.historianThinkingLevel,
-              directory: ctx.cwd,
+              directory: cwd,
               accountingSessionId: sessionId,
+              signal,
               systemPrompt: withContentLanguageDirective(COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, currentDeps.language, { preserveUserQuotes: true }),
-              notify: (text) => sendCtxStatusMessage(pi, {
+              notify: (text) => detachedSendStatus({
                 title: "/ctx-session-upgrade",
                 text,
                 level: "info"
@@ -28052,7 +28886,7 @@ Rebuilding compartments into the v2 format and re-organizing project memories. T
             db: currentDeps.db,
             sessionId,
             historianChunkTokens: currentDeps.historianChunkTokens,
-            directory: ctx.cwd,
+            directory: cwd,
             historianTimeoutMs: currentDeps.historianTimeoutMs,
             memoryEnabled: currentDeps.memoryEnabled,
             autoPromote: currentDeps.autoPromote,
@@ -28061,9 +28895,11 @@ Rebuilding compartments into the v2 format and re-organizing project memories. T
             fallbackModelId: sessionMainModel,
             language: currentDeps.language
           }, {});
+          if (signal.aborted)
+            return;
           if (!recompResult.published || !isRecompComplete(recompResult.message)) {
             const reason = contextualizeUpgradeReason(isRecompFailure(recompResult.message) ? extractRecompReason(recompResult.message) : `Compartments were not fully rebuilt: ${extractRecompReason(recompResult.message)}`);
-            sendCtxStatusMessage(pi, {
+            detachedSendStatus({
               title: "/ctx-session-upgrade",
               text: `## Session Upgrade — Incomplete
 
@@ -28073,14 +28909,20 @@ ${reason}`,
             return;
           }
           try {
-            stagePiRecompMarker({ db: currentDeps.db, sessionId, ctx });
+            stagePiRecompMarker({
+              db: currentDeps.db,
+              sessionId,
+              branchEntries: snapshot.branchEntries
+            });
           } catch (markerError) {
             sessionLog(sessionId, `pi /ctx-session-upgrade marker staging failed (non-fatal, recomp already published): ${describeError(markerError).brief}`);
           }
           signalPiDeferredHistoryRefresh(sessionId);
           signalPiDeferredMaterialization(sessionId);
-          const migrationSummary = await runMigration();
-          sendCtxStatusMessage(pi, {
+          const migrationSummary = await runMigration(signal);
+          if (signal.aborted)
+            return;
+          detachedSendStatus({
             title: "/ctx-session-upgrade",
             text: [
               "## Session Upgrade — Complete",
@@ -28092,7 +28934,8 @@ ${migrationSummary}` : "",
               recompResult.message
             ].join(`
 `),
-            level: "info"
+            level: "info",
+            rpcDisplay: "dialog"
           });
         }
       });
@@ -28118,6 +28961,9 @@ function formatThresholdClampNote(opts) {
   return ` [clamped: ${opts.configuredValue}% > ${opts.maxPercentage}%]`;
 }
 
+// ../plugin/src/shared/rust-mode-status.ts
+var RUST_MODE_HOST_PATHS_LINE = "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";
+
 // ../plugin/src/shared/tail-hygiene-status.ts
 function finiteNumber(value, fallback = 0) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
@@ -28184,7 +29030,7 @@ function formatExecuteThreshold(detail, contextLimit) {
   }
   return `${percentage}%${clampNote}`;
 }
-function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer, windowGeometry, tailHygiene) {
+function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer, windowGeometry, tailHygiene, contextUsage, rustMode = false) {
   const thresholdDetail = resolveExecuteThresholdDetail(executeThresholdPercentageConfig, liveModelKey, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, {
     tokensConfig: executeThresholdTokens,
     contextLimit,
@@ -28209,7 +29055,9 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
     const remainingMs = Math.max(0, ttlMs - elapsed);
     const cacheExpired = remainingMs === 0 && meta.lastResponseTime > 0;
     const proactiveCompartmentTrigger = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
-    const displayContextLimit = contextLimit && contextLimit > 0 ? contextLimit : meta.lastContextPercentage > 0 ? Math.round(meta.lastInputTokens / (meta.lastContextPercentage / 100)) : 0;
+    const displayInputTokens = contextUsage?.inputTokens ?? meta.lastInputTokens;
+    const displayPercentage = contextUsage?.percentage ?? meta.lastContextPercentage;
+    const displayContextLimit = contextLimit && contextLimit > 0 ? contextLimit : displayPercentage > 0 ? Math.round(displayInputTokens / (displayPercentage / 100)) : 0;
     const lines = [
       "## Magic Status",
       "",
@@ -28234,11 +29082,15 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       "",
       "### Execute Threshold",
       `- Execute threshold: ${formatExecuteThreshold(thresholdDetail, displayContextLimit)}`,
-      `- Last input tokens: ${meta.lastInputTokens.toLocaleString()} tokens`,
+      `- Last input tokens: ${displayInputTokens.toLocaleString()} tokens`,
       "",
       `**Protected tags:** ${protectedTags}`,
       `**Subagent session:** ${meta.isSubagent}`
     ];
+    const storage = getMagicContextStorageResolution();
+    lines.push("", `**Storage:** ${storage.path} (${storage.source})`);
+    if (rustMode)
+      lines.push("", "### Rust Mode", `- ${RUST_MODE_HOST_PATHS_LINE}`);
     if (tailHygiene !== undefined) {
       lines.push("", "### Tail Hygiene", `- Reclaimable / eligible: ${formatTailHygiene(tailHygiene)}`, "- Reasoning is excluded from both terms.");
     }
@@ -28247,8 +29099,8 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
         `- Running: ${dreamer.progress.task} — ${dreamer.progress.processed}/${dreamer.progress.total} processed`
       ] : [], ...formatDreamTaskBacklogs(dreamer.backlog).split("\\n"));
     }
-    if (meta.lastContextPercentage > 0 || meta.lastInputTokens > 0) {
-      lines.push("", "### Context Usage", `- Last percentage: ${meta.lastContextPercentage.toFixed(1)}%`, `- Last input tokens: ${meta.lastInputTokens.toLocaleString()}`, `- Resolved context limit: ${displayContextLimit > 0 ? displayContextLimit.toLocaleString() : "unknown"}`, ...windowGeometry ? [`- ${formatWindowDerivationLine(meta.lastInputTokens, windowGeometry)}`] : [], `- Proactive compartment evaluation: ${proactiveCompartmentTrigger}%`, `- Post-drop target for historian: ${(executeThresholdPercentage * POST_DROP_TARGET_RATIO).toFixed(0)}% (${executeThresholdPercentage}% * ${POST_DROP_TARGET_RATIO})`, `- Commit cluster trigger: ${commitClusterTrigger?.enabled !== false ? `enabled (min ${commitClusterTrigger?.min_clusters ?? 3} clusters)` : "disabled"}, tail-size trigger: > 3x compartment budget`);
+    if (displayPercentage > 0 || displayInputTokens > 0) {
+      lines.push("", "### Context Usage", `- Last percentage: ${displayPercentage.toFixed(1)}%`, `- Last input tokens: ${displayInputTokens.toLocaleString()}`, `- Resolved context limit: ${displayContextLimit > 0 ? displayContextLimit.toLocaleString() : "unknown"}`, ...windowGeometry ? [`- ${formatWindowDerivationLine(displayInputTokens, windowGeometry)}`] : [], `- Proactive compartment evaluation: ${proactiveCompartmentTrigger}%`, `- Post-drop target for historian: ${(executeThresholdPercentage * POST_DROP_TARGET_RATIO).toFixed(0)}% (${executeThresholdPercentage}% * ${POST_DROP_TARGET_RATIO})`, `- Commit cluster trigger: ${commitClusterTrigger?.enabled !== false ? `enabled (min ${commitClusterTrigger?.min_clusters ?? 3} clusters)` : "disabled"}, tail-size trigger: > 3x compartment budget`);
     }
     const compartments = getCompartments(db, sessionId);
     let historyBlockTokens = 0;
@@ -28285,7 +29137,7 @@ ${c.content}
 
 // src/dialogs/status-dialog.ts
 import {
-  matchesKey,
+  matchesKey as matchesKey2,
   truncateToWidth,
   visibleWidth
 } from "@earendil-works/pi-tui";
@@ -28349,7 +29201,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.40.1",
+  version: "0.41.1",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -28377,7 +29229,7 @@ var package_default = {
     "README.md"
   ],
   scripts: {
-    build: "tsc -p ../retina-local-fs/tsconfig.build.json && rm -f dist/index.js dist/subagent-entry.js dist/*-*.js && bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external @huggingface/transformers --external node:sqlite",
+    build: "tsc -p ../retina-local-fs/tsconfig.build.json && rm -f dist/index.js dist/subagent-entry.js dist/historian-calibration-extension.js dist/transformers-web.js dist/*-*.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts --outdir dist --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external node:sqlite",
     "build:e2e-argv": "bun build src/subagent-runner.ts --outfile ../../tests/docker/.generated/subagent-runner-e2e.mjs --target node --format esm --external node:sqlite",
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit",
     test: "bun install --frozen-lockfile && bun test",
@@ -28390,16 +29242,21 @@ var package_default = {
   },
   dependencies: {
     "@cortexkit/subc-client": "0.4.1",
-    "@huggingface/transformers": "^4.1.0",
     "@jitl/quickjs-singlefile-cjs-release-asyncify": "0.32.0",
     "ai-tokenizer": "^1.0.6",
     "comment-json": "^5.0.0",
+    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
     "quickjs-emscripten": "^0.32.0",
     typebox: "^1.3.1",
     zod: "^4.1.8"
   },
+  optionalDependencies: {
+    "onnxruntime-node": "1.24.3",
+    sharp: "^0.34.5"
+  },
   devDependencies: {
     "@biomejs/biome": "^2.5.1",
+    "@huggingface/transformers": "^4.1.0",
     "@earendil-works/pi-ai": "0.83.0",
     "@earendil-works/pi-coding-agent": "0.83.0",
     "@earendil-works/pi-tui": "0.83.0",
@@ -28485,7 +29342,7 @@ class StatusDialogComponent {
     }, REFRESH_INTERVAL_MS);
   }
   handleInput(data) {
-    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || matchesKey(data, "return")) {
+    if (matchesKey2(data, "escape") || matchesKey2(data, "ctrl+c") || matchesKey2(data, "return")) {
       this.close();
     }
   }
@@ -28586,8 +29443,6 @@ function drawBorder(inner, width, theme) {
 function buildPiStatusDetail(pi, ctx, deps, sessionId) {
   const usage = ctx.getContextUsage?.();
   const meta = getOrCreateSessionMeta(deps.db, sessionId);
-  const hasPersistedPressure = meta.lastInputTokens > 0 && meta.lastContextPercentage > 0;
-  const inputTokens = hasPersistedPressure ? meta.lastInputTokens : typeof usage?.tokens === "number" ? usage.tokens : 0;
   let detectedContextLimit;
   try {
     const detected = getOverflowState(deps.db, sessionId).detectedContextLimit;
@@ -28601,8 +29456,15 @@ function buildPiStatusDetail(pi, ctx, deps, sessionId) {
     persistedInputTokens: meta.lastInputTokens,
     persistedPercentage: meta.lastContextPercentage
   });
-  const contextLimit = windowGeometry?.usableSoft ?? 0;
-  const usagePercentage = contextLimit > 0 && inputTokens > 0 ? inputTokens / contextLimit * 100 : meta.lastContextPercentage;
+  const pressure = resolvePiPressureSnapshot({
+    persistedPercentage: meta.lastContextPercentage,
+    persistedInputTokens: meta.lastInputTokens,
+    liveInputTokens: usage?.tokens,
+    usableContextLimit: windowGeometry?.usableSoft
+  });
+  const inputTokens = pressure.inputTokens;
+  const contextLimit = pressure.contextLimit ?? 0;
+  const usagePercentage = pressure.percentage;
   const compartments = getCompartments(deps.db, sessionId);
   const metaRow = readSessionMetaRow(deps.db, sessionId);
   const memoryBlockCount = Number(metaRow?.memory_block_count ?? 0);
@@ -28859,12 +29721,13 @@ function registerCtxStatusCommand(pi, deps) {
   pi.registerCommand("ctx-status", {
     description: "Show Magic Context status for the current Pi session",
     handler: async (_args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const runtimeDeps = deps.resolveStatusDeps?.(ctx) ?? deps;
       const projectIdentity = runtimeDeps.resolveProject?.(ctx).projectIdentity ?? runtimeDeps.projectIdentity;
       const currentDeps = { ...runtimeDeps, projectIdentity };
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-status",
           text: `## Magic Status
 
@@ -28895,20 +29758,30 @@ No active Pi session is available.`,
           persistedPercentage: meta.lastContextPercentage
         });
         const usableContextLimit = windowGeometry?.usableSoft;
+        const pressure = resolvePiPressureSnapshot({
+          persistedPercentage: meta.lastContextPercentage,
+          persistedInputTokens: meta.lastInputTokens,
+          liveInputTokens: usage?.tokens,
+          usableContextLimit
+        });
         const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit, {
           backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
-        }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)));
+        }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)), pressure);
         const details = buildStatusDetails(currentDeps, sessionId);
         const profileStatus = currentDeps.activeProfile ?? "none";
-        sendCtxStatusMessage(pi, {
+        const storage = getMagicContextStorageResolution();
+        sendStatus({
           title: "/ctx-status",
           text: `${statusText}
 
-Active profile: ${profileStatus}`,
-          level: "info"
+Active profile: ${profileStatus}
+
+Storage: ${storage.path} (${storage.source})`,
+          level: "info",
+          rpcDisplay: "dialog"
         }, details);
       } catch (error) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-status",
           text: `## Magic Status — Failed
 
@@ -28996,9 +29869,10 @@ function registerCtxWrapupCommand(pi, deps) {
   pi.registerCommand("ctx-wrapup", {
     description: "Compact older Magic Context history while keeping the newest messages raw",
     handler: async (args, ctx) => {
+      const sendStatus = createCtxStatusSender(pi, ctx);
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: `## Magic Wrapup
 
@@ -29009,7 +29883,7 @@ No active Pi session is available.`,
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
       if (currentDeps.compactionOff) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
           level: "warning"
@@ -29018,7 +29892,7 @@ No active Pi session is available.`,
       }
       const sessionMeta = getOrCreateSessionMeta(currentDeps.db, sessionId);
       if (sessionMeta.isSubagent) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: `## Magic Wrapup — Skipped
 
@@ -29028,7 +29902,7 @@ No active Pi session is available.`,
         return;
       }
       if (!currentDeps.historianModel) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: "## Magic Wrapup\n\n/ctx-wrapup is unavailable because `historian.model` is not configured.",
           level: "error"
@@ -29037,7 +29911,7 @@ No active Pi session is available.`,
       }
       const parsed = parseWrapupArgs(args);
       if (!parsed.ok) {
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: `## Magic Wrapup — Invalid Arguments
 
@@ -29047,7 +29921,7 @@ ${parsed.message}`,
         return;
       }
       const result = await runPiWrapup(pi, currentDeps, ctx, sessionId, parsed.messagesToKeep);
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-wrapup",
         text: result,
         level: result.includes("Failed") || result.includes("Partial") ? "error" : "success"
@@ -29056,6 +29930,7 @@ ${parsed.message}`,
   });
 }
 async function runPiWrapup(pi, deps, ctx, sessionId, messagesToKeep) {
+  const sendStatus = createCtxStatusSender(pi, ctx);
   if (getOrCreateSessionMeta(deps.db, sessionId).isSubagent) {
     return `## Magic Wrapup — Skipped
 
@@ -29135,7 +30010,7 @@ No runnable wrapup boundary is available yet; wrapped up 0 messages into 0 compa
       }
     }, 60000);
     try {
-      sendCtxStatusMessage(pi, {
+      sendStatus({
         title: "/ctx-wrapup",
         text: `## Magic Wrapup
 
@@ -29191,7 +30066,7 @@ Eligible history is about ${initialPlan.snapshot.trueRawEligibleTokens.toLocaleS
           failure = `${ownershipLostReason}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
           break;
         }
-        sendCtxStatusMessage(pi, {
+        sendStatus({
           title: "/ctx-wrapup",
           text: `## Magic Wrapup
 
@@ -29246,7 +30121,7 @@ Chunk ${chunkIndex}: wrapping messages ${plan.snapshot.offset}-${plan.snapshot.e
             language: deps.language,
             compartmentLeaseHolderId: leaseHolder,
             readBranchEntries: () => readBranchEntries(ctx),
-            notifyIssue: (text) => sendCtxStatusMessage(pi, {
+            notifyIssue: (text) => sendStatus({
               title: "/ctx-wrapup",
               text,
               level: "warning"
@@ -29323,7 +30198,7 @@ async function acquireCompartmentLeaseEventually(db, sessionId, renewWrapupMarke
       return { ok: true, holderId };
     if (!renewWrapupMarker({}))
       return { ok: false, reason: "ownership_lost" };
-    await new Promise((resolve2) => setTimeout(resolve2, Math.min(LEASE_WAIT_MS, remainingMs())));
+    await new Promise((resolve3) => setTimeout(resolve3, Math.min(LEASE_WAIT_MS, remainingMs())));
   }
 }
 function estimateChunks(tokens, chunkTokens) {
@@ -29400,42 +30275,6 @@ function registerPiFailClosedSurface(pi, args) {
   log(`${PREFIX} fail-closed blocking surface registered (${args.reason.kind}); primary turns will error until storage recovers or the build is upgraded`);
 }
 
-// src/pi-pressure.ts
-function extractAssistantUsage(message) {
-  if (!message || typeof message !== "object")
-    return null;
-  const m = message;
-  if (m.role !== "assistant")
-    return null;
-  if (!m.usage || typeof m.usage !== "object")
-    return null;
-  const u = m.usage;
-  const result = {};
-  if (typeof u.input === "number")
-    result.input = u.input;
-  if (typeof u.output === "number")
-    result.output = u.output;
-  if (typeof u.cacheRead === "number")
-    result.cacheRead = u.cacheRead;
-  if (typeof u.cacheWrite === "number")
-    result.cacheWrite = u.cacheWrite;
-  if (typeof u.totalTokens === "number")
-    result.totalTokens = u.totalTokens;
-  return result;
-}
-function computePiPressure(usage, contextLimit) {
-  if (!usage)
-    return null;
-  const input = usage.input ?? 0;
-  const cacheRead = usage.cacheRead ?? 0;
-  const cacheWrite = usage.cacheWrite ?? 0;
-  const inputTokens = input + cacheRead + cacheWrite;
-  if (inputTokens === 0)
-    return null;
-  const percentage = contextLimit > 0 ? inputTokens / contextLimit * 100 : 0;
-  return { inputTokens, percentage };
-}
-
 // src/strip-tag-prefix.ts
 function stripTagPrefixFromAssistantMessage(message) {
   if (message.role !== "assistant")
@@ -29461,19 +30300,43 @@ function stripTagPrefixFromAssistantMessage(message) {
 
 // src/index.ts
 var PREFIX2 = "[magic-context][pi]";
-var PI_ACTIVE_LATCH = Symbol.for("magic-context.pi.active");
-function isPiMagicContextActiveInProcess() {
-  return globalThis[PI_ACTIVE_LATCH] === true;
+var PI_CHILD_INIT_CONTEXT = Symbol.for("magic-context.pi.child-init-context");
+var SUBAGENT_CHILD_SESSION_CREATED = "subagents:child:session-created";
+var SUBAGENT_CHILD_DISPOSED = "subagents:child:disposed";
+var PI_STARTUP_MAINTENANCE_SCHEDULED = Symbol.for("magic-context.pi.startup-maintenance-scheduled");
+function getPiChildInitContext() {
+  const globals = globalThis;
+  const existing = globals[PI_CHILD_INIT_CONTEXT];
+  if (existing instanceof AsyncLocalStorage)
+    return existing;
+  const context = new AsyncLocalStorage;
+  globals[PI_CHILD_INIT_CONTEXT] = context;
+  return context;
 }
-function markPiMagicContextActive() {
-  globalThis[PI_ACTIVE_LATCH] = true;
+function isPiInProcessSubagentInit() {
+  return getPiChildInitContext().getStore() === true;
 }
-function clearPiMagicContextActive() {
-  try {
-    delete globalThis[PI_ACTIVE_LATCH];
-  } catch {
-    globalThis[PI_ACTIVE_LATCH] = undefined;
-  }
+function clearPiInProcessSubagentInitContext() {
+  getPiChildInitContext().enterWith(false);
+}
+function registerPiSubagentInitContext(pi) {
+  const context = getPiChildInitContext();
+  const unsubscribeCreated = pi.events.on(SUBAGENT_CHILD_SESSION_CREATED, () => context.enterWith(true));
+  const unsubscribeDisposed = pi.events.on(SUBAGENT_CHILD_DISPOSED, () => context.enterWith(false));
+  return () => {
+    unsubscribeCreated();
+    unsubscribeDisposed();
+  };
+}
+function claimPiStartupMaintenance() {
+  const globals = globalThis;
+  if (globals[PI_STARTUP_MAINTENANCE_SCHEDULED] === true)
+    return false;
+  globals[PI_STARTUP_MAINTENANCE_SCHEDULED] = true;
+  return true;
+}
+function clearPiStartupMaintenanceClaim() {
+  delete globalThis[PI_STARTUP_MAINTENANCE_SCHEDULED];
 }
 function resolveCurrentProject(ctx, allowHomeProject = false) {
   const projectDir = ctx.cwd;
@@ -29587,7 +30450,7 @@ function ensureConfigLocationsMigrated(dir) {
   });
 }
 function logPiConfigLoad(args) {
-  const key = resolve2(args.dir);
+  const key = resolve3(args.dir);
   if (args.dedupe && loggedPiConfigDirs.has(key))
     return;
   if (args.dedupe) {
@@ -29607,9 +30470,9 @@ var __test = {
   resetLoggedPiConfigDirs() {
     loggedPiConfigDirs.clear();
   },
-  isPiMagicContextActiveInProcess,
-  markPiMagicContextActive,
-  clearPiMagicContextActive
+  clearPiInProcessSubagentInitContext,
+  claimPiStartupMaintenance,
+  clearPiStartupMaintenanceClaim
 };
 function formatTokens(value) {
   return value.toLocaleString();
@@ -29681,7 +30544,7 @@ async function persistPiPressureFromMessageEnd(args) {
 }
 var PLUGIN_VERSION = (() => {
   try {
-    const req = createRequire3(import.meta.url);
+    const req = createRequire2(import.meta.url);
     return req("../package.json").version;
   } catch {
     return "0.0.0";
@@ -29722,6 +30585,8 @@ function resolveHistorianFromConfig(config) {
     fallbackModels,
     historianChunkTokens,
     timeoutMs: config.historian_timeout_ms,
+    temperature: historian?.temperature,
+    maxOutputTokens: historian?.maxTokens ?? 32000,
     twoPass: historian?.two_pass === true,
     thinkingLevel: resolved.primary?.qualifier,
     executeThresholdPercentage: config.execute_threshold_percentage,
@@ -29754,11 +30619,12 @@ async function src_default(pi) {
     log(`${PREFIX2} subagent child detected (${MAGIC_CONTEXT_PI_SUBAGENT_ENV}=1); skipping full extension registration`);
     return;
   }
-  if (isPiMagicContextActiveInProcess()) {
-    log(`${PREFIX2} in-process re-init detected (Magic Context already active in this process); skipping full extension registration`);
+  if (isPiInProcessSubagentInit()) {
+    log(`${PREFIX2} in-process subagent child detected; skipping full extension registration`);
     return;
   }
-  markPiMagicContextActive();
+  const unregisterPiSubagentInitContext = registerPiSubagentInitContext(pi);
+  registerPiSubagentInitContextCleanup(pi, unregisterPiSubagentInitContext);
   beginBootQuietPeriod();
   const bootProjectDir = process.cwd();
   ensureConfigLocationsMigrated(bootProjectDir);
@@ -29769,7 +30635,7 @@ async function src_default(pi) {
     mmapSizeMb: bootConfig.config.sqlite.mmap_size_mb
   });
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join5(storageDir, "context.db");
+  const dbPath = join6(storageDir, "context.db");
   let db;
   let openFailureCause = null;
   try {
@@ -29830,27 +30696,44 @@ async function src_default(pi) {
 }
 async function startPiMagicContextRuntime(pi, database, dbPath) {
   const db = database;
-  scheduleAfterBootQuiet(() => {
-    runDeferredV22Backfill(db).catch((err) => {
-      warn(`[v22-backfill] background runner failed: ${err}`);
+  if (claimPiStartupMaintenance()) {
+    scheduleAfterBootQuiet(() => {
+      runDeferredV22Backfill(db).catch((err) => {
+        warn(`[v22-backfill] background runner failed: ${err}`);
+      });
     });
-  });
-  scheduleAfterBootQuiet(() => {
-    (async () => {
-      try {
-        const api = await loadDefaultPiSessionApi();
-        const sessions = await api.listSessions();
-        await runSessionProjectBackfill(database, sessions.map((session) => ({
-          sessionId: typeof session?.id === "string" ? session.id : "",
-          directory: typeof session?.cwd === "string" ? session.cwd : ""
-        })));
-      } catch (err) {
-        warn(`[session-projects] background runner failed: ${err}`);
-      }
-    })();
-  }, 0);
+    scheduleAfterBootQuiet(() => {
+      (async () => {
+        try {
+          let sessions;
+          await runSessionProjectBackfill(database, async (afterSessionId, limit) => {
+            if (!sessions) {
+              const api = await loadDefaultPiSessionApi();
+              const sessionsById2 = new Map;
+              for (const session of await api.listSessions()) {
+                const sessionId = typeof session?.id === "string" ? session.id : "";
+                const directory = typeof session?.cwd === "string" ? session.cwd : "";
+                if (sessionId && (!sessionsById2.has(sessionId) || directory)) {
+                  sessionsById2.set(sessionId, { sessionId, directory });
+                }
+              }
+              sessions = [...sessionsById2.values()];
+            }
+            const offset = afterSessionId === null ? 0 : sessions.findIndex((session) => session.sessionId === afterSessionId) + 1;
+            return sessions.slice(offset, offset + limit);
+          });
+        } catch (err) {
+          warn(`[session-projects] background runner failed: ${err}`);
+        }
+      })();
+    }, 0);
+  }
   const projectDir = process.cwd();
   const seenDreamerProjectIdentities = new Set;
+  const dreamerRegistrationOwner = {};
+  const commandLifecycleController = new AbortController;
+  registerCtxStatusLifecycleSignal(pi, commandLifecycleController.signal);
+  let sessionShuttingDown = false;
   ensureConfigLocationsMigrated(projectDir);
   const { config, warnings, loadedFromPaths, registrationPromptSurface } = loadPiConfig({
     cwd: projectDir
@@ -29993,6 +30876,32 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   }
   const bootProjectDeps = buildProjectDeps(projectDir, projectIdentity, config);
   projectDepsByDir.set(projectDir, bootProjectDeps);
+  function syncDreamerProjectRegistration(current) {
+    if (sessionShuttingDown)
+      return;
+    seenDreamerProjectIdentities.add(current.projectIdentity);
+    if (!current.dreamerConfig) {
+      unregisterPiDreamerProject({
+        projectIdentity: current.projectIdentity,
+        registrationOwner: dreamerRegistrationOwner
+      });
+      return;
+    }
+    registerPiDreamerProject({
+      db,
+      projectDir: current.projectDir,
+      projectIdentity: current.projectIdentity,
+      registrationOwner: dreamerRegistrationOwner,
+      config: current.dreamerConfig,
+      embeddingConfig: current.config.embedding,
+      memoryEnabled: current.config.memory.enabled,
+      retinaHandoff: current.config.smart_notes.retina_handoff,
+      mural: current.config.mural,
+      language: current.config.language,
+      gitCommitIndexing: current.config.memory.git_commit_indexing,
+      onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
+    });
+  }
   const todowriteEnabled = bootProjectDeps.config.todowrite.enabled !== false;
   const todowriteOverlayEnabled = todowriteEnabled && bootProjectDeps.config.todowrite.overlay !== false;
   registerMagicContextTools(pi, {
@@ -30187,7 +31096,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     },
     dreamerEnabled: bootProjectDeps.dreamerEnabled,
     resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
-    onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
+    onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity),
+    ensureRegistered: (ctx) => syncDreamerProjectRegistration(resolveCurrentProjectDeps(ctx)),
+    registrationOwner: dreamerRegistrationOwner
   });
   info("registered /ctx-dream");
   registerCtxEmbedCommand(pi, {
@@ -30207,19 +31118,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   info("registered /ctx-embed");
   const dreamerConfig = bootProjectDeps.dreamerConfig;
   if (dreamerConfig) {
-    registerPiDreamerProject({
-      db,
-      projectDir,
-      projectIdentity,
-      config: dreamerConfig,
-      embeddingConfig: bootProjectDeps.config.embedding,
-      memoryEnabled: bootProjectDeps.config.memory.enabled,
-      retinaHandoff: bootProjectDeps.config.smart_notes.retina_handoff,
-      mural: bootProjectDeps.config.mural,
-      language: bootProjectDeps.config.language,
-      gitCommitIndexing: bootProjectDeps.config.memory.git_commit_indexing,
-      onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
-    });
+    syncDreamerProjectRegistration(bootProjectDeps);
     info(`registered dreamer (${summarizeDreamSchedule(dreamerConfig)})`);
   } else {
     info(bootProjectDeps.dreamerEnabled ? "registered dreamer: DISABLED (no dreamer config)" : "registered dreamer: DISABLED (dreamer.disable=true or no dreamer config)");
@@ -30250,33 +31149,10 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         projectIdentity: effectiveProjectDeps.projectIdentity
       };
       const effectiveConfig = effectiveProjectDeps.config;
-      seenDreamerProjectIdentities.add(currentProject.projectIdentity);
-      const effectiveDreamerConfig = effectiveProjectDeps.dreamerConfig;
-      if (effectiveDreamerConfig) {
-        try {
-          registerPiDreamerProject({
-            db,
-            projectDir: currentProject.projectDir,
-            projectIdentity: currentProject.projectIdentity,
-            config: effectiveDreamerConfig,
-            embeddingConfig: effectiveConfig.embedding,
-            memoryEnabled: effectiveConfig.memory.enabled,
-            retinaHandoff: effectiveConfig.smart_notes.retina_handoff,
-            language: effectiveConfig.language,
-            gitCommitIndexing: effectiveConfig.memory.git_commit_indexing,
-            onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
-          });
-        } catch (err) {
-          warn("before_agent_start: registerPiDreamerProject threw:", err);
-        }
-      } else {
-        try {
-          unregisterPiDreamerProject({
-            projectIdentity: currentProject.projectIdentity
-          });
-        } catch (err) {
-          warn("before_agent_start: unregisterPiDreamerProject threw:", err);
-        }
+      try {
+        syncDreamerProjectRegistration(effectiveProjectDeps);
+      } catch (err) {
+        warn("before_agent_start: dreamer registration sync threw:", err);
       }
       const sm = ctx.sessionManager;
       let sessionId;
@@ -30538,39 +31414,47 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     }
   });
   pi.on("session_shutdown", async (_event, ctx) => {
+    sessionShuttingDown = true;
+    commandLifecycleController.abort();
     const SHUTDOWN_DRAIN_MS = 5000;
+    const sessionId = resolveSessionId(ctx);
     try {
-      await withTimeout(awaitInFlightHistorians(), SHUTDOWN_DRAIN_MS);
+      for (const identity of seenDreamerProjectIdentities) {
+        unregisterPiDreamerProject({
+          projectIdentity: identity,
+          registrationOwner: dreamerRegistrationOwner
+        });
+      }
     } catch (err) {
-      warn("shutdown: historian drain threw:", err);
+      warn("shutdown: unregisterPiDreamerProject threw:", err);
     }
-    try {
-      await withTimeout(awaitInFlightRecomps(), SHUTDOWN_DRAIN_MS);
-    } catch (err) {
-      warn("shutdown: recomp drain threw:", err);
+    if (sessionId) {
+      try {
+        await withTimeout(awaitInFlightHistorians(sessionId), SHUTDOWN_DRAIN_MS);
+      } catch (err) {
+        warn("shutdown: historian drain threw:", err);
+      }
+      try {
+        await withTimeout(awaitInFlightRecomps(sessionId), SHUTDOWN_DRAIN_MS);
+      } catch (err) {
+        warn("shutdown: recomp drain threw:", err);
+      }
+      abortInFlightRecomps(sessionId);
     }
     try {
-      await withTimeout(awaitInFlightDreamers(), SHUTDOWN_DRAIN_MS);
+      await withTimeout(awaitInFlightDreamers(dreamerRegistrationOwner), SHUTDOWN_DRAIN_MS);
     } catch (err) {
       warn("shutdown: dreamer drain threw:", err);
     }
-    try {
-      for (const identity of seenDreamerProjectIdentities) {
-        unregisterPiDreamerProject({ projectIdentity: identity });
-      }
-    } catch (err) {
-      warn("shutdown: unregisterPiDreamerProject threw:", err);
-    }
     try {
       const sm = ctx.sessionManager;
-      const sessionId = typeof sm?.getSessionId === "function" ? sm.getSessionId() : undefined;
-      if (typeof sessionId === "string" && sessionId.length > 0) {
-        clearPiSystemPromptSession(sessionId);
-        promptSurfaceGuidanceEpochs.clear(sessionId);
-        clearContextHandlerSession(sessionId);
+      const sessionId2 = typeof sm?.getSessionId === "function" ? sm.getSessionId() : undefined;
+      if (typeof sessionId2 === "string" && sessionId2.length > 0) {
+        clearPiSystemPromptSession(sessionId2);
+        promptSurfaceGuidanceEpochs.clear(sessionId2);
+        clearContextHandlerSession(sessionId2);
       }
     } catch {}
-    clearPiMagicContextActive();
   });
   pi.on("session_before_switch", (_event, ctx) => {
     try {
@@ -30584,6 +31468,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     } catch {}
   });
 }
+function registerPiSubagentInitContextCleanup(pi, unsubscribe) {
+  pi.on("session_shutdown", unsubscribe);
+}
 function formatExecuteThresholdForLog(value) {
   if (value === undefined)
     return "65%";