@cortexkit/pi-magic-context 0.31.2 → 0.31.3

package/dist/index.js

@@ -155029,6 +155029,13 @@ function setSessionWorkMetrics(db, sessionId, newWorkTokens, totalInputTokens) {
          SET new_work_tokens = ?, total_input_tokens = ?
          WHERE session_id = ?`).run(Math.max(0, Math.floor(newWorkTokens)), Math.max(0, Math.floor(totalInputTokens)), sessionId);
 }
+function getSessionWorkMetrics(db, sessionId) {
+  const row = db.prepare("SELECT new_work_tokens, total_input_tokens FROM session_meta WHERE session_id = ?").get(sessionId);
+  return {
+    newWorkTokens: typeof row?.new_work_tokens === "number" ? row.new_work_tokens : 0,
+    totalInputTokens: typeof row?.total_input_tokens === "number" ? row.total_input_tokens : 0
+  };
+}
 // ../plugin/src/features/magic-context/storage-meta-session.ts
 import { Buffer as Buffer3 } from "node:buffer";
 
@@ -157979,7 +157986,8 @@ function registerCtxAugCommand(pi, config) {
       const branch = ctx.sessionManager.getBranch();
       const lastEntryId = branch.length > 0 ? branch[branch.length - 1]?.id : "unknown";
       const sessionLabel = `pi-session-${lastEntryId}`;
-      if (!config) {
+      const currentConfig = typeof config === "function" ? config(ctx) : config;
+      if (!currentConfig) {
         ctx.ui.notify("/ctx-aug: Sidekick is not configured. Add `sidekick.model` to your magic-context.jsonc to enable this command.", "warning");
         return;
       }
@@ -157991,20 +157999,20 @@ function registerCtxAugCommand(pi, config) {
         ctx.ui.notify("\uD83D\uDD0D Preparing augmentation… 2-10s depending on your sidekick provider.", "info");
       }
       sessionLog(sessionLabel, "/ctx-aug: spawning sidekick", {
-        model: config.model
+        model: currentConfig.model
       });
       const projectIdentity = resolveProjectIdentity(ctx.cwd);
       sessionLog(sessionLabel, "/ctx-aug: project identity", projectIdentity);
       const result = await runner.run({
         agent: "sidekick",
-        systemPrompt: withContentLanguageDirective(config.systemPrompt ?? SIDEKICK_SYSTEM_PROMPT, config.language),
+        systemPrompt: withContentLanguageDirective(currentConfig.systemPrompt ?? SIDEKICK_SYSTEM_PROMPT, currentConfig.language),
         userMessage: prompt,
-        model: config.model,
-        fallbackModels: config.fallbackModels,
-        timeoutMs: config.timeoutMs ?? 30000,
+        model: currentConfig.model,
+        fallbackModels: currentConfig.fallbackModels,
+        timeoutMs: currentConfig.timeoutMs ?? 30000,
         cwd: ctx.cwd,
         signal: ctx.signal,
-        thinkingLevel: config.thinking_level,
+        thinkingLevel: currentConfig.thinking_level,
         accountingSessionId: sessionLabel,
         accountingSubagent: "sidekick"
       });
@@ -173234,6 +173242,10 @@ var MagicContextConfigSchema = exports_external.object({
   }).describe("Embedding provider configuration"),
   temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add start/end date attributes on compartments. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
   keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
+  todowrite: exports_external.object({
+    enabled: exports_external.boolean().default(true).describe("Pi only: register Magic Context's todowrite task-list tool. Disable if you use your own todo extension. OpenCode ships its own built-in todowrite; this setting has no effect there."),
+    overlay: exports_external.boolean().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
+  }).default({ enabled: true, overlay: true }).describe("Pi-only todowrite tool and overlay controls. Pi registers tools and widgets at extension boot, so changing this after /cd requires /reload or restart."),
   smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 5), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
   caveman_text_compression: exports_external.object({
     enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
@@ -176773,9 +176785,11 @@ import path7 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var GIT_TIMEOUT_MS2 = 1e4;
+var defaultExecFileForVerificationPaths = async (file2, args, options) => await execFileAsync(file2, [...args], options);
+var execFileForVerificationPaths = defaultExecFileForVerificationPaths;
 async function runGit(cwd, args) {
   try {
-    const result = await execFileAsync("git", [...args], {
+    const result = await execFileForVerificationPaths("git", args, {
       cwd,
       timeout: GIT_TIMEOUT_MS2,
       maxBuffer: 16 * 1024 * 1024,
@@ -184714,6 +184728,7 @@ function registerCtxDreamCommand(pi, deps) {
         projectDir: deps.projectDir,
         projectIdentity: deps.projectIdentity
       };
+      const dreamerEnabled = deps.resolveDreamerEnabled?.(ctx) ?? deps.dreamerEnabled;
       deps.onProjectSeen?.(project.projectIdentity);
       const requested = typeof args === "string" ? args.trim() : String(args ?? "").trim();
       let task;
@@ -184733,7 +184748,7 @@ Unknown task "${requested}".`,
         }
         task = requested;
       }
-      if (deps.dreamerEnabled === false) {
+      if (dreamerEnabled === false) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-dream",
           text: "## /ctx-dream\n\nDreamer is disabled for this project (`dreamer.disable=true`).",
@@ -184848,6 +184863,8 @@ function formatEmbedStatusText(coverage, drain) {
 }
 
 // src/commands/ctx-embed.ts
+var EMBED_PROGRESS_COMPARTMENT_STEP = 8;
+var EMBED_PROGRESS_MIN_INTERVAL_MS = 1e4;
 function clearPiEmbedSessionState(sessionId) {
   embedPauseBySession.delete(sessionId);
   const ctrl = embedRunStateBySession.get(sessionId);
@@ -184857,7 +184874,7 @@ function clearPiEmbedSessionState(sessionId) {
   }
   autoEmbedAttemptedBySession.delete(sessionId);
 }
-async function runEmbedDrain(db, projectIdentity, sessionId) {
+async function runEmbedDrain(db, projectIdentity, sessionId, options = {}) {
   const activeCtrl = embedRunStateBySession.get(sessionId);
   if (activeCtrl && !activeCtrl.signal.aborted) {
     return {
@@ -184873,10 +184890,46 @@ Embedding is already running for this session.`,
     prior.abort();
   const controller = new AbortController;
   embedRunStateBySession.set(sessionId, controller);
+  const now = options.now ?? Date.now;
+  let startEmitted = false;
+  let lastProgressEmbedded = 0;
+  let lastProgressAt = 0;
+  const emitProgress = (progress) => {
+    if (progress.total <= 0)
+      return;
+    if (!startEmitted) {
+      startEmitted = true;
+      lastProgressAt = now();
+      options.onStatus?.({
+        text: `## /ctx-embed
+
+Embedding ${progress.total} compartment${progress.total === 1 ? "" : "s"} of history…`,
+        level: "info"
+      });
+      return;
+    }
+    if (progress.embedded <= 0 || progress.embedded >= progress.total)
+      return;
+    const currentTime = now();
+    const enoughCompartments = progress.embedded - lastProgressEmbedded >= EMBED_PROGRESS_COMPARTMENT_STEP;
+    const enoughTime = currentTime - lastProgressAt >= EMBED_PROGRESS_MIN_INTERVAL_MS && progress.embedded > lastProgressEmbedded;
+    if (!enoughCompartments && !enoughTime)
+      return;
+    lastProgressEmbedded = progress.embedded;
+    lastProgressAt = currentTime;
+    options.onStatus?.({
+      text: `## /ctx-embed
+
+Embedded ${progress.embedded}/${progress.total} compartments so far…`,
+      level: "info"
+    });
+  };
   let outcome;
   try {
     outcome = await embedSessionCompartmentChunks(db, projectIdentity, sessionId, {
-      signal: controller.signal
+      signal: controller.signal,
+      onProgress: emitProgress,
+      ...options.batchSize !== undefined ? { batchSize: options.batchSize } : {}
     });
   } finally {
     if (embedRunStateBySession.get(sessionId) === controller) {
@@ -184949,6 +185002,7 @@ No active Pi session is available.`,
         projectDir: deps.projectDir,
         projectIdentity: deps.projectIdentity
       };
+      const memoryEnabled = deps.resolveMemoryEnabled?.(ctx) ?? deps.memoryEnabled;
       const sub = args.trim().toLowerCase();
       if (sub === "pause") {
         embedPauseBySession.add(sessionId);
@@ -184965,7 +185019,7 @@ Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
         });
         return;
       }
-      if (deps.memoryEnabled === false) {
+      if (memoryEnabled === false) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-embed",
           text: `## /ctx-embed
@@ -184977,7 +185031,12 @@ 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);
+        const { text, level } = await runEmbedDrain(deps.db, project.projectIdentity, sessionId, {
+          onStatus: (status) => sendCtxStatusMessage(pi, {
+            title: "/ctx-embed",
+            ...status
+          })
+        });
         sendCtxStatusMessage(pi, { title: "/ctx-embed", text, level });
         return;
       }
@@ -188010,6 +188069,11 @@ function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions
 `);
 }
 
+// ../plugin/src/hooks/magic-context/sentinel.ts
+function modelAcceptsEmptyContent(providerID) {
+  return providerID === "anthropic";
+}
+
 // ../plugin/src/hooks/magic-context/supersession-reclaim.ts
 var TODOWRITE_KEEP = 1;
 var CTX_REDUCE_KEEP = 5;
@@ -190510,8 +190574,8 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
       sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
     }
   }
-  const staleReduce = collectStaleReduceCallIds(piMessages, buildMessageIdToMaxTagFromTargets(targets), toolAgeCutoff, resolveStableId);
-  if (staleReduce.composite.size > 0 || staleReduce.bareCallIds.size > 0) {
+  const staleReduce = config2.staleReduceStripEnabled ? collectStaleReduceCallIds(piMessages, buildMessageIdToMaxTagFromTargets(targets), toolAgeCutoff, resolveStableId) : { composite: new Set, bareCallIds: new Set };
+  if (config2.staleReduceStripEnabled && (staleReduce.composite.size > 0 || staleReduce.bareCallIds.size > 0)) {
     db.transaction(() => {
       for (const tag of tags) {
         if (tag.status !== "active")
@@ -194792,8 +194856,122 @@ function buildReferenceBlocks(args) {
 init_logger();
 var HISTORIAN_AGENT_NAME = "magic-context-historian";
 var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 120000;
+var MAX_HISTORIAN_RETRIES = 2;
 var HISTORIAN_ALERT_COOLDOWN_MS = 60 * 1000;
 var lastHistorianAlertBySession = new Map;
+function getHistorianRetryBackoffMs(retryIndex) {
+  if (retryIndex === 0) {
+    return 2000 + Math.floor(Math.random() * 1001);
+  }
+  return 6000 + Math.floor(Math.random() * 2001);
+}
+function isTransientHistorianPromptError(message) {
+  const normalized = message.toLowerCase();
+  if (normalized.includes("invalid request") || normalized.includes("bad request") || normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("authentication") || normalized.includes("auth") || normalized.includes(" 400") || normalized.startsWith("400")) {
+    return false;
+  }
+  return [
+    "429",
+    "rate limit",
+    "timeout",
+    "econnreset",
+    "etimedout",
+    "503",
+    "502",
+    "500",
+    "overloaded"
+  ].some((token) => normalized.includes(token));
+}
+function isTransientHistorianRunFailure(result) {
+  if (result.reason === "abort")
+    return false;
+  if (result.reason === "timeout")
+    return true;
+  return isTransientHistorianPromptError(result.error);
+}
+function historianAbortResult(startedAt) {
+  return {
+    ok: false,
+    reason: "abort",
+    error: "pi subagent aborted by caller",
+    durationMs: Date.now() - startedAt
+  };
+}
+async function sleepWithAbort(ms, signal) {
+  if (signal?.aborted)
+    return true;
+  if (ms <= 0)
+    return signal?.aborted === true;
+  return new Promise((resolve3) => {
+    let settled = false;
+    let timeout;
+    const finish = (aborted2) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timeout)
+        clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve3(aborted2);
+    };
+    const onAbort = () => finish(true);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timeout = setTimeout(() => finish(false), ms);
+  });
+}
+async function runHistorianSubagentWithTransientRetries(args) {
+  const startedAt = Date.now();
+  if (args.options.signal?.aborted)
+    return historianAbortResult(startedAt);
+  for (let retryIndex = 0;retryIndex <= MAX_HISTORIAN_RETRIES; retryIndex += 1) {
+    const attemptStart = Date.now();
+    let result;
+    try {
+      result = await args.runner.run({
+        ...args.options,
+        fallbackModels: undefined
+      });
+    } catch (error51) {
+      const desc = describeError(error51);
+      result = {
+        ok: false,
+        reason: "model_failed",
+        error: desc.brief,
+        durationMs: Date.now() - attemptStart
+      };
+    }
+    if (result.ok)
+      return result;
+    if (result.reason === "abort" || args.options.signal?.aborted) {
+      return result.reason === "abort" ? result : historianAbortResult(startedAt);
+    }
+    const shouldRetry = retryIndex < MAX_HISTORIAN_RETRIES && isTransientHistorianRunFailure(result);
+    if (!shouldRetry)
+      return result;
+    const backoffMs2 = args.retryBackoffMs?.(retryIndex) ?? getHistorianRetryBackoffMs(retryIndex);
+    sessionLog(args.sessionId, `historian[${args.passLabel}] transient failure; retry ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES} on same model after ${backoffMs2}ms: ${result.error}`);
+    const aborted2 = await sleepWithAbort(backoffMs2, args.options.signal);
+    if (aborted2)
+      return historianAbortResult(startedAt);
+  }
+  return historianAbortResult(startedAt);
+}
+function buildHistorianFallbackChain(primaryModel, fallbackModels, fallbackModelId) {
+  const seen = new Set;
+  if (primaryModel)
+    seen.add(primaryModel);
+  const chain = [];
+  for (const candidate of fallbackModels ?? []) {
+    if (!candidate || seen.has(candidate))
+      continue;
+    seen.add(candidate);
+    chain.push({ modelId: candidate, kind: "configured" });
+  }
+  if (fallbackModelId && !seen.has(fallbackModelId)) {
+    chain.push({ modelId: fallbackModelId, kind: "session" });
+  }
+  return chain;
+}
 function parseSourceMessageTime(value) {
   if (typeof value === "number" && Number.isFinite(value))
     return value;
@@ -194842,11 +195020,14 @@ async function runPiHistorian(deps) {
     runner,
     historianModel,
     fallbackModels,
+    fallbackModelId,
     historianChunkTokens,
     boundarySnapshot: providedBoundarySnapshot,
     refreshBoundarySnapshot,
     currentContextLimit,
     historianTimeoutMs = DEFAULT_HISTORIAN_TIMEOUT_MS2,
+    signal,
+    retryBackoffMs,
     twoPass,
     thinkingLevel,
     memoryEnabled,
@@ -194860,7 +195041,9 @@ async function runPiHistorian(deps) {
     forceDrainQuota,
     forceKeepLastCompartment
   } = deps;
+  let issueNotified = false;
   const notify = async (message) => {
+    issueNotified = true;
     if (shouldSuppressHistorianAlert(sessionId)) {
       sessionLog(sessionId, "historian alert suppressed (cooldown)");
       return;
@@ -195051,61 +195234,77 @@ ${chunkText}`,
       retainDrainReservationForRetryThrottle = true;
       const historianSystemPrompt = withContentLanguageDirective(COMPARTMENT_AGENT_SYSTEM_PROMPT, deps.language, { preserveUserQuotes: true });
       const historianEditorSystemPrompt = withContentLanguageDirective(HISTORIAN_EDITOR_SYSTEM_PROMPT, deps.language, { preserveUserQuotes: true });
-      const firstResult = await runner.run({
-        agent: HISTORIAN_AGENT_NAME,
-        systemPrompt: historianSystemPrompt,
-        userMessage: prompt,
-        model: historianModel,
-        fallbackModels,
-        timeoutMs: historianTimeoutMs,
-        cwd: directory,
-        thinkingLevel,
-        onProgress: buildProgressLogger("first"),
-        accountingSessionId: sessionId,
-        accountingSubagent: "historian"
-      });
-      let validatedPass = await validateHistorianResult(firstResult, sessionId, chunk, priorCompartments, sequenceOffset);
-      let validatedDraftText = firstResult.ok ? firstResult.assistantText : null;
-      if (validatedPass.kind === "validation-failed") {
-        sessionLog(sessionId, `historian: first pass validation failed, retrying with repair prompt: ${validatedPass.error}`);
-        const repairPrompt = buildHistorianRepairPrompt(prompt, validatedPass.rawText, validatedPass.error, deps.language);
-        const repairResult = await runner.run({
+      const firstResult = await runHistorianSubagentWithTransientRetries({
+        runner,
+        sessionId,
+        passLabel: "first",
+        retryBackoffMs,
+        options: {
           agent: HISTORIAN_AGENT_NAME,
           systemPrompt: historianSystemPrompt,
-          userMessage: repairPrompt,
+          userMessage: prompt,
           model: historianModel,
-          fallbackModels,
           timeoutMs: historianTimeoutMs,
           cwd: directory,
+          signal,
           thinkingLevel,
-          onProgress: buildProgressLogger("repair"),
+          onProgress: buildProgressLogger("first"),
           accountingSessionId: sessionId,
           accountingSubagent: "historian"
-        });
-        validatedPass = await validateHistorianResult(repairResult, sessionId, chunk, priorCompartments, sequenceOffset);
-        if (validatedPass.kind === "ok" && repairResult.ok) {
-          validatedDraftText = repairResult.assistantText;
         }
-      }
-      if (validatedPass.kind !== "ok" && (fallbackModels?.length ?? 0) > 0) {
-        const seen = new Set([historianModel].filter(Boolean));
-        for (const candidate of fallbackModels ?? []) {
-          if (!candidate || seen.has(candidate))
-            continue;
-          seen.add(candidate);
-          sessionLog(sessionId, `historian: escalating to configured fallback model ${candidate}`);
-          const fbResult = await runner.run({
+      });
+      let validatedPass = await validateHistorianResult(firstResult, sessionId, chunk, priorCompartments, sequenceOffset);
+      let validatedDraftText = firstResult.ok ? firstResult.assistantText : null;
+      if (validatedPass.kind === "validation-failed") {
+        sessionLog(sessionId, `historian: first pass validation failed, retrying with repair prompt: ${validatedPass.error}`);
+        const repairPrompt = buildHistorianRepairPrompt(prompt, validatedPass.rawText, validatedPass.error, deps.language);
+        const repairResult = await runHistorianSubagentWithTransientRetries({
+          runner,
+          sessionId,
+          passLabel: "repair",
+          retryBackoffMs,
+          options: {
             agent: HISTORIAN_AGENT_NAME,
             systemPrompt: historianSystemPrompt,
-            userMessage: prompt,
-            model: candidate,
-            fallbackModels: undefined,
+            userMessage: repairPrompt,
+            model: historianModel,
             timeoutMs: historianTimeoutMs,
             cwd: directory,
+            signal,
             thinkingLevel,
-            onProgress: buildProgressLogger("fallback"),
+            onProgress: buildProgressLogger("repair"),
             accountingSessionId: sessionId,
             accountingSubagent: "historian"
+          }
+        });
+        validatedPass = await validateHistorianResult(repairResult, sessionId, chunk, priorCompartments, sequenceOffset);
+        if (validatedPass.kind === "ok" && repairResult.ok) {
+          validatedDraftText = repairResult.assistantText;
+        }
+      }
+      const fallbackChain = buildHistorianFallbackChain(historianModel, fallbackModels, fallbackModelId);
+      if (validatedPass.kind !== "ok" && !(validatedPass.kind === "spawn-failed" && validatedPass.reason === "abort") && fallbackChain.length > 0) {
+        for (let i = 0;i < fallbackChain.length; i += 1) {
+          const candidate = fallbackChain[i];
+          sessionLog(sessionId, `historian: escalating to ${candidate.kind === "session" ? "session-model last resort" : "configured fallback model"} ${candidate.modelId}`);
+          const fbResult = await runHistorianSubagentWithTransientRetries({
+            runner,
+            sessionId,
+            passLabel: candidate.kind === "session" ? "fallback-session" : "fallback",
+            retryBackoffMs,
+            options: {
+              agent: HISTORIAN_AGENT_NAME,
+              systemPrompt: historianSystemPrompt,
+              userMessage: prompt,
+              model: candidate.modelId,
+              timeoutMs: historianTimeoutMs,
+              cwd: directory,
+              signal,
+              thinkingLevel,
+              onProgress: buildProgressLogger("fallback"),
+              accountingSessionId: sessionId,
+              accountingSubagent: "historian"
+            }
           });
           const fbPass = await validateHistorianResult(fbResult, sessionId, chunk, priorCompartments, sequenceOffset);
           if (fbPass.kind === "ok") {
@@ -195114,6 +195313,10 @@ ${chunkText}`,
               validatedDraftText = fbResult.assistantText;
             break;
           }
+          if (fbPass.kind === "spawn-failed" && fbPass.reason === "abort") {
+            validatedPass = fbPass;
+            break;
+          }
         }
       }
       if (validatedPass.kind !== "ok") {
@@ -195130,17 +195333,24 @@ ${chunkText}`,
         const draftAssistantText = validatedDraftText ?? "";
         if (draftAssistantText.trim().length > 0) {
           sessionLog(sessionId, "historian two-pass: running editor on draft");
-          const editorResult = await runner.run({
-            agent: HISTORIAN_AGENT_NAME,
-            systemPrompt: historianEditorSystemPrompt,
-            userMessage: buildHistorianEditorPrompt(draftAssistantText),
-            model: historianModel,
-            timeoutMs: historianTimeoutMs,
-            cwd: directory,
-            thinkingLevel,
-            onProgress: buildProgressLogger("editor"),
-            accountingSessionId: sessionId,
-            accountingSubagent: "historian_editor"
+          const editorResult = await runHistorianSubagentWithTransientRetries({
+            runner,
+            sessionId,
+            passLabel: "editor",
+            retryBackoffMs,
+            options: {
+              agent: HISTORIAN_AGENT_NAME,
+              systemPrompt: historianEditorSystemPrompt,
+              userMessage: buildHistorianEditorPrompt(draftAssistantText),
+              model: historianModel,
+              timeoutMs: historianTimeoutMs,
+              cwd: directory,
+              signal,
+              thinkingLevel,
+              onProgress: buildProgressLogger("editor"),
+              accountingSessionId: sessionId,
+              accountingSubagent: "historian_editor"
+            }
           });
           const editorPass = await validateHistorianResult(editorResult, sessionId, chunk, priorCompartments, sequenceOffset);
           if (editorPass.kind === "ok") {
@@ -195353,7 +195563,7 @@ ${chunkText}`,
     const desc = describeError(error51);
     telemetry.failureReason = `exception: ${desc.brief}`;
     sessionLog(sessionId, `historian failure: source=exception ${desc.brief}${desc.stackHead ? ` stackHead="${desc.stackHead}"` : ""}`);
-    {
+    if (!issueNotified) {
       const failCount = incrementHistorianFailure(db, sessionId, desc.brief);
       await notify(buildHistorianFailureNotice(failCount, desc.brief));
     }
@@ -197302,6 +197512,8 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       const sessionMeta = sessionMetaForUsage;
       const modelKey = liveModelBySession.get(sessionId);
+      const providerId = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
+      const canUseEmptySentinels = modelAcceptsEmptyContent(providerId);
       if (usageContextLimit === undefined) {
         const modelWindow = ctx.model?.contextWindow;
         if (isSaneLimit(modelWindow)) {
@@ -197312,6 +197524,7 @@ function registerPiContextHandler(pi, baseOptions) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
       ({ percentage: usagePercentage, inputTokens: usageInputTokens } = applyForwardPressureFloor(usagePercentage, usageInputTokens, piUsage?.tokens, usageContextLimit));
+      const realUsagePercentageBeforeEmergencyBump = usagePercentage;
       if (needsEmergencyBump) {
         sessionLog(sessionId, `transform: overflow recovery flag set — bumping percentage to 95% (detectedLimit=${usageContextLimit ?? "unknown"})`);
         usagePercentage = Math.max(usagePercentage, 95);
@@ -197382,7 +197595,7 @@ function registerPiContextHandler(pi, baseOptions) {
             sessionLog(sessionId, "EMERGENCY: historian wait completed (or timed out)");
           } catch {}
         }
-        if (emergencyRecoveryArmed && !inFlightHistorian.has(sessionId) && !hasEligiblePiCompartmentHistory(options.db, sessionId)) {
+        if (emergencyRecoveryArmed && realUsagePercentageBeforeEmergencyBump < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && !hasEligiblePiCompartmentHistory(options.db, sessionId)) {
           try {
             clearEmergencyRecovery(options.db, sessionId);
             sessionLog(sessionId, "EMERGENCY: disarming recovery — no eligible pre-tail history to compact (would otherwise loop at 95%)");
@@ -197437,6 +197650,7 @@ function registerPiContextHandler(pi, baseOptions) {
         reasoningClearing: {
           clearReasoningAge: options.heuristics?.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE
         },
+        canUseEmptySentinels,
         temporalAwareness: options.injection?.temporalAwareness === true,
         appendCompaction: resolvePiAppendCompaction(ctx),
         readBranchEntries: resolvePiReadBranchEntries(ctx),
@@ -197458,6 +197672,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       if (options.historian) {
         maybeFireHistorian({
+          pi,
           ctx,
           sessionId,
           db: options.db,
@@ -197698,6 +197913,7 @@ function sendPiIgnoredNotification(ctx, message) {
 }
 function spawnPiHistorianRun(args) {
   const {
+    pi,
     ctx,
     sessionId,
     db,
@@ -197706,7 +197922,8 @@ function spawnPiHistorianRun(args) {
     unregister,
     boundarySnapshot,
     refreshBoundarySnapshot,
-    currentContextLimit
+    currentContextLimit,
+    fallbackModelId
   } = args;
   const holderId = crypto3.randomUUID();
   const runPromise = (async () => {
@@ -197732,6 +197949,7 @@ function spawnPiHistorianRun(args) {
         runner: historian.runner,
         historianModel: historian.model,
         fallbackModels: historian.fallbackModels,
+        fallbackModelId,
         historianChunkTokens: historian.historianChunkTokens,
         boundarySnapshot,
         refreshBoundarySnapshot,
@@ -197744,6 +197962,17 @@ function spawnPiHistorianRun(args) {
         userMemoriesEnabled: historian.userMemoriesEnabled,
         language: historian.language,
         compartmentLeaseHolderId: holderId,
+        notifyIssue: (text) => {
+          if (!isContextHandlerSessionActive(sessionId)) {
+            sessionLog(sessionId, "historian failure notice skipped after session context cleared");
+            return;
+          }
+          sendCtxStatusMessage(pi, {
+            title: "Magic Context",
+            text,
+            level: "warning"
+          });
+        },
         onPublished: () => {
           const sessionStillActive = isContextHandlerSessionActive(sessionId);
           try {
@@ -197893,6 +198122,7 @@ function maybeFireHistorian(args) {
 
 Historian previously failed ${failureState.failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`);
         spawnPiHistorianRun({
+          pi: args.pi,
           ctx,
           sessionId,
           db,
@@ -197901,7 +198131,8 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
           unregister,
           boundarySnapshot,
           refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
-          currentContextLimit: boundaryContextLimit
+          currentContextLimit: boundaryContextLimit,
+          fallbackModelId: modelKey
         });
         return;
       }
@@ -197923,6 +198154,7 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
     triggered = true;
     sessionLog(sessionId, `historian trigger fired (reason=${trigger.reason ?? "unknown"}) usage=${usage.percentage.toFixed(1)}% — spawning subagent`);
     spawnPiHistorianRun({
+      pi: args.pi,
       ctx,
       sessionId,
       db,
@@ -197934,7 +198166,8 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
         triggerBoundarySnapshot: trigger.boundarySnapshot
       }),
       refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
-      currentContextLimit: boundaryContextLimit
+      currentContextLimit: boundaryContextLimit,
+      fallbackModelId: modelKey
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -198014,7 +198247,10 @@ async function runPipeline(args) {
     historyBudgetTokens: args.injection.historyBudgetTokens,
     hardSignals: piHardSignals
   }, args.db, getCompartments(args.db, args.sessionId)).value : false;
-  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || hasPendingMaterialization(args.sessionId) || deferredMaterializeEligible || m0HardFoldThisPass || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
+  const historianRunning = inFlightHistorian.has(args.sessionId);
+  const bypassHistorianGate = args.forceMaterialization === true || m0HardFoldThisPass;
+  const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
+  const shouldRunHeuristics = args.heuristics !== undefined && (!historianRunning || bypassHistorianGate) && (args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || m0HardFoldThisPass || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver);
   adoptPiFallbackTags(args.db, args.sessionId, args.tagger, entryFingerprintByMessageId, {
     messages: args.messages,
@@ -198048,14 +198284,13 @@ async function runPipeline(args) {
   } catch (err) {
     sessionLog(args.sessionId, `commit-detect failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
   }
-  const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const pendingOps = getPendingOps(args.db, args.sessionId);
   const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || m0HardFoldThisPass;
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
-  const shouldApplyPendingOps = baseShouldApplyPendingOps || deferredMaterialize;
+  const shouldApplyPendingOps = (baseShouldApplyPendingOps || deferredMaterialize) && (!historianRunning || bypassHistorianGate);
   if (shouldApplyPendingOps) {
     const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : m0HardFoldThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into known 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)}%`);
@@ -198144,6 +198379,7 @@ async function runPipeline(args) {
       const tHeuristic = performance.now();
       heuristicsResult = applyPiHeuristicCleanup(args.sessionId, args.db, targets, args.messages, {
         protectedTags: args.protectedTags,
+        staleReduceStripEnabled: args.canUseEmptySentinels,
         emergency: args.forceMaterialization === true && args.emergencyCeilingTokens !== undefined && args.emergencyCeilingTokens > 0 ? {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens
@@ -198729,7 +198965,7 @@ init_data_path();
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
 }
-var MAX_HISTORIAN_RETRIES = 2;
+var MAX_HISTORIAN_RETRIES2 = 2;
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -198870,7 +199106,7 @@ async function runHistorianPrompt(args) {
       });
       return { ok: false, error: "Historian could not create its child session." };
     }
-    for (let retryIndex = 0;retryIndex <= MAX_HISTORIAN_RETRIES; retryIndex += 1) {
+    for (let retryIndex = 0;retryIndex <= MAX_HISTORIAN_RETRIES2; retryIndex += 1) {
       try {
         await promptSyncWithModelSuggestionRetry(client, {
           path: { id: agentSessionId },
@@ -198885,17 +199121,17 @@ async function runHistorianPrompt(args) {
           fallbackModels: modelOverride ? undefined : fallbackModels,
           callContext: agentId === HISTORIAN_EDITOR_AGENT ? "historian:editor" : "historian"
         });
-        sessionLog(parentSessionId, `historian: prompt completed (attempt ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES + 1})`);
+        sessionLog(parentSessionId, `historian: prompt completed (attempt ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES2 + 1})`);
         break;
       } catch (error51) {
         const errorMsg = getErrorMessage(error51);
         sessionLog(parentSessionId, `historian: prompt attempt ${retryIndex + 1} failed: ${errorMsg}`);
-        const shouldRetry = retryIndex < MAX_HISTORIAN_RETRIES && isTransientHistorianPromptError(errorMsg);
+        const shouldRetry = retryIndex < MAX_HISTORIAN_RETRIES2 && isTransientHistorianPromptError2(errorMsg);
         if (!shouldRetry) {
           throw error51;
         }
-        const backoffMs2 = getHistorianRetryBackoffMs(retryIndex);
-        sessionLog(parentSessionId, `historian retry ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES} after ${backoffMs2}ms: ${errorMsg}`);
+        const backoffMs2 = getHistorianRetryBackoffMs2(retryIndex);
+        sessionLog(parentSessionId, `historian retry ${retryIndex + 1}/${MAX_HISTORIAN_RETRIES2} after ${backoffMs2}ms: ${errorMsg}`);
         await sleep(backoffMs2);
       }
     }
@@ -198988,13 +199224,13 @@ function parseModelOverride(modelId) {
   }
   return { providerID, modelID };
 }
-function getHistorianRetryBackoffMs(retryIndex) {
+function getHistorianRetryBackoffMs2(retryIndex) {
   if (retryIndex === 0) {
     return 2000 + Math.floor(Math.random() * 1001);
   }
   return 6000 + Math.floor(Math.random() * 2001);
 }
-function isTransientHistorianPromptError(message) {
+function isTransientHistorianPromptError2(message) {
   const normalized = message.toLowerCase();
   if (normalized.includes("invalid request") || normalized.includes("bad request") || normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("authentication") || normalized.includes("auth") || normalized.includes(" 400") || normalized.startsWith("400")) {
     return false;
@@ -200238,6 +200474,13 @@ function spawnPiRecompRun(args) {
 // src/commands/ctx-recomp.ts
 var confirmationBySession = new Map;
 var RECOMP_CONFIRMATION_WINDOW_MS = 60000;
+var RECOMP_USAGE = [
+  "Usage:",
+  "- `/ctx-recomp` — full rebuild from message 1 to the protected tail",
+  "- `/ctx-recomp <start>-<end>` — partial rebuild of a message range (e.g. `/ctx-recomp 1-11322`)",
+  "- `/ctx-recomp --upgrade` — upgrade legacy v1 compartments to v2 layout (Wave 3 runner)"
+].join(`
+`);
 function registerCtxRecompCommand(pi, deps) {
   pi.registerCommand("ctx-recomp", {
     description: "Rebuild Magic Context compartments from raw Pi session history",
@@ -200253,21 +200496,30 @@ No active Pi session is available.`,
         });
         return;
       }
-      if (!deps.historianModel) {
+      const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      const parsed = parseRecompArgs(args);
+      if (parsed.kind === "error") {
         sendCtxStatusMessage(pi, {
           title: "/ctx-recomp",
-          text: "## Magic Recomp\n\n/ctx-recomp is unavailable because `historian.model` is not configured.",
+          text: `## Magic Recomp — Invalid Arguments
+
+${parsed.message}`,
           level: "error"
         });
         return;
       }
-      const parsed = parseRecompArgs(args);
-      if (parsed.kind === "error") {
+      if (parsed.kind === "upgrade") {
         sendCtxStatusMessage(pi, {
           title: "/ctx-recomp",
-          text: `## Magic Recomp — Invalid Arguments
-
-${parsed.message}`,
+          text: executeRecompUpgradeStub(currentDeps.db, sessionId),
+          level: "info"
+        });
+        return;
+      }
+      if (!currentDeps.historianModel) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-recomp",
+          text: "## Magic Recomp\n\n/ctx-recomp is unavailable because `historian.model` is not configured.",
           level: "error"
         });
         return;
@@ -200277,7 +200529,7 @@ ${parsed.message}`,
       const confirmation = confirmationBySession.get(sessionId);
       const confirmed = confirmation !== undefined && now - confirmation.timestamp < RECOMP_CONFIRMATION_WINDOW_MS && confirmation.argsKey === argsKey;
       if (!confirmed) {
-        const warning = buildConfirmationWarning(deps.db, sessionId, parsed);
+        const warning = buildConfirmationWarning(currentDeps.db, sessionId, parsed);
         if (!warning.confirmable)
           confirmationBySession.delete(sessionId);
         else
@@ -200289,7 +200541,7 @@ ${parsed.message}`,
         });
         return;
       }
-      if (isWrapupInProgress(deps.db, sessionId)) {
+      if (isWrapupInProgress(currentDeps.db, sessionId)) {
         sendCtxStatusMessage(pi, {
           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.",
@@ -200323,16 +200575,19 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
       spawnPiRecompRun({
         sessionId,
         provider: provider2,
-        onStatusChange: () => updateStatusLine(ctx, { db: deps.db, projectIdentity: ctx.cwd }),
+        onStatusChange: () => updateStatusLine(ctx, {
+          db: currentDeps.db,
+          projectIdentity: ctx.cwd
+        }),
         work: async () => {
           const result = await executeContextRecompWithResult({
             client: createPiHistorianClient({
-              runner: deps.runner,
-              model: deps.historianModel,
-              systemPrompt: withContentLanguageDirective(COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, deps.language, { preserveUserQuotes: true }),
-              fallbackModels: deps.historianFallbacks,
-              timeoutMs: deps.historianTimeoutMs,
-              thinkingLevel: deps.historianThinkingLevel,
+              runner: currentDeps.runner,
+              model: currentDeps.historianModel,
+              systemPrompt: withContentLanguageDirective(COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, currentDeps.language, { preserveUserQuotes: true }),
+              fallbackModels: currentDeps.historianFallbacks,
+              timeoutMs: currentDeps.historianTimeoutMs,
+              thinkingLevel: currentDeps.historianThinkingLevel,
               directory: ctx.cwd,
               accountingSessionId: sessionId,
               notify: (text) => {
@@ -200343,26 +200598,26 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
                 });
               }
             }),
-            db: deps.db,
+            db: currentDeps.db,
             sessionId,
-            historianChunkTokens: deps.historianChunkTokens,
+            historianChunkTokens: currentDeps.historianChunkTokens,
             directory: ctx.cwd,
-            historianTimeoutMs: deps.historianTimeoutMs,
-            memoryEnabled: deps.memoryEnabled,
-            autoPromote: deps.autoPromote,
+            historianTimeoutMs: currentDeps.historianTimeoutMs,
+            memoryEnabled: currentDeps.memoryEnabled,
+            autoPromote: currentDeps.autoPromote,
             ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
-            fallbackModels: deps.historianFallbacks,
-            language: deps.language,
+            fallbackModels: currentDeps.historianFallbacks,
+            language: currentDeps.language,
             fallbackModelId: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined
           }, parsed.kind === "partial" ? { range: parsed.range } : {});
           if (result.published) {
             try {
-              clearEmergencyRecovery(deps.db, sessionId);
+              clearEmergencyRecovery(currentDeps.db, sessionId);
             } catch (recoveryError) {
               sessionLog(sessionId, `/ctx-recomp: clearEmergencyRecovery failed (continuing): ${describeError(recoveryError).brief}`);
             }
             try {
-              stagePiRecompMarker({ db: deps.db, sessionId, ctx });
+              stagePiRecompMarker({ db: currentDeps.db, sessionId, ctx });
             } catch (markerError) {
               sessionLog(sessionId, `/ctx-recomp: marker staging failed (recomp already published; continuing): ${describeError(markerError).brief}`);
             }
@@ -200383,11 +200638,15 @@ function parseRecompArgs(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0)
     return { kind: "full" };
+  if (trimmed === "--upgrade")
+    return { kind: "upgrade" };
   const match = trimmed.match(/^(\d+)\s*-\s*(\d+)$/);
   if (!match) {
     return {
       kind: "error",
-      message: "Usage:\n- `/ctx-recomp` — full rebuild from message 1 to the protected tail\n- `/ctx-recomp <start>-<end>` — partial rebuild of a message range"
+      message: `Invalid /ctx-recomp arguments: \`${trimmed}\`.
+
+${RECOMP_USAGE}`
     };
   }
   const start = Number.parseInt(match[1], 10);
@@ -200401,6 +200660,21 @@ function parseRecompArgs(raw) {
     };
   return { kind: "partial", range: { start, end } };
 }
+function executeRecompUpgradeStub(db, sessionId) {
+  const legacyCount = getCompartments(db, sessionId).filter((compartment) => compartment.legacy === 1).length;
+  if (legacyCount === 0) {
+    return `## Magic Recomp Upgrade
+
+Nothing to upgrade: this session has no legacy compartments.`;
+  }
+  return [
+    "## Magic Recomp Upgrade",
+    "",
+    `Found ${legacyCount} legacy compartment${legacyCount === 1 ? "" : "s"} for this session.`,
+    "The `--upgrade` flag is deprecated. Run `/ctx-session-upgrade` to upgrade this session."
+  ].join(`
+`);
+}
 function buildConfirmationWarning(db, sessionId, parsed) {
   const compartments = getCompartments(db, sessionId);
   if (parsed.kind === "partial") {
@@ -200680,7 +200954,8 @@ No active Pi session is available.`,
         });
         return;
       }
-      if (!deps.historianModel) {
+      const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      if (!currentDeps.historianModel) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-session-upgrade",
           text: "## Session Upgrade\n\nUnavailable because `historian.model` is not configured.",
@@ -200688,7 +200963,7 @@ No active Pi session is available.`,
         });
         return;
       }
-      if (isWrapupInProgress(deps.db, sessionId)) {
+      if (isWrapupInProgress(currentDeps.db, sessionId)) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-session-upgrade",
           text: `## Session Upgrade
@@ -200708,27 +200983,27 @@ An upgrade or recomp is already running for this session in the background. Wait
         });
         return;
       }
-      const compartments = getCompartments(deps.db, sessionId);
+      const compartments = getCompartments(currentDeps.db, sessionId);
       const upgradableCount = compartments.filter((c) => c.legacy === 1 || !c.p1 || c.p1.trim() === "").length;
       const sessionMainModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
-      const migrationEnabled = deps.memoryEnabled;
+      const migrationEnabled = currentDeps.memoryEnabled;
       const runMigration = async () => {
         if (!migrationEnabled) {
           return "Memory migration skipped (memory disabled).";
         }
         try {
           const outcome = await runPiMemoryMigration({
-            db: deps.db,
-            runner: deps.runner,
+            db: currentDeps.db,
+            runner: currentDeps.runner,
             primaryModel: sessionMainModel,
-            model: deps.historianModel,
-            fallbackModels: deps.historianFallbacks,
-            timeoutMs: deps.historianTimeoutMs,
-            thinkingLevel: deps.historianThinkingLevel,
+            model: currentDeps.historianModel,
+            fallbackModels: currentDeps.historianFallbacks,
+            timeoutMs: currentDeps.historianTimeoutMs,
+            thinkingLevel: currentDeps.historianThinkingLevel,
             directory: ctx.cwd,
             sessionId,
-            userMemoriesEnabled: deps.userMemoriesEnabled,
-            language: deps.language
+            userMemoriesEnabled: currentDeps.userMemoriesEnabled,
+            language: currentDeps.language
           });
           return outcome.summary;
         } catch (error51) {
@@ -200737,7 +201012,7 @@ An upgrade or recomp is already running for this session in the background. Wait
       };
       if (upgradableCount === 0) {
         const projectPath = resolveProjectIdentity(ctx.cwd);
-        const migrationPending = migrationEnabled && !isMemoryMigrationDone(deps.db, projectPath);
+        const migrationPending = migrationEnabled && !isMemoryMigrationDone(currentDeps.db, projectPath);
         if (!migrationPending) {
           sendCtxStatusMessage(pi, {
             title: "/ctx-session-upgrade",
@@ -200763,7 +201038,10 @@ Compartments are already current. Re-organizing project memories. This may take
           provider: {
             readMessages: () => readPiSessionMessages(ctx)
           },
-          onStatusChange: () => updateStatusLine(ctx, { db: deps.db, projectIdentity: ctx.cwd }),
+          onStatusChange: () => updateStatusLine(ctx, {
+            db: currentDeps.db,
+            projectIdentity: ctx.cwd
+          }),
           work: async () => {
             const summary = await runMigration();
             sendCtxStatusMessage(pi, {
@@ -200789,35 +201067,38 @@ Rebuilding compartments into the v2 format and re-organizing project memories. T
       spawnPiRecompRun({
         sessionId,
         provider: provider2,
-        onStatusChange: () => updateStatusLine(ctx, { db: deps.db, projectIdentity: ctx.cwd }),
+        onStatusChange: () => updateStatusLine(ctx, {
+          db: currentDeps.db,
+          projectIdentity: ctx.cwd
+        }),
         work: async () => {
           const recompResult = await executeContextRecompWithResult({
             client: createPiHistorianClient({
-              runner: deps.runner,
-              model: deps.historianModel,
-              fallbackModels: deps.historianFallbacks,
-              timeoutMs: deps.historianTimeoutMs,
-              thinkingLevel: deps.historianThinkingLevel,
+              runner: currentDeps.runner,
+              model: currentDeps.historianModel,
+              fallbackModels: currentDeps.historianFallbacks,
+              timeoutMs: currentDeps.historianTimeoutMs,
+              thinkingLevel: currentDeps.historianThinkingLevel,
               directory: ctx.cwd,
               accountingSessionId: sessionId,
-              systemPrompt: withContentLanguageDirective(COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, deps.language, { preserveUserQuotes: true }),
+              systemPrompt: withContentLanguageDirective(COMPARTMENT_STRUCTURAL_SYSTEM_PROMPT, currentDeps.language, { preserveUserQuotes: true }),
               notify: (text) => sendCtxStatusMessage(pi, {
                 title: "/ctx-session-upgrade",
                 text,
                 level: "info"
               })
             }),
-            db: deps.db,
+            db: currentDeps.db,
             sessionId,
-            historianChunkTokens: deps.historianChunkTokens,
+            historianChunkTokens: currentDeps.historianChunkTokens,
             directory: ctx.cwd,
-            historianTimeoutMs: deps.historianTimeoutMs,
-            memoryEnabled: deps.memoryEnabled,
-            autoPromote: deps.autoPromote,
+            historianTimeoutMs: currentDeps.historianTimeoutMs,
+            memoryEnabled: currentDeps.memoryEnabled,
+            autoPromote: currentDeps.autoPromote,
             ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
-            fallbackModels: deps.historianFallbacks,
+            fallbackModels: currentDeps.historianFallbacks,
             fallbackModelId: sessionMainModel,
-            language: deps.language
+            language: currentDeps.language
           }, {});
           if (!recompResult.published || !isRecompComplete(recompResult.message)) {
             const reason = contextualizeUpgradeReason(isRecompFailure(recompResult.message) ? extractRecompReason(recompResult.message) : `Compartments were not fully rebuilt: ${extractRecompReason(recompResult.message)}`);
@@ -200831,7 +201112,7 @@ ${reason}`,
             return;
           }
           try {
-            stagePiRecompMarker({ db: deps.db, sessionId, ctx });
+            stagePiRecompMarker({ db: currentDeps.db, sessionId, ctx });
           } catch (markerError) {
             sessionLog(sessionId, `pi /ctx-session-upgrade marker staging failed (non-fatal, recomp already published): ${describeError(markerError).brief}`);
           }
@@ -201029,7 +201310,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.31.2",
+  version: "0.31.3",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -201180,6 +201461,7 @@ function renderInner(s, theme, innerWidth) {
   lines.push(`${theme.fg("accent", theme.bold("⚡ Magic Context Status"))}   ${theme.fg("muted", `v${package_default.version}`)}`);
   lines.push("");
   lines.push(`Context  ${theme.fg(pctColor, theme.bold(`${s.usagePercentage.toFixed(1)}%`))} · ${fmt2(s.inputTokens)} / ${s.contextLimit > 0 ? fmt2(s.contextLimit) : "?"} tokens`);
+  lines.push(`Work tokens ${fmt2(s.newWorkTokens)} new · ${fmt2(s.totalInputTokens)} total input`);
   lines.push(renderBar(s, innerWidth));
   for (const seg of breakdownSegments(s)) {
     const pct = (seg.tokens / (s.inputTokens || 1) * 100).toFixed(1);
@@ -201275,6 +201557,7 @@ ${safeStringify(tool.parameters)}`);
     }
   } catch {}
   const conversationTokens = Math.max(0, inputTokens - systemPromptTokens - compartmentTokens - factTokens - memoryTokens - docsTokens - profileTokens - toolCallTokens - toolDefinitionTokens);
+  const workMetrics = getSessionWorkMetrics(deps.db, sessionId);
   const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
   const threshold = resolveExecuteThresholdDetail(deps.executeThresholdPercentage ?? 65, modelKey, 65, {
     tokensConfig: deps.executeThresholdTokens,
@@ -201338,6 +201621,8 @@ ${safeStringify(tool.parameters)}`);
     conversationTokens,
     toolCallTokens,
     toolDefinitionTokens,
+    newWorkTokens: workMetrics.newWorkTokens,
+    totalInputTokens: workMetrics.totalInputTokens,
     upgradeNeededCount: safeRead(() => countCompartmentsNeedingUpgrade(deps.db, sessionId), 0),
     recompInFlight: isPiRecompInFlight(sessionId)
   };
@@ -201492,8 +201777,9 @@ function registerCtxStatusCommand(pi, deps) {
   pi.registerCommand("ctx-status", {
     description: "Show Magic Context status for the current Pi session",
     handler: async (_args, ctx) => {
-      const projectIdentity = deps.resolveProject?.(ctx).projectIdentity ?? deps.projectIdentity;
-      const currentDeps = { ...deps, projectIdentity };
+      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, {
@@ -201608,7 +201894,8 @@ No active Pi session is available.`,
         });
         return;
       }
-      const sessionMeta = getOrCreateSessionMeta(deps.db, sessionId);
+      const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      const sessionMeta = getOrCreateSessionMeta(currentDeps.db, sessionId);
       if (sessionMeta.isSubagent) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-wrapup",
@@ -201619,7 +201906,7 @@ No active Pi session is available.`,
         });
         return;
       }
-      if (!deps.historianModel) {
+      if (!currentDeps.historianModel) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-wrapup",
           text: "## Magic Wrapup\n\n/ctx-wrapup is unavailable because `historian.model` is not configured.",
@@ -201638,7 +201925,7 @@ ${parsed.message}`,
         });
         return;
       }
-      const result = await runPiWrapup(pi, deps, ctx, sessionId, parsed.messagesToKeep);
+      const result = await runPiWrapup(pi, currentDeps, ctx, sessionId, parsed.messagesToKeep);
       sendCtxStatusMessage(pi, {
         title: "/ctx-wrapup",
         text: result,
@@ -201812,6 +202099,7 @@ Chunk ${chunkIndex}: wrapping messages ${plan.snapshot.offset}-${plan.snapshot.e
             runner: deps.runner,
             historianModel: deps.historianModel,
             fallbackModels: deps.historianFallbacks,
+            fallbackModelId: modelKey,
             historianChunkTokens: deps.historianChunkTokens,
             boundarySnapshot: plan.snapshot,
             refreshBoundarySnapshot: () => resolveWrapupProtectedTailBoundary({
@@ -206393,16 +206681,16 @@ __export(exports_typebox, {
 // src/tools/ctx-expand.ts
 var ParamsSchema = exports_typebox.Object({
   start: exports_typebox.Optional(exports_typebox.Number({
-    description: "Start message ordinal (from compartment start attribute)"
+    description: `First message ordinal to expand — a compartment's start="N" attribute, or an ordinal from a ctx_search message hit`
   })),
   end: exports_typebox.Optional(exports_typebox.Number({
-    description: "End message ordinal (from compartment end attribute)"
+    description: `Last message ordinal to expand (inclusive) — a compartment's end="M" attribute`
   })),
   verbose: exports_typebox.Optional(exports_typebox.Boolean({
     description: "With start/end: list each message separately with its ordinal [N] and per-part preview, so you can recover one in full by ordinal."
   })),
   message: exports_typebox.Optional(exports_typebox.Number({
-    description: "Full untruncated recovery of ONE message by its ordinal (text + every tool call's full input/output). Recovers a tool output you dropped with ctx_reduce."
+    description: "Full untruncated recovery of ONE message by its ordinal (every text part + every tool call's complete input/output). Use an ordinal from a compartment, ctx_search hit, or verbose range. Recovers a tool output you dropped with ctx_reduce."
   }))
 });
 function ok(text) {
@@ -206553,25 +206841,45 @@ function formatMemoryList(memories) {
     id: String(m.id),
     category: m.category,
     status: m.status,
+    verification: m.verificationStatus,
     updated: new Date(m.updatedAt).toISOString(),
     content: m.content.replace(/\s+/g, " ").trim()
   }));
+  const headers = {
+    id: "ID",
+    category: "CATEGORY",
+    status: "STATUS",
+    verification: "VERIFY",
+    updated: "UPDATED",
+    content: "CONTENT"
+  };
   const widths = {
-    id: Math.max(2, ...rows.map((r) => r.id.length)),
-    category: Math.max(8, ...rows.map((r) => r.category.length)),
-    status: Math.max(6, ...rows.map((r) => r.status.length)),
-    updated: Math.max(7, ...rows.map((r) => r.updated.length))
+    id: Math.max(headers.id.length, ...rows.map((r) => r.id.length)),
+    category: Math.max(headers.category.length, ...rows.map((r) => r.category.length)),
+    status: Math.max(headers.status.length, ...rows.map((r) => r.status.length)),
+    verification: Math.max(headers.verification.length, ...rows.map((r) => r.verification.length)),
+    updated: Math.max(headers.updated.length, ...rows.map((r) => r.updated.length))
   };
   const fmt3 = (r) => [
     r.id.padEnd(widths.id),
     r.category.padEnd(widths.category),
     r.status.padEnd(widths.status),
+    r.verification.padEnd(widths.verification),
     r.updated.padEnd(widths.updated),
     r.content
   ].join(" | ");
   return [
     `Found ${rows.length} active ${rows.length === 1 ? "memory" : "memories"}:`,
     "",
+    fmt3(headers),
+    [
+      "-".repeat(widths.id),
+      "-".repeat(widths.category),
+      "-".repeat(widths.status),
+      "-".repeat(widths.verification),
+      "-".repeat(widths.updated),
+      "-------"
+    ].join("-+-"),
     ...rows.map(fmt3)
   ].join(`
 `);
@@ -206977,6 +207285,7 @@ function createCtxNoteTool(deps) {
     parameters: ParamsSchema3,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const sessionId = ctx.sessionManager.getSessionId();
+      const dreamerEnabled = deps.resolveDreamerEnabled?.(ctx) ?? deps.dreamerEnabled;
       const action2 = params.action ?? (params.content?.trim() ? "write" : "read");
       if (action2 === "write") {
         const content = params.content?.trim();
@@ -206985,7 +207294,7 @@ function createCtxNoteTool(deps) {
         const anchorOrdinal = captureAnchorOrdinal(deps.db, sessionId);
         const surfaceCondition = params.surface_condition?.trim();
         if (surfaceCondition) {
-          if (deps.dreamerEnabled !== true) {
+          if (dreamerEnabled !== true) {
             return err3("Error: Smart notes require dreamer to be enabled. Enable dreamer in magic-context.jsonc to use surface_condition.");
           }
           const projectIdentity = resolveProjectIdentity(ctx.cwd);
@@ -206994,6 +207303,7 @@ function createCtxNoteTool(deps) {
           }
           const note2 = addNote(deps.db, "smart", {
             content,
+            sessionId,
             projectPath: projectIdentity,
             surfaceCondition,
             anchorOrdinal
@@ -207245,6 +207555,7 @@ function createCtxReduceTool(deps) {
     parameters: ParamsSchema4,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const sessionId = ctx.sessionManager.getSessionId();
+      const protectedTags = Math.max(0, Math.floor(deps.resolveProtectedTags?.(ctx) ?? deps.protectedTags));
       if (!params.drop) {
         return err4("Error: 'drop' must be provided.");
       }
@@ -207262,7 +207573,7 @@ function createCtxReduceTool(deps) {
         return err4(`Error: Unknown tag(s) ${formatIds(unknownIds)}. Check available tags in conversation.`);
       }
       const activeTags = allTags.filter((tag) => tag.status === "active");
-      const protectedTagIds = activeTags.map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, deps.protectedTags);
+      const protectedTagIds = activeTags.map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, protectedTags);
       const protectedSet = new Set(protectedTagIds);
       const tagStatusMap = new Map(allTags.map((tag) => [tag.tagNumber, tag.status]));
       const pendingOps = getPendingOps(deps.db, sessionId);
@@ -207489,6 +207800,417 @@ function createCtxSearchTool(deps) {
   };
 }
 
+// src/tools/todo-view-pi.ts
+import {
+  truncateToWidth as truncateToWidth2
+} from "@earendil-works/pi-tui";
+var TODO_TOOL_NAME = "todowrite";
+var TODOS_COMMAND_NAME = "todos";
+var WIDGET_KEY = "magic-context-todos";
+var MAX_OVERLAY_CONTENT_ROWS = 12;
+var TODO_STATUSES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "cancelled"
+];
+var TODO_PRIORITIES = ["high", "medium", "low"];
+var STATUS_GLYPH = {
+  pending: "○",
+  in_progress: "◐",
+  completed: "✓",
+  cancelled: "✗"
+};
+var STATUS_COLOR = {
+  pending: "dim",
+  in_progress: "warning",
+  completed: "success",
+  cancelled: "error"
+};
+var snapshotsBySession = new Map;
+function isTodoStatus(value) {
+  return TODO_STATUSES.includes(value);
+}
+function isTodoPriority(value) {
+  return TODO_PRIORITIES.includes(value);
+}
+function cloneTodos(todos) {
+  return todos.map((todo) => ({ ...todo }));
+}
+function parseTodos(input) {
+  if (!Array.isArray(input))
+    return null;
+  const todos = [];
+  for (const item of input) {
+    if (item === null || typeof item !== "object")
+      return null;
+    const raw = item;
+    if (typeof raw.content !== "string" || !isTodoStatus(raw.status)) {
+      return null;
+    }
+    const todo = {
+      content: raw.content,
+      status: raw.status
+    };
+    if (isTodoPriority(raw.priority))
+      todo.priority = raw.priority;
+    if (typeof raw.id === "string" && raw.id.length > 0)
+      todo.id = raw.id;
+    todos.push(todo);
+  }
+  return todos;
+}
+function parseTodoStateJson(stateJson) {
+  if (!stateJson)
+    return null;
+  try {
+    return parseTodos(JSON.parse(stateJson));
+  } catch {
+    return null;
+  }
+}
+function setTodoSnapshot(sessionId, todos) {
+  const parsed = parseTodos(todos);
+  if (parsed === null)
+    return false;
+  snapshotsBySession.set(sessionId, { todos: parsed });
+  return true;
+}
+function seedTodoSnapshotFromStateJson(sessionId, stateJson) {
+  const parsed = parseTodoStateJson(stateJson);
+  if (parsed === null) {
+    snapshotsBySession.delete(sessionId);
+    return false;
+  }
+  snapshotsBySession.set(sessionId, { todos: parsed });
+  return true;
+}
+function getTodoSnapshot(sessionId) {
+  if (!sessionId)
+    return { todos: [] };
+  const snapshot = snapshotsBySession.get(sessionId);
+  return { todos: snapshot ? cloneTodos(snapshot.todos) : [] };
+}
+function clearTodoSnapshot(sessionId) {
+  snapshotsBySession.delete(sessionId);
+}
+function getSessionId(ctx) {
+  try {
+    const id = ctx.sessionManager?.getSessionId?.();
+    return typeof id === "string" && id.length > 0 ? id : undefined;
+  } catch {
+    return;
+  }
+}
+function countTodos(todos) {
+  const counts = {
+    total: todos.length,
+    pending: 0,
+    inProgress: 0,
+    completed: 0,
+    cancelled: 0
+  };
+  for (const todo of todos) {
+    switch (todo.status) {
+      case "pending":
+        counts.pending++;
+        break;
+      case "in_progress":
+        counts.inProgress++;
+        break;
+      case "completed":
+        counts.completed++;
+        break;
+      case "cancelled":
+        counts.cancelled++;
+        break;
+    }
+  }
+  return counts;
+}
+function activeTitleCount(todos) {
+  return todos.filter((todo) => todo.status !== "completed").length;
+}
+function formatCounts(counts) {
+  if (counts.total === 0)
+    return "No todos";
+  const parts = [`${counts.completed}/${counts.total} completed`];
+  if (counts.inProgress > 0)
+    parts.push(`${counts.inProgress} in progress`);
+  if (counts.pending > 0)
+    parts.push(`${counts.pending} pending`);
+  if (counts.cancelled > 0)
+    parts.push(`${counts.cancelled} cancelled`);
+  return parts.join(" · ");
+}
+function formatTodoLine(todo, theme, options = {}) {
+  const glyph = theme.fg(STATUS_COLOR[todo.status], STATUS_GLYPH[todo.status]);
+  const id = options.showId && todo.id ? `${theme.fg("accent", `#${todo.id}`)} ` : "";
+  const color = todo.status === "pending" || todo.status === "in_progress" ? "text" : "dim";
+  let content = theme.fg(color, todo.content);
+  if (todo.status === "completed" || todo.status === "cancelled") {
+    content = theme.strikethrough(content);
+  }
+  return `${glyph} ${id}${content}`;
+}
+function formatCommandLine(todo) {
+  const id = todo.id ? `#${todo.id} ` : "";
+  return `  ${STATUS_GLYPH[todo.status]} ${id}${todo.content}`;
+}
+function lineComponent(renderLines) {
+  return {
+    render: renderLines,
+    invalidate() {}
+  };
+}
+function renderTodowriteCall(args, theme) {
+  const todos = parseTodos(args.todos) ?? [];
+  const active = activeTitleCount(todos);
+  const activeColor = active > 0 ? "warning" : "success";
+  const line = `${theme.fg("toolTitle", theme.bold("Todos"))} ${theme.fg("muted", "—")} ${theme.fg(activeColor, `${active} active`)}`;
+  return lineComponent((width) => [truncateToWidth2(line, width, "…")]);
+}
+function renderTodowriteResult(result, theme) {
+  const detailsTodos = result.details?.todos;
+  let todos = parseTodos(detailsTodos);
+  if (todos === null && Array.isArray(result.content)) {
+    const text = result.content.find((part) => part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string")?.text;
+    if (text) {
+      try {
+        todos = parseTodos(JSON.parse(text));
+      } catch {}
+    }
+  }
+  const renderedTodos = todos ?? [];
+  return lineComponent((width) => {
+    if (renderedTodos.length === 0)
+      return [theme.fg("dim", "No todos")];
+    return renderedTodos.map((todo) => truncateToWidth2(formatTodoLine(todo, theme, { showId: true }), width, "…"));
+  });
+}
+function registerTodosCommand(pi) {
+  pi.registerCommand(TODOS_COMMAND_NAME, {
+    description: "Show the current Magic Context todo list",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("The /todos command requires interactive UI.", "error");
+        return;
+      }
+      const sessionId = getSessionId(ctx);
+      const todos = getTodoSnapshot(sessionId).todos;
+      if (todos.length === 0) {
+        ctx.ui.notify("No todos yet.", "info");
+        return;
+      }
+      const counts = countTodos(todos);
+      const lines = [formatCounts(counts)];
+      const groups = [
+        ["pending", "── Pending ──"],
+        ["in_progress", "── In Progress ──"],
+        ["completed", "── Completed ──"],
+        ["cancelled", "── Cancelled ──"]
+      ];
+      for (const [status, heading] of groups) {
+        const group = todos.filter((todo) => todo.status === status);
+        if (group.length === 0)
+          continue;
+        lines.push(heading);
+        for (const todo of group)
+          lines.push(formatCommandLine(todo));
+      }
+      ctx.ui.notify(lines.join(`
+`), "info");
+    }
+  });
+}
+function todoKey(todo, index) {
+  return todo.id ? `id:${todo.id}` : `pos:${index}:${todo.content}`;
+}
+function isOverlayLive(todo) {
+  return todo.status === "pending" || todo.status === "in_progress";
+}
+
+class TodoOverlay {
+  uiCtx;
+  sessionId;
+  widgetRegistered = false;
+  tui;
+  completedTaskIdsPendingHide = new Set;
+  hiddenCompletedTaskIds = new Set;
+  lastTodoKeys = new Set;
+  setUICtx(sessionId, ctx) {
+    if (ctx !== this.uiCtx || sessionId !== this.sessionId) {
+      this.uiCtx = ctx;
+      this.sessionId = sessionId;
+      this.widgetRegistered = false;
+      this.tui = undefined;
+      this.resetCompletedDisplayState();
+    }
+  }
+  update(sessionId = this.sessionId) {
+    if (!this.uiCtx || !this.sessionId || sessionId !== this.sessionId)
+      return;
+    const todos = getTodoSnapshot(this.sessionId).todos;
+    this.pruneCompletedDisplayState(todos);
+    const visible = this.selectOverlayTodos(todos);
+    if (visible.length === 0) {
+      if (this.widgetRegistered) {
+        this.uiCtx.setWidget(WIDGET_KEY, undefined);
+        this.widgetRegistered = false;
+        this.tui = undefined;
+      }
+      return;
+    }
+    if (!this.widgetRegistered) {
+      this.uiCtx.setWidget(WIDGET_KEY, (tui, theme) => {
+        this.tui = tui;
+        return {
+          render: (width) => this.renderWidget(theme, width),
+          invalidate: () => {
+            this.widgetRegistered = false;
+            this.tui = undefined;
+          }
+        };
+      }, { placement: "aboveEditor" });
+      this.widgetRegistered = true;
+    } else {
+      this.tui?.requestRender();
+    }
+  }
+  resetCompletedDisplayState() {
+    this.completedTaskIdsPendingHide.clear();
+    this.hiddenCompletedTaskIds.clear();
+    this.lastTodoKeys.clear();
+  }
+  hideCompletedTasksFromPreviousTurn() {
+    if (this.completedTaskIdsPendingHide.size === 0)
+      return;
+    for (const taskId of this.completedTaskIdsPendingHide) {
+      this.hiddenCompletedTaskIds.add(taskId);
+    }
+    this.completedTaskIdsPendingHide.clear();
+    this.update();
+  }
+  disposeSession(sessionId) {
+    if (this.sessionId !== sessionId)
+      return;
+    this.dispose();
+  }
+  dispose() {
+    if (this.uiCtx)
+      this.uiCtx.setWidget(WIDGET_KEY, undefined);
+    this.widgetRegistered = false;
+    this.tui = undefined;
+    this.uiCtx = undefined;
+    this.sessionId = undefined;
+    this.resetCompletedDisplayState();
+  }
+  pruneCompletedDisplayState(todos) {
+    const currentKeys = new Set(todos.map((todo, index) => todoKey(todo, index)));
+    const hasSharedKeys = [...currentKeys].some((key) => this.lastTodoKeys.has(key));
+    if (this.lastTodoKeys.size > 0 && currentKeys.size > 0 && !hasSharedKeys) {
+      this.resetCompletedDisplayState();
+    }
+    this.lastTodoKeys = currentKeys;
+    const completedKeys = new Set(todos.map((todo, index) => ({ todo, key: todoKey(todo, index) })).filter(({ todo }) => todo.status === "completed").map(({ key }) => key));
+    for (const taskId of this.completedTaskIdsPendingHide) {
+      if (!completedKeys.has(taskId))
+        this.completedTaskIdsPendingHide.delete(taskId);
+    }
+    for (const taskId of this.hiddenCompletedTaskIds) {
+      if (!completedKeys.has(taskId))
+        this.hiddenCompletedTaskIds.delete(taskId);
+    }
+  }
+  selectOverlayTodos(todos) {
+    return todos.map((todo, index) => ({ todo, key: todoKey(todo, index) })).filter(({ todo, key }) => {
+      if (isOverlayLive(todo))
+        return true;
+      return todo.status === "completed" && !this.hiddenCompletedTaskIds.has(key);
+    });
+  }
+  renderWidget(theme, width) {
+    if (!this.sessionId)
+      return [];
+    const todos = getTodoSnapshot(this.sessionId).todos;
+    this.pruneCompletedDisplayState(todos);
+    const overlayTodos = this.selectOverlayTodos(todos);
+    if (overlayTodos.length === 0)
+      return [];
+    const counts = countTodos(todos);
+    const hasInProgress = counts.inProgress > 0;
+    const headingColor = hasInProgress ? "accent" : "dim";
+    const headingIcon = hasInProgress ? "●" : "○";
+    const heading = `${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, "Todos")} ${theme.fg("muted", "—")} ${theme.fg("dim", formatCounts(counts))}`;
+    const truncate3 = (line) => truncateToWidth2(line, width, "…");
+    const lines = [truncate3(heading)];
+    const hasTruncatedTail = overlayTodos.length > MAX_OVERLAY_CONTENT_ROWS;
+    const visibleRows = hasTruncatedTail ? MAX_OVERLAY_CONTENT_ROWS - 1 : MAX_OVERLAY_CONTENT_ROWS;
+    const truncatedTail = Math.max(0, overlayTodos.length - visibleRows);
+    const visible = overlayTodos.slice(0, visibleRows);
+    for (const [index, { todo, key }] of visible.entries()) {
+      const isLast = index === visible.length - 1 && truncatedTail === 0;
+      const branch = theme.fg("dim", isLast ? "└─" : "├─");
+      lines.push(truncate3(`${branch} ${formatTodoLine(todo, theme, { showId: true })}`));
+      if (todo.status === "completed")
+        this.completedTaskIdsPendingHide.add(key);
+    }
+    if (truncatedTail > 0) {
+      lines.push(truncate3(`${theme.fg("dim", "└─")} ${theme.fg("dim", `+${truncatedTail} more`)}`));
+    }
+    return lines;
+  }
+}
+function registerTodoOverlay(pi, deps) {
+  const overlay = new TodoOverlay;
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (!sessionId)
+      return;
+    seedTodoSnapshotFromStateJson(sessionId, deps.readLastTodoState(sessionId));
+    if (!ctx.hasUI)
+      return;
+    overlay.setUICtx(sessionId, ctx.ui);
+    overlay.update(sessionId);
+  });
+  pi.on("agent_start", async () => {
+    overlay.hideCompletedTasksFromPreviousTurn();
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (!sessionId)
+      return;
+    clearTodoSnapshot(sessionId);
+    overlay.disposeSession(sessionId);
+  });
+  pi.on("session_before_switch", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (!sessionId)
+      return;
+    clearTodoSnapshot(sessionId);
+    overlay.disposeSession(sessionId);
+  });
+  return overlay;
+}
+function registerTodoStateLifecycle(pi, deps) {
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (!sessionId)
+      return;
+    seedTodoSnapshotFromStateJson(sessionId, deps.readLastTodoState(sessionId));
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (sessionId)
+      clearTodoSnapshot(sessionId);
+  });
+  pi.on("session_before_switch", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (sessionId)
+      clearTodoSnapshot(sessionId);
+  });
+}
+
 // src/tools/todowrite.ts
 var STATUS_VALUES = [
   "pending",
@@ -207508,29 +208230,20 @@ var TodowriteParams = exports_typebox.Object({
     description: "Replace the current task list with this complete set of todos. Include every task you intend to track this turn — pending, in_progress, completed, or cancelled — because the list overwrites previous state."
   })
 });
-var TOOL_DESCRIPTION = [
-  "Manage your task list for this session.",
-  "",
-  "Use this tool to plan multi-step work, track in-flight tasks, and",
-  "mark progress as you complete steps. Pass the COMPLETE updated list",
-  "of todos every time — this tool replaces the prior list rather than",
-  "appending to it.",
-  "",
-  "Task states:",
-  "  - pending: not started yet",
-  "  - in_progress: currently working on (limit to ONE task at a time)",
-  "  - completed: finished successfully",
-  "  - cancelled: no longer needed",
-  "",
-  "Use this tool proactively for non-trivial work spanning 3+ steps.",
-  "Skip it for single-shot answers or trivial 1-2 step tasks."
-].join(`
-`);
+var PROMPT_SNIPPET = "Manage a task list to track multi-step progress";
+var PROMPT_GUIDELINES = [
+  "Use `todowrite` for non-trivial work spanning 3+ steps, when the user gives you multiple tasks, or when you need to track progress across a verify/fix loop. Skip it for single-shot answers or trivial one-step work.",
+  "Pass the COMPLETE updated todo list every time. This tool replaces the prior list rather than appending to it, so include pending, in_progress, completed, and cancelled tasks that should remain visible.",
+  "When starting a task, mark exactly one todo `in_progress` before doing the work. Mark items `completed` immediately when done; use `cancelled` only for work that is no longer needed.",
+  "Never mark a todo completed if verification is failing, implementation is partial, or an unresolved blocker remains. Keep it `in_progress` and add or update a todo for the blocker instead."
+];
 function createTodowriteTool() {
   return {
-    name: "todowrite",
+    name: TODO_TOOL_NAME,
     label: "Todos",
-    description: TOOL_DESCRIPTION,
+    description: "Manage the session task list.",
+    promptSnippet: PROMPT_SNIPPET,
+    promptGuidelines: PROMPT_GUIDELINES,
     parameters: TodowriteParams,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
       const todos = params.todos ?? [];
@@ -207549,6 +208262,12 @@ function createTodowriteTool() {
           truncated: false
         }
       };
+    },
+    renderCall(args, theme) {
+      return renderTodowriteCall(args, theme);
+    },
+    renderResult(result, _opts, theme) {
+      return renderTodowriteResult(result, theme);
     }
   };
 }
@@ -207574,15 +208293,22 @@ function registerMagicContextTools(pi, opts) {
   if (!opts.sessionScopedToolsDisabled) {
     pi.registerTool(createCtxNoteTool({
       db: opts.db,
-      dreamerEnabled: opts.dreamerEnabled ?? false
+      dreamerEnabled: opts.dreamerEnabled ?? false,
+      resolveDreamerEnabled: opts.resolveDreamerEnabled
     }));
     pi.registerTool(createCtxExpandTool({ db: opts.db }));
   }
-  pi.registerTool(createTodowriteTool());
+  if (opts.todowriteEnabled !== false) {
+    pi.registerTool(createTodowriteTool());
+    if (opts.todowriteCommandEnabled !== false) {
+      registerTodosCommand(pi);
+    }
+  }
   if (!opts.sessionScopedToolsDisabled) {
     pi.registerTool(createCtxReduceTool({
       db: opts.db,
-      protectedTags: opts.protectedTags ?? 20
+      protectedTags: opts.protectedTags ?? 20,
+      resolveProtectedTags: opts.resolveProtectedTags
     }));
   }
 }
@@ -207594,6 +208320,10 @@ function resolveCurrentProject(ctx) {
   const projectIdentity = resolveProjectIdentityOrFallback(projectDir);
   return { projectDir, projectIdentity };
 }
+function signalPiDeferredCompactionMarkerDrain(sessionId) {
+  signalPiDeferredHistoryRefresh(sessionId);
+  signalPiDeferredMaterialization(sessionId);
+}
 function persistPiMessageEndModelMeta(args) {
   if (!args.message || typeof args.message !== "object")
     return;
@@ -207798,8 +208528,7 @@ async function src_default2(pi) {
   try {
     const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
     for (const sid of pendingPiMarkerSessions) {
-      signalPiDeferredHistoryRefresh(sid);
-      signalPiDeferredMaterialization(sid);
+      signalPiDeferredCompactionMarkerDrain(sid);
     }
     if (pendingPiMarkerSessions.length > 0) {
       log(`${PREFIX} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
@@ -207832,26 +208561,7 @@ async function src_default2(pi) {
   }
   await ensureProjectRegisteredFromPiDirectory(projectDir, db);
   info(`registered embedding config for project ${projectIdentity}`);
-  registerMagicContextTools(pi, {
-    db,
-    ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
-    allowDreamerActions: false,
-    memoryToolEnabled: true,
-    protectedTags: config2.protected_tags ?? 20,
-    dreamerEnabled: isDreamerRunnable(config2)
-  });
-  info("registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, ctx_reduce");
-  const historianConfig = resolveHistorianFromConfig(config2);
-  if (historianConfig) {
-    historianConfig.onStatusChange = (ctx) => {
-      updateStatusLine(ctx, {
-        db,
-        projectIdentity: resolveCurrentProject(ctx).projectIdentity
-      });
-    };
-  }
-  const autoSearchConfig = resolveAutoSearchFromConfig(config2);
-  const contextOptionsByDir = new Map;
+  const projectDepsByDir = new Map;
   const buildContextOptions = (cfg, hist, auto) => ({
     db: database,
     smartDrops: cfg.smart_drops === true,
@@ -207892,46 +208602,110 @@ async function src_default2(pi) {
       });
     }
   });
-  function resolveContextOptionsForProject(dir) {
-    const cached2 = contextOptionsByDir.get(dir);
-    if (cached2)
-      return cached2;
-    ensureConfigLocationsMigrated(dir);
-    const switchedConfig = loadPiConfig({ cwd: dir }).config;
-    const switchedHistorian = resolveHistorianFromConfig(switchedConfig);
-    if (switchedHistorian) {
-      switchedHistorian.onStatusChange = (ctx) => {
+  function buildProjectDeps(dir, identity, cfg) {
+    const hist = resolveHistorianFromConfig(cfg);
+    if (hist) {
+      hist.onStatusChange = (ctx) => {
         updateStatusLine(ctx, {
           db: database,
           projectIdentity: resolveCurrentProject(ctx).projectIdentity
         });
       };
     }
-    const built = buildContextOptions(switchedConfig, switchedHistorian, resolveAutoSearchFromConfig(switchedConfig));
-    contextOptionsByDir.set(dir, built);
+    const auto = resolveAutoSearchFromConfig(cfg);
+    return {
+      projectDir: dir,
+      projectIdentity: identity,
+      config: cfg,
+      historianConfig: hist,
+      autoSearchConfig: auto,
+      contextOptions: buildContextOptions(cfg, hist, auto),
+      sidekickConfig: resolveSidekickFromConfig(cfg),
+      dreamerConfig: resolveDreamerFromConfig(cfg),
+      dreamerEnabled: isDreamerRunnable(cfg)
+    };
+  }
+  function resolveProjectDepsForDir(dir, identityOverride) {
+    const cached2 = projectDepsByDir.get(dir);
+    if (cached2)
+      return cached2;
+    ensureConfigLocationsMigrated(dir);
+    const switchedConfig = loadPiConfig({ cwd: dir }).config;
+    const switchedIdentity = identityOverride ?? resolveProjectIdentityOrFallback(dir);
+    const built = buildProjectDeps(dir, switchedIdentity, switchedConfig);
+    projectDepsByDir.set(dir, built);
     return built;
   }
-  const bootContextOptions = buildContextOptions(config2, historianConfig, autoSearchConfig);
-  contextOptionsByDir.set(projectDir, bootContextOptions);
-  registerPiContextHandler(pi, bootContextOptions);
-  info(historianConfig ? `registered historian trigger (model=${historianConfig.model}, executeThreshold=${formatExecuteThresholdForLog(historianConfig.executeThresholdPercentage)})` : "registered historian trigger: DISABLED (set historian.model in magic-context.jsonc)");
-  info(autoSearchConfig.enabled ? `registered auto-search hint (threshold=${autoSearchConfig.scoreThreshold}, minChars=${autoSearchConfig.minPromptChars})` : "registered auto-search hint: DISABLED (memory.auto_search.enabled=false)");
-  const sidekickConfig = resolveSidekickFromConfig(config2);
-  registerCtxAugCommand(pi, sidekickConfig);
-  info(sidekickConfig ? `registered /ctx-aug (sidekick model=${sidekickConfig.model})` : "registered /ctx-aug (sidekick disabled — set sidekick.disable=false and sidekick.model in config)");
+  function resolveCurrentProjectDeps(ctx) {
+    const currentProject = resolveCurrentProject(ctx);
+    return resolveProjectDepsForDir(currentProject.projectDir, currentProject.projectIdentity);
+  }
+  function resolveContextOptionsForProject(dir) {
+    return resolveProjectDepsForDir(dir).contextOptions;
+  }
+  const bootProjectDeps = buildProjectDeps(projectDir, projectIdentity, config2);
+  projectDepsByDir.set(projectDir, bootProjectDeps);
+  const todowriteEnabled = bootProjectDeps.config.todowrite.enabled !== false;
+  const todowriteOverlayEnabled = todowriteEnabled && bootProjectDeps.config.todowrite.overlay !== false;
+  registerMagicContextTools(pi, {
+    db,
+    ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
+    allowDreamerActions: false,
+    memoryToolEnabled: true,
+    protectedTags: config2.protected_tags ?? 20,
+    resolveProtectedTags: (ctx) => resolveCurrentProjectDeps(ctx).config.protected_tags ?? 20,
+    dreamerEnabled: isDreamerRunnable(config2),
+    resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
+    todowriteEnabled
+  });
+  info(todowriteEnabled ? "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, todowrite, ctx_reduce; registered /todos" : "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, ctx_reduce (todowrite disabled)");
+  const readLastTodoState = (sessionId) => getOrCreateSessionMeta(db, sessionId).lastTodoState;
+  if (todowriteEnabled) {
+    registerTodoStateLifecycle(pi, { readLastTodoState });
+  }
+  const todoOverlay = todowriteOverlayEnabled ? registerTodoOverlay(pi, {
+    readLastTodoState
+  }) : undefined;
+  info(todowriteOverlayEnabled ? "registered todowrite overlay" : "registered todowrite overlay: DISABLED (todowrite.enabled=false or todowrite.overlay=false)");
+  registerPiContextHandler(pi, bootProjectDeps.contextOptions);
+  info(bootProjectDeps.historianConfig ? `registered historian trigger (model=${bootProjectDeps.historianConfig.model}, executeThreshold=${formatExecuteThresholdForLog(bootProjectDeps.historianConfig.executeThresholdPercentage)})` : "registered historian trigger: DISABLED (set historian.model in magic-context.jsonc)");
+  info(bootProjectDeps.autoSearchConfig.enabled ? `registered auto-search hint (threshold=${bootProjectDeps.autoSearchConfig.scoreThreshold}, minChars=${bootProjectDeps.autoSearchConfig.minPromptChars})` : "registered auto-search hint: DISABLED (memory.auto_search.enabled=false)");
+  registerCtxAugCommand(pi, (ctx) => resolveCurrentProjectDeps(ctx).sidekickConfig);
+  info(bootProjectDeps.sidekickConfig ? `registered /ctx-aug (sidekick model=${bootProjectDeps.sidekickConfig.model})` : "registered /ctx-aug (sidekick disabled — set sidekick.disable=false and sidekick.model in config)");
+  const recompRunner = new PiSubagentRunner;
+  const wrapupRunner = new PiSubagentRunner;
+  const upgradeRunner = new PiSubagentRunner;
   registerCtxStatusCommand(pi, {
     db,
     projectIdentity,
     resolveProject: resolveCurrentProject,
-    protectedTags: config2.protected_tags,
-    executeThresholdPercentage: config2.execute_threshold_percentage,
-    historyBudgetPercentage: config2.history_budget_percentage,
-    injectionBudgetTokens: config2.memory?.injection_budget_tokens,
-    commitClusterTrigger: config2.commit_cluster_trigger,
-    executeThresholdTokens: config2.execute_threshold_tokens,
+    protectedTags: bootProjectDeps.config.protected_tags,
+    executeThresholdPercentage: bootProjectDeps.config.execute_threshold_percentage,
+    historyBudgetPercentage: bootProjectDeps.config.history_budget_percentage,
+    injectionBudgetTokens: bootProjectDeps.config.memory?.injection_budget_tokens,
+    commitClusterTrigger: bootProjectDeps.config.commit_cluster_trigger,
+    executeThresholdTokens: bootProjectDeps.config.execute_threshold_tokens,
     dreamer: {
-      runnable: isDreamerRunnable(config2),
-      scheduleSummary: summarizeDreamSchedule(config2.dreamer)
+      runnable: bootProjectDeps.dreamerEnabled,
+      scheduleSummary: summarizeDreamSchedule(bootProjectDeps.config.dreamer)
+    },
+    resolveStatusDeps: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        db,
+        projectIdentity: current.projectIdentity,
+        resolveProject: resolveCurrentProject,
+        protectedTags: current.config.protected_tags,
+        executeThresholdPercentage: current.config.execute_threshold_percentage,
+        historyBudgetPercentage: current.config.history_budget_percentage,
+        injectionBudgetTokens: current.config.memory?.injection_budget_tokens,
+        commitClusterTrigger: current.config.commit_cluster_trigger,
+        executeThresholdTokens: current.config.execute_threshold_tokens,
+        dreamer: {
+          runnable: current.dreamerEnabled,
+          scheduleSummary: summarizeDreamSchedule(current.config.dreamer)
+        }
+      };
     }
   });
   info("registered /ctx-status");
@@ -207941,45 +208715,94 @@ async function src_default2(pi) {
   info("registered /ctx-flush");
   registerCtxRecompCommand(pi, {
     db,
-    runner: new PiSubagentRunner,
-    historianModel: historianConfig?.model,
-    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(historianConfig?.model)),
-    historianFallbacks: historianConfig?.fallbackModels,
-    historianTimeoutMs: config2.historian_timeout_ms,
-    historianThinkingLevel: historianConfig?.thinkingLevel,
-    language: config2.language,
-    memoryEnabled: config2.memory.enabled,
-    autoPromote: config2.memory.auto_promote
+    runner: recompRunner,
+    historianModel: bootProjectDeps.historianConfig?.model,
+    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(bootProjectDeps.historianConfig?.model)),
+    historianFallbacks: bootProjectDeps.historianConfig?.fallbackModels,
+    historianTimeoutMs: bootProjectDeps.config.historian_timeout_ms,
+    historianThinkingLevel: bootProjectDeps.historianConfig?.thinkingLevel,
+    language: bootProjectDeps.config.language,
+    memoryEnabled: bootProjectDeps.config.memory.enabled,
+    autoPromote: bootProjectDeps.config.memory.auto_promote,
+    resolveRuntimeDeps: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        db,
+        runner: recompRunner,
+        historianModel: current.historianConfig?.model,
+        historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(current.historianConfig?.model)),
+        historianFallbacks: current.historianConfig?.fallbackModels,
+        historianTimeoutMs: current.config.historian_timeout_ms,
+        historianThinkingLevel: current.historianConfig?.thinkingLevel,
+        language: current.config.language,
+        memoryEnabled: current.config.memory.enabled,
+        autoPromote: current.config.memory.auto_promote
+      };
+    }
   });
   info("registered /ctx-recomp");
   registerCtxWrapupCommand(pi, {
     db,
-    runner: new PiSubagentRunner,
-    historianModel: historianConfig?.model,
-    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(historianConfig?.model)),
-    historianFallbacks: historianConfig?.fallbackModels,
-    historianTimeoutMs: config2.historian_timeout_ms,
-    historianThinkingLevel: historianConfig?.thinkingLevel,
-    language: config2.language,
-    memoryEnabled: config2.memory.enabled,
-    autoPromote: config2.memory.auto_promote,
-    userMemoriesEnabled: userMemoryCollectionEnabled(config2.dreamer),
-    executeThresholdPercentage: config2.execute_threshold_percentage,
-    executeThresholdTokens: config2.execute_threshold_tokens
+    runner: wrapupRunner,
+    historianModel: bootProjectDeps.historianConfig?.model,
+    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(bootProjectDeps.historianConfig?.model)),
+    historianFallbacks: bootProjectDeps.historianConfig?.fallbackModels,
+    historianTimeoutMs: bootProjectDeps.config.historian_timeout_ms,
+    historianThinkingLevel: bootProjectDeps.historianConfig?.thinkingLevel,
+    language: bootProjectDeps.config.language,
+    memoryEnabled: bootProjectDeps.config.memory.enabled,
+    autoPromote: bootProjectDeps.config.memory.auto_promote,
+    userMemoriesEnabled: userMemoryCollectionEnabled(bootProjectDeps.config.dreamer),
+    executeThresholdPercentage: bootProjectDeps.config.execute_threshold_percentage,
+    executeThresholdTokens: bootProjectDeps.config.execute_threshold_tokens,
+    resolveRuntimeDeps: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        db,
+        runner: wrapupRunner,
+        historianModel: current.historianConfig?.model,
+        historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(current.historianConfig?.model)),
+        historianFallbacks: current.historianConfig?.fallbackModels,
+        historianTimeoutMs: current.config.historian_timeout_ms,
+        historianThinkingLevel: current.historianConfig?.thinkingLevel,
+        language: current.config.language,
+        memoryEnabled: current.config.memory.enabled,
+        autoPromote: current.config.memory.auto_promote,
+        userMemoriesEnabled: userMemoryCollectionEnabled(current.config.dreamer),
+        executeThresholdPercentage: current.config.execute_threshold_percentage,
+        executeThresholdTokens: current.config.execute_threshold_tokens
+      };
+    }
   });
   info("registered /ctx-wrapup");
   registerCtxSessionUpgradeCommand(pi, {
     db,
-    runner: new PiSubagentRunner,
-    historianModel: historianConfig?.model,
-    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(historianConfig?.model)),
-    historianFallbacks: historianConfig?.fallbackModels,
-    historianTimeoutMs: config2.historian_timeout_ms,
-    historianThinkingLevel: historianConfig?.thinkingLevel,
-    language: config2.language,
-    memoryEnabled: config2.memory.enabled,
-    autoPromote: config2.memory.auto_promote,
-    userMemoriesEnabled: userMemoryCollectionEnabled(config2.dreamer)
+    runner: upgradeRunner,
+    historianModel: bootProjectDeps.historianConfig?.model,
+    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(bootProjectDeps.historianConfig?.model)),
+    historianFallbacks: bootProjectDeps.historianConfig?.fallbackModels,
+    historianTimeoutMs: bootProjectDeps.config.historian_timeout_ms,
+    historianThinkingLevel: bootProjectDeps.historianConfig?.thinkingLevel,
+    language: bootProjectDeps.config.language,
+    memoryEnabled: bootProjectDeps.config.memory.enabled,
+    autoPromote: bootProjectDeps.config.memory.auto_promote,
+    userMemoriesEnabled: userMemoryCollectionEnabled(bootProjectDeps.config.dreamer),
+    resolveRuntimeDeps: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        db,
+        runner: upgradeRunner,
+        historianModel: current.historianConfig?.model,
+        historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(current.historianConfig?.model)),
+        historianFallbacks: current.historianConfig?.fallbackModels,
+        historianTimeoutMs: current.config.historian_timeout_ms,
+        historianThinkingLevel: current.historianConfig?.thinkingLevel,
+        language: current.config.language,
+        memoryEnabled: current.config.memory.enabled,
+        autoPromote: current.config.memory.auto_promote,
+        userMemoriesEnabled: userMemoryCollectionEnabled(current.config.dreamer)
+      };
+    }
   });
   info("registered /ctx-session-upgrade");
   registerCtxDreamCommand(pi, {
@@ -207987,7 +208810,8 @@ async function src_default2(pi) {
     projectDir,
     projectIdentity,
     resolveProject: resolveCurrentProject,
-    dreamerEnabled: isDreamerRunnable(config2),
+    dreamerEnabled: bootProjectDeps.dreamerEnabled,
+    resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
   });
   info("registered /ctx-dream");
@@ -207995,26 +208819,27 @@ async function src_default2(pi) {
     db,
     projectDir,
     projectIdentity,
-    memoryEnabled: config2.memory.enabled,
+    memoryEnabled: bootProjectDeps.config.memory.enabled,
+    resolveMemoryEnabled: (ctx) => resolveCurrentProjectDeps(ctx).config.memory.enabled,
     resolveProject: resolveCurrentProject
   });
   info("registered /ctx-embed");
-  const dreamerConfig = resolveDreamerFromConfig(config2);
+  const dreamerConfig = bootProjectDeps.dreamerConfig;
   if (dreamerConfig) {
     registerPiDreamerProject({
       db,
       projectDir,
       projectIdentity,
       config: dreamerConfig,
-      embeddingConfig: config2.embedding,
-      memoryEnabled: config2.memory.enabled,
-      language: config2.language,
-      gitCommitIndexing: config2.memory.git_commit_indexing,
+      embeddingConfig: bootProjectDeps.config.embedding,
+      memoryEnabled: bootProjectDeps.config.memory.enabled,
+      language: bootProjectDeps.config.language,
+      gitCommitIndexing: bootProjectDeps.config.memory.git_commit_indexing,
       onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
     });
     info(`registered dreamer (${summarizeDreamSchedule(dreamerConfig)})`);
   } else {
-    info(isDreamerRunnable(config2) ? "registered dreamer: DISABLED (no dreamer config)" : "registered dreamer: DISABLED (dreamer.disable=true or no dreamer config)");
+    info(bootProjectDeps.dreamerEnabled ? "registered dreamer: DISABLED (no dreamer config)" : "registered dreamer: DISABLED (dreamer.disable=true or no dreamer config)");
   }
   pi.on("before_agent_start", async (event, ctx) => {
     try {
@@ -208035,13 +208860,14 @@ async function src_default2(pi) {
       }
     } catch {}
     try {
-      const currentProject = resolveCurrentProject(ctx);
+      const effectiveProjectDeps = resolveCurrentProjectDeps(ctx);
+      const currentProject = {
+        projectDir: effectiveProjectDeps.projectDir,
+        projectIdentity: effectiveProjectDeps.projectIdentity
+      };
+      const effectiveConfig = effectiveProjectDeps.config;
       seenDreamerProjectIdentities.add(currentProject.projectIdentity);
-      const switchedProject = currentProject.projectDir !== projectDir;
-      if (switchedProject)
-        ensureConfigLocationsMigrated(currentProject.projectDir);
-      const effectiveConfig = switchedProject ? loadPiConfig({ cwd: currentProject.projectDir }).config : config2;
-      const effectiveDreamerConfig = switchedProject ? resolveDreamerFromConfig(effectiveConfig) : dreamerConfig;
+      const effectiveDreamerConfig = effectiveProjectDeps.dreamerConfig;
       if (effectiveDreamerConfig) {
         try {
           registerPiDreamerProject({
@@ -208051,13 +208877,14 @@ async function src_default2(pi) {
             config: effectiveDreamerConfig,
             embeddingConfig: effectiveConfig.embedding,
             memoryEnabled: effectiveConfig.memory.enabled,
+            language: effectiveConfig.language,
             gitCommitIndexing: effectiveConfig.memory.git_commit_indexing,
             onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
           });
         } catch (err5) {
           warn("before_agent_start: registerPiDreamerProject threw:", err5);
         }
-      } else if (switchedProject) {
+      } else {
         try {
           unregisterPiDreamerProject({
             projectIdentity: currentProject.projectIdentity
@@ -208084,11 +208911,10 @@ async function src_default2(pi) {
           const smForDrain = sm;
           const canDrain = typeof smForDrain.appendCompaction === "function" && typeof smForDrain.getBranch === "function";
           if (canDrain && getPendingPiCompactionMarkerState(db, sessionId)) {
-            signalPiDeferredHistoryRefresh(sessionId);
-            signalPiPendingMaterialization(sessionId);
+            signalPiDeferredCompactionMarkerDrain(sessionId);
           }
         } catch {}
-        if (ctx.hasUI && historianConfig?.model) {
+        if (ctx.hasUI && effectiveProjectDeps.historianConfig?.model) {
           maybeSendUpgradeReminder({
             client: null,
             db,
@@ -208109,7 +208935,6 @@ async function src_default2(pi) {
         return;
       }
       const isCacheBusting = sessionId ? hasSystemPromptRefresh(sessionId) : true;
-      const effectiveDreamerRunnable = switchedProject ? isDreamerRunnable(effectiveConfig) : isDreamerRunnable(config2);
       const block = buildMagicContextBlock({
         db,
         cwd: currentProject.projectDir,
@@ -208118,7 +208943,7 @@ async function src_default2(pi) {
         includeGuidance: true,
         protectedTags: effectiveConfig.protected_tags,
         ctxReduceCallable: true,
-        dreamerEnabled: effectiveDreamerRunnable,
+        dreamerEnabled: effectiveProjectDeps.dreamerEnabled,
         temporalAwarenessEnabled: effectiveConfig.temporal_awareness ?? false,
         cavemanTextCompressionEnabled: effectiveConfig.caveman_text_compression?.enabled === true,
         language: effectiveConfig.language,
@@ -208176,6 +209001,10 @@ ${block}` : event.systemPrompt;
         const todoArgs = event.args;
         const todos = todoArgs?.todos;
         const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(db, sessionId) : null;
+        if (todowriteEnabled && Array.isArray(todos)) {
+          setTodoSnapshot(sessionId, todos);
+          todoOverlay?.update(sessionId);
+        }
         if (sessionMeta && !sessionMeta.isSubagent) {
           const normalizedTodos = normalizeTodoStateJson(todos);
           if (normalizedTodos !== null) {
@@ -208264,7 +209093,7 @@ ${block}` : event.systemPrompt;
         db,
         sessionId,
         message: event.message,
-        cacheTtlConfig: config2.cache_ttl
+        cacheTtlConfig: resolveCurrentProjectDeps(ctx).config.cache_ttl
       });
       const piUsage = ctx.getContextUsage?.();
       const piContextWindow = piUsage && typeof piUsage.contextWindow === "number" && piUsage.contextWindow > 0 ? piUsage.contextWindow : ctx.model?.contextWindow ?? 0;
@@ -208306,6 +209135,10 @@ ${block}` : event.systemPrompt;
               const normalized = normalizeTodoStateJson(todos);
               if (normalized === null)
                 continue;
+              if (todowriteEnabled) {
+                setTodoSnapshot(sessionId, todos);
+                todoOverlay?.update(sessionId);
+              }
               updateSessionMeta(db, sessionId, {
                 lastTodoState: normalized
               });
@@ -208397,6 +209230,7 @@ function formatExecuteThresholdForLog(value) {
   return overrides.length > 0 ? `${base} (${overrides.join(", ")})` : base;
 }
 export {
+  signalPiDeferredCompactionMarkerDrain,
   resolveSidekickFromConfig,
   resolveHistorianFromConfig,
   resolveDreamerFromConfig,