@cortexkit/pi-magic-context 0.33.1 → 0.34.1

package/dist/index.js

@@ -1,5 +1,7 @@
 import {
   AGE_RECLAIM_MIN_TOKENS,
+  BoundedSessionMap,
+  COMPACTION_ENABLED_PATH,
   COMPARTMENT_LEASE_RENEWAL_MS,
   COMPARTMENT_RENDER_EPOCH,
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
@@ -10,6 +12,8 @@ import {
   Database,
   GIT_SWEEP_LEASE_RENEWAL_MS,
   GLOBAL_USER_PROFILE_PROJECT_PATH,
+  LATEST_SUPPORTED_VERSION,
+  MAX_EXECUTE_THRESHOLD,
   PRIMER_CANDIDATE_MAX_AGE_MS,
   PRIMER_CANDIDATE_TTL_MS,
   ProjectIdentityError,
@@ -57,6 +61,7 @@ import {
   clearInjectionCache,
   clearMemoryVerifications,
   clearPendingCompactionMarkerStateIf,
+  clearPendingOps,
   clearPendingPiCompactionMarkerStateIf,
   clearPersistedReasoningWatermark,
   clearPersistedTodoSyntheticAnchor,
@@ -89,6 +94,7 @@ import {
   encodeCachedM0UpgradeIdentity,
   enqueueShadowEmbeddingItems,
   ensureProjectRegisteredFromPiDirectory,
+  escalationBands,
   escapeXmlAttr,
   escapeXmlContent,
   estimateTokens,
@@ -109,6 +115,7 @@ import {
   getAutoSearchHintDecisions,
   getCachedAbsoluteMessageCount,
   getChannel2NudgeState,
+  getCompactionModeRecord,
   getCompartments,
   getCompartmentsByEndMessageId,
   getContextStoreUuid,
@@ -141,6 +148,7 @@ import {
   getMemoryVerifications,
   getMessageIndexReconciliationStartOrdinal,
   getMessageIndexSourceIdentity,
+  getMigrationOnOpenRefusal,
   getModuleNoteEvaluationBridge,
   getMuralCueState,
   getNoteLastReadAt,
@@ -156,6 +164,7 @@ import {
   getPendingPiCompactionMarkerState,
   getPendingSmartNotes,
   getPersistedNoteNudge,
+  getPersistedSchemaVersion,
   getPersistedTodoSyntheticAnchor,
   getPersistedToolTagAccounting,
   getPrimerCandidatesByIds,
@@ -191,6 +200,7 @@ import {
   hasMeaningfulUserText,
   hasMemoryClassifiedAtColumn,
   hasMemoryShareableColumn,
+  hasMuralCueColumns,
   hasPiFallbackMessageTags,
   hasPiFallbackToolOwnerTags,
   incrementHistorianFailure,
@@ -203,11 +213,13 @@ import {
   insertUserMemory,
   insertUserMemoryCandidates,
   invalidateMemory,
+  isCompactionEnabled,
   isCompartmentLeaseHeld,
   isDreamerRunnable,
   isEditTool,
   isMessageIndexReconciledThrough,
   isMessageIndexSourceCurrent,
+  isMidTurn,
   isMidTurnPi,
   isRecord,
   isSaneLimit,
@@ -282,7 +294,9 @@ import {
   reserveProtectedTailDrainTokens,
   resetLastNudgeCycle,
   resetLastNudgeCycleIfTailShrank,
+  resolveCompactionModeRecord,
   resolveGitTopLevel,
+  resolveLimit,
   resolveModelRefForPi,
   resolveMuralWire,
   resolvePiStableId,
@@ -298,6 +312,7 @@ import {
   saveSourceContent,
   scheduleAfterBootQuiet,
   setChannel2NudgeState,
+  setCompactionModeRecord,
   setDeferredExecutePendingIfAbsent,
   setEmergencyDropSample,
   setLastNudgeLevel,
@@ -312,6 +327,7 @@ import {
   setRecompPartialRange,
   setSessionWorkMetrics,
   setSqlitePragmaConfig,
+  setStoragePrivatePermissionEnforcement,
   setTodoSnapshot,
   sourceNameForMemory,
   stableStringify,
@@ -346,7 +362,10 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-e3kftg52.js";
+} from "./index-ekzg3w5y.js";
+import {
+  pushNotification
+} from "./index-hw34xmzk.js";
 import {
   ensureCortexKitArtifactGitignore,
   getHarness,
@@ -425,6 +444,16 @@ var CANONICAL_DREAM_TASKS = [
   "promote-primers",
   "refresh-primers"
 ];
+function formatDreamTaskBacklogs(backlogs, tasks = CANONICAL_DREAM_TASKS) {
+  return tasks.filter((task) => backlogs[task] !== undefined).map((task) => {
+    const backlog = backlogs[task];
+    return `- ${task}: ${backlog?.pending ?? 0} pending / ${backlog?.total ?? 0} total`;
+  }).join(`
+`);
+}
+function processedDreamTaskItems(startPending, endPending) {
+  return Math.max(0, startPending - endPending);
+}
 var MEMORY_DOMAIN_TASKS = [
   "map-memories",
   "verify",
@@ -528,14 +557,41 @@ function isMagicContextHiddenAgentName(agent) {
     return true;
   return false;
 }
+var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
+function formatFailClosedBlockingProcesses(processes) {
+  const uniqueProcesses = new Map;
+  for (const process2 of processes) {
+    if (!process2.harness.trim() || !Number.isInteger(process2.pid) || process2.pid <= 0)
+      continue;
+    uniqueProcesses.set(`${process2.harness}\x00${process2.pid}`, {
+      harness: process2.harness.trim(),
+      pid: process2.pid
+    });
+  }
+  const entries = [...uniqueProcesses.values()];
+  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
+  const rendered = visible.map(({ harness, pid }) => `${harness} (PID ${pid})`);
+  const omitted = entries.length - visible.length;
+  if (omitted > 0)
+    rendered.push(`${omitted} more blocking process(es)`);
+  if (rendered.length === 0)
+    return "a live harness process";
+  if (rendered.length === 1)
+    return rendered[0];
+  const last = rendered.pop();
+  return `${rendered.join(", ")}, and ${last}`;
+}
 function formatFailClosedBlockingMessage(reason) {
+  if (reason.kind === "migration_guard") {
+    return [
+      `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
+      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+    ].join(" ");
+  }
   if (reason.kind === "schema_fence") {
     return [
-      `Magic Context cannot operate: shared database schema v${reason.persistedVersion}`,
-      `is newer than this build supports (max v${reason.supportedVersion}).`,
-      "A newer OpenCode/Pi instance upgraded the database; this build fail-closed",
-      "so it cannot corrupt the cache or silently fall back to native compaction.",
-      `Update or unpin Magic Context on this harness, then restart.`,
+      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
       `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
     ].join(" ");
   }
@@ -596,7 +652,7 @@ function createFailClosedController(options) {
       const shouldReprobe = typeof input.tryReopen === "function" && (blockedPassCount === 1 || blockedPassCount % reprobeEveryN === 0);
       if (shouldReprobe) {
         try {
-          const healed = await input.tryReopen();
+          const healed = await input.tryReopen?.();
           if (healed) {
             reason = null;
             blockedPassCount = 0;
@@ -779,6 +835,7 @@ var OVERFLOW_PATTERNS = [
   /maximum prompt length is \d+/i,
   /reduce the length of the messages/i,
   /maximum context length is \d+ tokens/i,
+  /maximum model length is \d+/i,
   /exceeds the limit of \d+/i,
   /exceeds the available context size/i,
   /greater than the context length/i,
@@ -794,15 +851,25 @@ var OVERFLOW_PATTERNS = [
   /context size has been exceeded/i
 ];
 var LIMIT_EXTRACTION_PATTERNS = [
-  /maximum prompt length is (\d+)/i,
-  /maximum context length is (\d+) tokens?/i,
-  /context length is only (\d+) tokens?/i,
-  /exceeds the limit of (\d+)/i,
-  /too large for model with (\d+) maximum context length/i,
-  /context size.*(\d+) tokens?/i,
-  /exceeds? the context length of (\d+)/i,
-  />\s*(\d+)\s*(?:tokens?\s*)?(?:maximum|max|limit)\b/i,
-  /max(?:imum)?.*context.*?(\d+)/i
+  { pattern: /maximum prompt length is (\d+)/i, provenance: "prompt_only" },
+  {
+    pattern: /maximum context length is (\d+) tokens?/i,
+    provenance: "combined"
+  },
+  { pattern: /maximum model length is (\d+)/i, provenance: "combined" },
+  { pattern: /context length is only (\d+) tokens?/i, provenance: "combined" },
+  { pattern: /exceeds the limit of (\d+)/i, provenance: "unknown" },
+  {
+    pattern: /too large for model with (\d+) maximum context length/i,
+    provenance: "combined"
+  },
+  { pattern: /context size.*(\d+) tokens?/i, provenance: "combined" },
+  { pattern: /exceeds? the context length of (\d+)/i, provenance: "combined" },
+  {
+    pattern: />\s*(\d+)\s*(?:tokens?\s*)?(?:maximum|max|limit)\b/i,
+    provenance: "prompt_only"
+  },
+  { pattern: /max(?:imum)?.*context.*?(\d+)/i, provenance: "unknown" }
 ];
 var MIN_PLAUSIBLE_LIMIT = 1024;
 var MAX_PLAUSIBLE_LIMIT = 1e7;
@@ -853,14 +920,15 @@ function detectOverflow(error) {
   const reportedLimit = parseReportedLimit(message);
   return {
     isOverflow: true,
-    reportedLimit,
+    reportedLimit: reportedLimit?.value,
+    reportedLimitProvenance: reportedLimit?.provenance,
     matchedPattern: matched?.source
   };
 }
 function parseReportedLimit(message) {
   if (!message)
     return;
-  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
+  for (const { pattern, provenance } of LIMIT_EXTRACTION_PATTERNS) {
     const match = message.match(pattern);
     if (!match)
       continue;
@@ -872,7 +940,7 @@ function parseReportedLimit(message) {
       continue;
     if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
       continue;
-    return value;
+    return { value, provenance };
   }
   return;
 }
@@ -1354,6 +1422,15 @@ async function runDeferredV22Backfill(db, options = {}) {
   };
 }
 
+// ../plugin/src/hooks/magic-context/ctx-reduce-availability.ts
+var ctxReduceRegisteredGlobally = true;
+function setCtxReduceRegisteredGlobally(registered) {
+  ctxReduceRegisteredGlobally = registered;
+}
+var availabilityBySession = new BoundedSessionMap(1000);
+var permissionDeniedBySession = new BoundedSessionMap(2000);
+var ctxReducePermissionDenyLogged = new BoundedSessionMap(1000);
+
 // ../plugin/src/hooks/magic-context/derive-budgets.ts
 var TRIGGER_BUDGET_PERCENTAGE = 0.05;
 var TRIGGER_BUDGET_MIN = 5000;
@@ -1397,7 +1474,6 @@ function resolveHistorianContextLimit(historianModelOverride) {
 
 // ../plugin/src/hooks/magic-context/event-resolvers.ts
 var DEFAULT_CONTEXT_LIMIT = 128000;
-var MAX_EXECUTE_THRESHOLD = 80;
 function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
     return cacheTtl;
@@ -1442,7 +1518,7 @@ function resolveExecuteThresholdDetail(config, modelKey, fallback, options) {
         const dedupeKey = `${options.sessionId ?? "__global__"}|${modelKey ?? "__default__"}|${tokenMatch.value}|${cap}`;
         if (!clampWarnSeen.has(dedupeKey)) {
           clampWarnSeen.add(dedupeKey);
-          const msg = `execute_threshold_tokens clamped: ${tokenMatch.value} → ${effectiveTokens} (80% of ${contextLimit}) for ${modelKey ?? "default"}`;
+          const msg = `execute_threshold_tokens clamped: ${tokenMatch.value} → ${effectiveTokens} (${MAX_EXECUTE_THRESHOLD}% of ${contextLimit}) for ${modelKey ?? "default"}`;
           if (options.sessionId) {
             sessionLog(options.sessionId, `WARN: ${msg}`);
           } else {
@@ -1498,7 +1574,7 @@ function resolveExecuteThresholdDetail(config, modelKey, fallback, options) {
     const dedupeKey = `pct|${options?.sessionId ?? "__global__"}|${modelKey ?? "__default__"}|${resolved}`;
     if (!clampWarnSeen.has(dedupeKey)) {
       clampWarnSeen.add(dedupeKey);
-      const msg = `execute_threshold clamped ${resolved}% → ${MAX_EXECUTE_THRESHOLD}% for ${modelKey ?? "default"} (capped for cache safety; a large step can overflow before compaction, and 80% stays below the 85%/95% emergency bands)`;
+      const msg = `execute_threshold clamped ${resolved}% → ${MAX_EXECUTE_THRESHOLD}% for ${modelKey ?? "default"} (capped against the output-reserved safe window; 10% remains for mid-turn growth before the absolute 95% wall)`;
       if (options?.sessionId) {
         sessionLog(options.sessionId, `WARN: ${msg}`);
       } else {
@@ -1990,6 +2066,57 @@ import {
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 
+// ../plugin/src/features/magic-context/schema-fence-probe.ts
+var STALE_CHILD_SPAWN_FAILURE = "stale_schema_fence";
+var STALE_CHILD_SPAWN_LATCH_THRESHOLD = 2;
+var state = {
+  consecutiveFailures: 0,
+  totalFailures: 0,
+  latched: false,
+  noticeEmitted: false,
+  failure: null
+};
+function recordStaleFence(persistedVersion, supportedVersion) {
+  state.consecutiveFailures += 1;
+  state.totalFailures += 1;
+  const latched = state.consecutiveFailures >= STALE_CHILD_SPAWN_LATCH_THRESHOLD;
+  state.latched ||= latched;
+  const failure = {
+    failureClass: STALE_CHILD_SPAWN_FAILURE,
+    persistedVersion,
+    supportedVersion,
+    consecutiveFailures: state.consecutiveFailures,
+    totalFailures: state.totalFailures,
+    latched: state.latched
+  };
+  state.failure = failure;
+  const shouldSurface = state.latched && !state.noticeEmitted;
+  if (shouldSurface)
+    state.noticeEmitted = true;
+  return { allowSpawn: false, failure, shouldSurface };
+}
+function probeChildSpawnFence(db) {
+  if (!db) {
+    const knownRejection = getSchemaFenceRejection();
+    if (knownRejection) {
+      return recordStaleFence(knownRejection.persistedVersion, knownRejection.supportedVersion);
+    }
+    return { allowSpawn: true };
+  }
+  try {
+    const persistedVersion = getPersistedSchemaVersion(db);
+    if (persistedVersion > LATEST_SUPPORTED_VERSION) {
+      return recordStaleFence(persistedVersion, LATEST_SUPPORTED_VERSION);
+    }
+  } catch {
+    return { allowSpawn: true };
+  }
+  state.consecutiveFailures = 0;
+  state.latched = false;
+  state.noticeEmitted = false;
+  return { allowSpawn: true };
+}
+
 // ../plugin/src/features/magic-context/subagent-token-capture.ts
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
@@ -2338,6 +2465,10 @@ class PiSubagentRunner {
     if (ZERO_TOOL_PROMPT_REQUIRED_AGENTS.has(options.agent) && options.systemPrompt.trim().length === 0) {
       return failBeforeSpawn("invalid_prompt", `zero-tool Pi subagent "${options.agent}" requires a non-empty system prompt`, true);
     }
+    const fence = probeChildSpawnFence(openDatabase());
+    if (!fence.allowSpawn) {
+      return failBeforeSpawn("spawn_failed", `Magic Context: plugin build is older than its database (database=v${fence.failure.persistedVersion}, supported_fence=v${fence.failure.supportedVersion}) — restart Pi.`);
+    }
     const promptBytes = Buffer.byteLength(options.userMessage, "utf8");
     const deliverViaStdin = promptBytes > PROMPT_ARGV_MAX_BYTES || this.platform === "win32";
     let systemPromptTempDir;
@@ -2909,7 +3040,7 @@ function registerCtxAugCommand(pi, config) {
       sessionLog(sessionLabel, "/ctx-aug: spawning sidekick", {
         model: currentConfig.model
       });
-      const projectIdentity = resolveProjectIdentityForSession(ctx.cwd);
+      const projectIdentity = resolveProjectIdentityForSession(ctx.cwd, currentConfig.allowHomeProject);
       if (!projectIdentity) {
         sessionLog(sessionLabel, "Error: Could not resolve project identity for sidekick.");
         return;
@@ -2952,6 +3083,394 @@ ${sidekickText}
   });
 }
 
+// ../plugin/src/features/magic-context/smart-notes/types.ts
+var SMART_NOTE_CHECK_POLICY_VERSION = 1;
+var SMART_NOTE_CHECK_FLOOR_MS = 5 * 60 * 1000;
+var SMART_NOTE_CHECK_CEILING_MS = 24 * 60 * 60 * 1000;
+var SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+var SMART_NOTE_CHECK_MAX_STALENESS_MS = 7 * 24 * 60 * 60 * 1000;
+var SMART_NOTE_CHECK_LIVENESS_RECHECK_MS = 24 * 60 * 60 * 1000;
+
+class SmartNoteNetworkError extends Error {
+  isSmartNoteNetworkError = true;
+  terminal;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "SmartNoteNetworkError";
+    this.terminal = options.terminal ?? false;
+  }
+}
+
+class SmartNoteSecurityError extends Error {
+  isSmartNoteSecurityError = true;
+  constructor(message) {
+    super(message);
+    this.name = "SmartNoteSecurityError";
+  }
+}
+function isSmartNoteNetworkError(error) {
+  return error instanceof SmartNoteNetworkError || error instanceof Error && (error.name === "SmartNoteNetworkError" || error.message.includes("SmartNoteNetworkError") || error.message.includes("SMART_NOTE_NETWORK"));
+}
+function isTerminalSmartNoteNetworkError(error) {
+  return error instanceof SmartNoteNetworkError && error.terminal;
+}
+function parseSmartNoteManifest(json) {
+  if (!json)
+    return { capabilities: [] };
+  try {
+    const parsed = JSON.parse(json);
+    const capabilities = Array.isArray(parsed.capabilities) ? parsed.capabilities.filter((c) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(c))) : [];
+    return {
+      capabilities,
+      readFiles: stringArray(parsed.readFiles),
+      hosts: stringArray(parsed.hosts),
+      urls: stringArray(parsed.urls),
+      signals: stringArray(parsed.signals),
+      summary: typeof parsed.summary === "string" ? parsed.summary : undefined
+    };
+  } catch {
+    return { capabilities: [] };
+  }
+}
+function stringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const arr = value.filter((item) => typeof item === "string");
+  return arr.length > 0 ? arr : undefined;
+}
+
+// ../plugin/src/features/magic-context/smart-notes/storage.ts
+function toSmartNote(note) {
+  return {
+    ...note,
+    checkStatus: note.checkStatus ?? "uncompiled",
+    checkFailureCount: note.checkFailureCount ?? 0,
+    checkNetworkFailureCount: note.checkNetworkFailureCount ?? 0,
+    policyVersion: note.policyVersion ?? 0
+  };
+}
+function commitSmartNoteState(db, args) {
+  db.exec("BEGIN IMMEDIATE");
+  let leaseLost = false;
+  let committed = false;
+  try {
+    if (args.leaseHeld && !args.leaseHeld()) {
+      leaseLost = true;
+    } else if (claimExpectedState(db, args.expected)) {
+      args.write();
+      committed = true;
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+  if (leaseLost) {
+    throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
+  }
+  if (!committed) {
+    log(`[debug] smart note #${args.expected.noteId}: discarded stale ${args.phase} result`);
+  }
+  return committed;
+}
+function claimExpectedState(db, expected) {
+  if (expected.kind === "compiled-check") {
+    return db.prepare(`UPDATE notes SET id = id
+                     WHERE id = ? AND type = 'smart' AND status = 'pending'
+                       AND check_status = 'compiled' AND compiled_check = ?
+                       AND check_hash IS ? AND check_compiled_at IS ?`).run(expected.noteId, expected.compiledCheck, expected.checkHash, expected.checkCompiledAt).changes > 0;
+  }
+  const statusClause = expected.checkStatus ? " AND check_status = ?" : "";
+  const params = [
+    expected.noteId,
+    expected.content,
+    expected.surfaceCondition,
+    expected.updatedAt
+  ];
+  if (expected.checkStatus)
+    params.push(expected.checkStatus);
+  return db.prepare(`UPDATE notes SET id = id
+                 WHERE id = ? AND type = 'smart' AND status = 'pending'
+                   AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
+}
+function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function getSmartNotesNeedingCompilation(db, projectPath, now, limit) {
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function getStaleCompiledSmartNotes(db, projectPath, now, limit) {
+  const staleBefore = now - SMART_NOTE_CHECK_MAX_STALENESS_MS;
+  const livenessBefore = now - SMART_NOTE_CHECK_LIVENESS_RECHECK_MS;
+  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
+}
+function storeCompiledSmartNoteCheck(db, args) {
+  db.prepare(`UPDATE notes
+         SET compiled_check = ?,
+             manifest_json = ?,
+             check_hash = ?,
+             check_cron = ?,
+             check_version = 1,
+             check_status = 'compiled',
+             check_failure_count = 0,
+             check_network_failure_count = 0,
+             check_quarantined_until = NULL,
+             check_next_due_at = ?,
+             check_compiled_at = ?,
+             check_false_since_at = COALESCE(check_false_since_at, ?),
+             check_last_liveness_at = NULL,
+             policy_version = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(args.compiledCheck, JSON.stringify(args.manifest), args.checkHash, args.checkCron, args.nextDueAt, args.now, args.now, SMART_NOTE_CHECK_POLICY_VERSION, args.now, args.noteId);
+}
+function markCompiledCheckFalse(db, noteId, nextDueAt, now) {
+  db.prepare(`UPDATE notes
+         SET last_checked_at = ?,
+             updated_at = ?,
+             check_next_due_at = ?,
+             check_failure_count = 0,
+             check_network_failure_count = 0,
+             check_false_since_at = COALESCE(check_false_since_at, ?)
+         WHERE id = ? AND type = 'smart'`).run(now, now, nextDueAt, now, noteId);
+}
+function markCompiledCheckLogicFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
+  const status = failureCount >= maxFailures ? "failing" : "compiled";
+  db.prepare(`UPDATE notes
+         SET check_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+}
+function markCompiledCheckNetworkFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_network_failure_count") + 1;
+  const quarantinedUntil = now + backoffMs(failureCount);
+  const status = failureCount >= maxFailures ? "failing" : "compiled";
+  db.prepare(`UPDATE notes
+         SET check_network_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             check_quarantined_until = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, quarantinedUntil, quarantinedUntil, now, noteId);
+}
+function markSmartNoteLivenessChecked(db, noteId, now) {
+  db.prepare(`UPDATE notes
+         SET check_last_liveness_at = ?, updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(now, now, noteId);
+}
+function markSmartNoteCheckStatus(db, noteId, status, now) {
+  db.prepare(`UPDATE notes SET check_status = ?, updated_at = ? WHERE id = ? AND type = 'smart'`).run(status, now, noteId);
+}
+function markSmartNoteCompilationFailure(db, noteId, now, maxFailures) {
+  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
+  const status = failureCount >= maxFailures ? "fallback" : "uncompiled";
+  db.prepare(`UPDATE notes
+         SET check_failure_count = ?,
+             check_status = ?,
+             check_next_due_at = ?,
+             updated_at = ?
+         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+}
+function readFailureCount(db, noteId, column) {
+  if (column !== "check_failure_count" && column !== "check_network_failure_count")
+    return 0;
+  const row = db.prepare(`SELECT ${column} AS count FROM notes WHERE id = ?`).get(noteId);
+  return row?.count ?? 0;
+}
+function backoffMs(failureCount) {
+  const minutes = Math.min(24 * 60, 5 * 2 ** Math.max(0, failureCount - 1));
+  return minutes * 60 * 1000;
+}
+
+// ../plugin/src/features/magic-context/dreamer/task-gates.ts
+function countActiveMemories(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUnmappedActiveMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories m
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND NOT EXISTS (
+                    SELECT 1 FROM memory_verifications v WHERE v.memory_id = m.id
+                )`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countCompartmentsSince(db, projectPath, since) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM compartments c
+               JOIN session_projects sp ON sp.session_id = c.session_id
+              WHERE sp.project_path = ? AND c.created_at > ?`).get(projectPath, since);
+  return row?.cnt ?? 0;
+}
+function countProjectSessionsSince(db, projectPath, since) {
+  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ? AND updated_at > ?").get(projectPath, since);
+  return row?.cnt ?? 0;
+}
+function countMappedMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
+               FROM memories m
+               JOIN memory_verifications v ON v.memory_id = m.id
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND v.file_path <> ''`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUnverifiedMappedMemories(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
+               FROM memories m
+               JOIN memory_verifications v ON v.memory_id = m.id
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND v.file_path <> ''
+                AND v.verified_at = 0`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countCueCandidates(db, projectPath) {
+  if (!hasMuralCueColumns(db))
+    return countActiveMemories(db, projectPath);
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories
+              WHERE project_path = ?
+                AND status IN ('active','permanent')
+                AND (mural_cue IS NULL OR mural_cue_hash IS NULL OR updated_at > mural_cue_at)`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countStalePrimers(db, projectPath) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM primers
+              WHERE project_path = ?
+                AND status = 'active'
+                AND (answer IS NULL OR TRIM(answer) = '' OR answer_refreshed_at IS NULL
+                     OR last_observed_at > answer_refreshed_at)`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUnclassifiedActiveMemories(db, projectPath) {
+  if (!hasMemoryClassifiedAtColumn(db))
+    return countActiveMemories(db, projectPath);
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories
+              WHERE project_path = ?
+                AND status IN ('active','permanent')
+                AND classified_at IS NULL`).get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countPendingSmartNotes(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM notes WHERE project_path = ? AND type = 'smart' AND status = 'pending'").get(projectPath);
+  return row?.cnt ?? 0;
+}
+function countUserMemoryCandidates(db) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM user_memory_candidates").get();
+  return row?.cnt ?? 0;
+}
+function countActivePrimers(db, projectPath) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM primers WHERE project_path = ? AND status = 'active'").get(projectPath);
+  return row?.cnt ?? 0;
+}
+function getDreamTaskBacklog(db, projectPath, task, options = {}) {
+  switch (task) {
+    case "map-memories": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countUnmappedActiveMemories(db, projectPath), total };
+    }
+    case "verify": {
+      return {
+        pending: countUnverifiedMappedMemories(db, projectPath),
+        total: countMappedMemories(db, projectPath)
+      };
+    }
+    case "verify-broad": {
+      const total = countMappedMemories(db, projectPath);
+      return { pending: total, total };
+    }
+    case "curate": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: total, total };
+    }
+    case "compress-cues": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countCueCandidates(db, projectPath), total };
+    }
+    case "classify-memories": {
+      const total = countActiveMemories(db, projectPath);
+      return { pending: countUnclassifiedActiveMemories(db, projectPath), total };
+    }
+    case "retrospective": {
+      const pending = countProjectSessionsSince(db, projectPath, options.retrospectiveWatermarkMs ?? null);
+      return { pending, total: pending };
+    }
+    case "maintain-docs": {
+      const total = countCompartmentsSince(db, projectPath, 0);
+      const pending = countCompartmentsSince(db, projectPath, options.lastRunAt ?? 0);
+      return { pending, total };
+    }
+    case "evaluate-smart-notes": {
+      const pending = countPendingSmartNotes(db, projectPath);
+      return { pending, total: pending };
+    }
+    case "review-user-memories": {
+      const pending = countUserMemoryCandidates(db);
+      return { pending, total: pending };
+    }
+    case "promote-primers": {
+      const pending = countPrimerCandidatesForProject(db, projectPath);
+      return { pending, total: pending };
+    }
+    case "refresh-primers": {
+      const total = countActivePrimers(db, projectPath);
+      return { pending: countStalePrimers(db, projectPath), total };
+    }
+    default: {
+      const _exhaustive = task;
+      return _exhaustive;
+    }
+  }
+}
+function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, options = {}) {
+  const result = {};
+  for (const task of tasks)
+    result[task] = getDreamTaskBacklog(db, projectPath, task, options);
+  return result;
+}
+function evaluateTaskGate(task, ctx) {
+  const { db, projectIdentity: project, lastRunAt } = ctx;
+  switch (task) {
+    case "map-memories":
+      return countUnmappedActiveMemories(db, project) > 0;
+    case "verify":
+      return countActiveMemories(db, project) > 0;
+    case "verify-broad":
+      return countActiveMemories(db, project) > 0;
+    case "curate":
+      return countActiveMemories(db, project) > 0;
+    case "compress-cues":
+      return countActiveMemories(db, project) > 0;
+    case "classify-memories":
+      return countActiveMemories(db, project) > 0;
+    case "retrospective":
+      return countProjectSessionsSince(db, project, ctx.retrospectiveWatermarkMs ?? null) > 0;
+    case "maintain-docs":
+      return countCompartmentsSince(db, project, lastRunAt ?? 0) > 0;
+    case "evaluate-smart-notes":
+      return getSmartNotesNeedingCompilation(db, project, Date.now(), 1).length > 0 || getStaleCompiledSmartNotes(db, project, Date.now(), 1).length > 0 || getPendingSmartNotes(db, project).some((note) => note.checkStatus === "fallback");
+    case "review-user-memories":
+      return getUserMemoryCandidates(db).length >= ctx.promotionThreshold;
+    case "promote-primers":
+      return countPrimerCandidatesForProject(db, project) >= (ctx.promotionThreshold ?? 2);
+    case "refresh-primers":
+      return getActivePrimers(db, project).some((primer) => !primer.answer.trim() || primer.answerRefreshedAt == null || (primer.lastObservedAt ?? 0) > primer.answerRefreshedAt);
+    default: {
+      const _exhaustive = task;
+      return Boolean(_exhaustive);
+    }
+  }
+}
+
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
 import { existsSync as existsSync4 } from "node:fs";
 function openOpenCodeDb() {
@@ -2969,19 +3488,214 @@ function openOpenCodeDb() {
     return null;
   }
 }
-
-// ../plugin/src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync7 } from "node:fs";
-
-// ../plugin/src/agents/dreamer.ts
-var DREAMER_AGENT = "dreamer";
-var DREAMER_RETROSPECTIVE_AGENT = "dreamer-retrospective";
-var DREAMER_PRIMER_INVESTIGATOR_AGENT = "dreamer-primer-investigator";
-var DREAMER_MEMORY_MAPPER_AGENT = "dreamer-memory-mapper";
-var DREAMER_CLASSIFIER_AGENT = "dreamer-classifier";
-var DREAMER_DOCS_AGENT = "dreamer-docs";
-var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
+
+// ../plugin/src/features/magic-context/dreamer/task-executor.ts
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync7 } from "node:fs";
+
+// ../plugin/src/agents/dreamer.ts
+var DREAMER_AGENT = "dreamer";
+var DREAMER_RETROSPECTIVE_AGENT = "dreamer-retrospective";
+var DREAMER_PRIMER_INVESTIGATOR_AGENT = "dreamer-primer-investigator";
+var DREAMER_MEMORY_MAPPER_AGENT = "dreamer-memory-mapper";
+var DREAMER_CLASSIFIER_AGENT = "dreamer-classifier";
+var DREAMER_DOCS_AGENT = "dreamer-docs";
+var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
+
+// ../plugin/src/hooks/magic-context/send-session-notification.ts
+var MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
+var queuedIgnoredNotifications = new Map;
+var flushingIgnoredNotifications = new Set;
+var midTurnDetector = (sessionId) => isMidTurn(undefined, sessionId);
+function queueIgnoredNotification(notification) {
+  const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
+  queued.push(notification);
+  if (queued.length > MAX_QUEUED_IGNORED_NOTIFICATIONS) {
+    queued.splice(0, queued.length - MAX_QUEUED_IGNORED_NOTIFICATIONS);
+    sessionLog(notification.sessionId, `ignored notification queue full; dropped oldest entries (kept newest ${MAX_QUEUED_IGNORED_NOTIFICATIONS})`);
+  }
+  queuedIgnoredNotifications.set(notification.sessionId, queued);
+}
+async function trySendTuiToast(sessionId, text, params, forcePersist) {
+  if (forcePersist)
+    return false;
+  const title = extractToastTitle(text);
+  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+  const toastVariant = inferToastVariant(text);
+  const duration = params.toastDurationMs ?? 5000;
+  const { isTuiConnected: checkTui } = await import("./rpc-notifications-s2rw51c6.js");
+  if (!checkTui(sessionId))
+    return false;
+  try {
+    const { pushNotification: pushNotification2 } = await import("./rpc-notifications-s2rw51c6.js");
+    pushNotification2("toast", {
+      title,
+      message,
+      variant: toastVariant,
+      duration
+    }, sessionId);
+    return true;
+  } catch {
+    sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
+    return false;
+  }
+}
+function hasNotificationSessionClient(client) {
+  if (client === null || typeof client !== "object")
+    return false;
+  const candidate = client;
+  if (candidate.session === undefined)
+    return true;
+  if (candidate.session === null || typeof candidate.session !== "object")
+    return false;
+  const session = candidate.session;
+  return (session.prompt === undefined || typeof session.prompt === "function") && (session.promptAsync === undefined || typeof session.promptAsync === "function");
+}
+function inferToastVariant(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("error") || lower.includes("failed") || lower.includes("alert"))
+    return "error";
+  if (lower.includes("warning") || lower.includes("⚠"))
+    return "warning";
+  if (lower.includes("complete") || lower.includes("success") || lower.includes("✓") || lower.includes("finished"))
+    return "success";
+  return "info";
+}
+function extractToastTitle(text) {
+  const headingMatch = text.match(/^#+\s+(.+)/m);
+  if (headingMatch)
+    return headingMatch[1].trim();
+  const firstLine = text.split(`
+`)[0].trim();
+  if (firstLine.length <= 80)
+    return firstLine;
+  return "Magic Context";
+}
+async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
+  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-ng8ygena.js");
+  if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
+    sessionLog(sessionId, "notification skipped (session not titled yet)");
+    return "skipped";
+  }
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
+  if (!hasNotificationSessionClient(client)) {
+    sessionLog(sessionId, "session prompt API unavailable for notification");
+    return "failed";
+  }
+  const c = client;
+  let agent = params.agent || undefined;
+  let variant = params.variant || undefined;
+  let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
+  if (!agent || !model || !variant) {
+    try {
+      const { resolvePromptContext } = await import("./prompt-context-602yq94t.js");
+      const resolved = await resolvePromptContext(client, sessionId);
+      if (resolved) {
+        agent = agent ?? resolved.agent;
+        model = model ?? resolved.model;
+        variant = variant ?? resolved.variant;
+      }
+    } catch {}
+  }
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
+  const input = {
+    path: { id: sessionId },
+    body: {
+      noReply: true,
+      agent,
+      model,
+      variant,
+      parts: [
+        {
+          type: "text",
+          text,
+          ignored: true
+        }
+      ]
+    }
+  };
+  try {
+    if (typeof c.session?.prompt === "function") {
+      await Promise.resolve(c.session.prompt(input));
+      return "sent";
+    }
+    if (typeof c.session?.promptAsync === "function") {
+      await c.session.promptAsync(input);
+      return "sent";
+    }
+    sessionLog(sessionId, "session prompt API unavailable for notification");
+    return "failed";
+  } catch (error) {
+    const msg = getErrorMessage(error);
+    sessionLog(sessionId, "failed to send notification:", msg);
+    return "failed";
+  }
+}
+async function sendIgnoredMessage(client, sessionId, text, params, forcePersist = false) {
+  if (await trySendTuiToast(sessionId, text, params, forcePersist))
+    return "sent";
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
+  return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
+}
+
+// ../plugin/src/hooks/magic-context/child-session-spawn.ts
+var STALE_PLUGIN_RESTART_NOTICE = "Magic Context: plugin build is older than its database — restart OpenCode";
+async function surfaceStalePluginBuild(args) {
+  if (!args.parentSessionId)
+    return;
+  try {
+    if (args.db) {
+      updateSessionMeta(args.db, args.parentSessionId, {
+        lastTransformError: STALE_PLUGIN_RESTART_NOTICE
+      });
+    }
+    pushNotification("toast", {
+      title: "Magic Context",
+      message: STALE_PLUGIN_RESTART_NOTICE,
+      variant: "error",
+      duration: 1e4
+    }, args.parentSessionId);
+    pushNotification("action", { action: "refresh-sidebar" }, args.parentSessionId);
+    await sendIgnoredMessage(args.client, args.parentSessionId, STALE_PLUGIN_RESTART_NOTICE, args.notificationParams ?? {}, true);
+  } catch (error) {
+    sessionLog(args.parentSessionId, `stale plugin-build warning delivery failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function createChildSessionWithFence(args) {
+  const verdict = probeChildSpawnFence(args.db);
+  if (!verdict.allowSpawn) {
+    if (args.parentSessionId) {
+      sessionLog(args.parentSessionId, `child session skipped (${verdict.failure.failureClass}): database=v${verdict.failure.persistedVersion}, supported_fence=v${verdict.failure.supportedVersion}, consecutive=${verdict.failure.consecutiveFailures}, total=${verdict.failure.totalFailures}`);
+    }
+    if (verdict.shouldSurface) {
+      if (args.onFenceLatched)
+        await args.onFenceLatched(verdict.failure);
+      else
+        await surfaceStalePluginBuild(args);
+    }
+    return null;
+  }
+  return args.client.session.create({
+    body: {
+      ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
+      title: args.title
+    },
+    query: { directory: args.directory }
+  });
+}
 // ../plugin/src/shared/model-suggestion-retry.ts
 var ABORT_CALL_TIMEOUT_MS = 3000;
 function copyPromptArgs(args, body) {
@@ -3635,7 +4349,7 @@ function parseCuesManifest(text) {
   const body = extractCompleteManifestBody(text, "cues");
   const out = [];
   for (const match of body.matchAll(/<cue\s+id="(\d+)"\s*>([\s\S]*?)<\/cue>/g)) {
-    const id = Number.parseInt(match[1], 10);
+    const id = Number.parseInt(match[1] ?? "", 10);
     if (!Number.isInteger(id))
       continue;
     out.push({ id, cue: unescapeXml(match[2] ?? "").trim() });
@@ -3736,11 +4450,15 @@ async function runCompressCues(args) {
         break;
       }
       const sliceMs = computeChunkSliceMs(remainingMs, chunks.length - i);
-      const outcome = await compressOneChunk(args, chunks[i], sliceMs, abortController.signal);
+      const chunk = chunks[i];
+      if (!chunk)
+        break;
+      const outcome = await compressOneChunk(args, chunk, sliceMs, abortController.signal);
       result.compressed += outcome.compressed;
       result.skipped += outcome.skipped;
       result.remaining -= outcome.compressed;
       result.chunks += 1;
+      args.onProgress?.(result.compressed + result.skipped);
       if (outcome.failure?.class === "timeout") {
         consecutiveTimeouts += 1;
         timeoutStreakElapsedMs.push(outcome.failure.elapsedMs);
@@ -3771,12 +4489,12 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
       projectPath: args.projectIdentity,
       memories: chunk.map(toPromptMemory)
     });
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-compress-cues"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-compress-cues",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -4260,12 +4978,12 @@ If no promotions are warranted, return empty arrays. Always consume reviewed can
     abortController.abort();
   });
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-user-memories"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-user-memories",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof created?.id === "string" ? created.id : null;
@@ -4836,6 +5554,7 @@ async function runClassify(args) {
       result.changed += counts.changed;
       result.remaining -= counts.classified;
       result.chunks += 1;
+      args.onProgress?.(result.classified);
     }
     result.complete = result.remaining === 0;
     log(`[dreamer] classify: stage=${stage} classified=${result.classified} changed=${result.changed} chunks=${result.chunks} remaining=${result.remaining} complete=${result.complete}`);
@@ -4859,12 +5578,12 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       recordInvocation(args, startedAt, { status: "completed" });
       return run2;
     }
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-classify"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-classify",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -5096,64 +5815,6 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import * as https from "node:https";
 import { isIP } from "node:net";
 import { domainToASCII } from "node:url";
-
-// ../plugin/src/features/magic-context/smart-notes/types.ts
-var SMART_NOTE_CHECK_POLICY_VERSION = 1;
-var SMART_NOTE_CHECK_FLOOR_MS = 5 * 60 * 1000;
-var SMART_NOTE_CHECK_CEILING_MS = 24 * 60 * 60 * 1000;
-var SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
-var SMART_NOTE_CHECK_MAX_STALENESS_MS = 7 * 24 * 60 * 60 * 1000;
-var SMART_NOTE_CHECK_LIVENESS_RECHECK_MS = 24 * 60 * 60 * 1000;
-
-class SmartNoteNetworkError extends Error {
-  isSmartNoteNetworkError = true;
-  terminal;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "SmartNoteNetworkError";
-    this.terminal = options.terminal ?? false;
-  }
-}
-
-class SmartNoteSecurityError extends Error {
-  isSmartNoteSecurityError = true;
-  constructor(message) {
-    super(message);
-    this.name = "SmartNoteSecurityError";
-  }
-}
-function isSmartNoteNetworkError(error) {
-  return error instanceof SmartNoteNetworkError || error instanceof Error && (error.name === "SmartNoteNetworkError" || error.message.includes("SmartNoteNetworkError") || error.message.includes("SMART_NOTE_NETWORK"));
-}
-function isTerminalSmartNoteNetworkError(error) {
-  return error instanceof SmartNoteNetworkError && error.terminal;
-}
-function parseSmartNoteManifest(json) {
-  if (!json)
-    return { capabilities: [] };
-  try {
-    const parsed = JSON.parse(json);
-    const capabilities = Array.isArray(parsed.capabilities) ? parsed.capabilities.filter((c) => ["readFile", "gitHeadSha", "gitTag", "gitLog", "httpGet"].includes(String(c))) : [];
-    return {
-      capabilities,
-      readFiles: stringArray(parsed.readFiles),
-      hosts: stringArray(parsed.hosts),
-      urls: stringArray(parsed.urls),
-      signals: stringArray(parsed.signals),
-      summary: typeof parsed.summary === "string" ? parsed.summary : undefined
-    };
-  } catch {
-    return { capabilities: [] };
-  }
-}
-function stringArray(value) {
-  if (!Array.isArray(value))
-    return;
-  const arr = value.filter((item) => typeof item === "string");
-  return arr.length > 0 ? arr : undefined;
-}
-
-// ../plugin/src/features/magic-context/smart-notes/ssrf-guard.ts
 var DNS_TIMEOUT_MS = 3000;
 var DEFAULT_HTTP_TIMEOUT_MS = 5000;
 var DEFAULT_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
@@ -5676,7 +6337,7 @@ function getAsyncModule() {
   asyncModulePromise ??= (async () => {
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await Promise.all([
       import("./index-ayd60xnw.js").then((m)=>__toESM(m.default,1)),
-      import("./index-v7fmc1s2.js")
+      import("./index-3pnd4qh9.js")
     ]);
     return newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
   })();
@@ -5895,12 +6556,12 @@ Remember: output only the JSON object described by the system prompt.`;
     });
   };
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: `magic-context-smart-note-compile-${args.note.id}`
-      },
-      query: { directory: args.sessionDirectory ?? args.projectIdentity }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db ?? null,
+      parentSessionId: args.parentSessionId,
+      title: `magic-context-smart-note-compile-${args.note.id}`,
+      directory: args.sessionDirectory ?? args.projectIdentity
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -6077,213 +6738,66 @@ function capabilityUses(code) {
   const uses = new Set;
   const regex = /\bcap\s*\.\s*(readFile|gitHeadSha|gitTag|gitLog|httpGet)\s*\(/g;
   for (const match of code.matchAll(regex))
-    uses.add(match[1]);
-  return uses;
-}
-function literalCalls(code, method) {
-  const regex = new RegExp(`\\bcap\\s*\\.\\s*${method}\\s*\\(\\s*(["'])((?:\\\\.|(?!\\1)[^\\\\])*)\\1`, "g");
-  const values = [];
-  for (const match of code.matchAll(regex)) {
-    values.push(match[2].replace(/\\([\\"'])/g, "$1"));
-  }
-  return values;
-}
-function normalizeCron(cron) {
-  if (cron.length > MAX_CRON_CHARS)
-    throw new Error("check_cron exceeds 256 characters");
-  const normalized = cron.trim() || "0 * * * *";
-  const parsed = parseCron(normalized);
-  if (!parsed.ok)
-    throw new Error(`invalid check_cron: ${parsed.error}`);
-  const next = nextOccurrence(parsed.cron, new Date, undefined, SMART_NOTE_CHECK_CEILING_MS);
-  if (!next)
-    throw new Error("check_cron has no occurrence within the scheduling ceiling");
-  return normalized;
-}
-function unique(items) {
-  return [...new Set(items)];
-}
-function uniqueStrings(items, normalize = (value) => value) {
-  if (!Array.isArray(items))
-    return;
-  const values = unique(items.slice(0, MAX_MANIFEST_ENTRIES).filter((item) => typeof item === "string" && item.length > 0).map(normalize));
-  return values.length > 0 ? values : undefined;
-}
-function boundedError(error) {
-  return error.slice(0, MAX_COMPILER_ERROR_CHARS);
-}
-
-// ../plugin/src/features/magic-context/smart-notes/schedule.ts
-function nextSmartNoteCheckDueAt(cron, options = {}) {
-  const now = options.now ?? Date.now();
-  const floorMs = options.floorMs ?? SMART_NOTE_CHECK_FLOOR_MS;
-  const ceilingMs = options.ceilingMs ?? SMART_NOTE_CHECK_CEILING_MS;
-  const rawNext = cron?.trim() ? nextDueAtMs(cron, now, undefined, ceilingMs) : null;
-  const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
-  const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
-  const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
-  const bounded = Math.min(ceilingMs, Math.max(floorMs, jittered));
-  return now + bounded;
-}
-function deterministicJitterMs(intervalMs, noteId, hash) {
-  const max = Math.min(60000, Math.floor(intervalMs * 0.1));
-  if (max <= 0)
-    return 0;
-  const seed = `${noteId ?? 0}:${hash ?? ""}`;
-  let h = 2166136261;
-  for (let i = 0;i < seed.length; i++) {
-    h ^= seed.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  const unsigned = h >>> 0;
-  return unsigned % (max * 2 + 1) - max;
-}
-
-// ../plugin/src/features/magic-context/smart-notes/storage.ts
-function toSmartNote(note) {
-  return {
-    ...note,
-    checkStatus: note.checkStatus ?? "uncompiled",
-    checkFailureCount: note.checkFailureCount ?? 0,
-    checkNetworkFailureCount: note.checkNetworkFailureCount ?? 0,
-    policyVersion: note.policyVersion ?? 0
-  };
-}
-function commitSmartNoteState(db, args) {
-  db.exec("BEGIN IMMEDIATE");
-  let leaseLost = false;
-  let committed = false;
-  try {
-    if (args.leaseHeld && !args.leaseHeld()) {
-      leaseLost = true;
-    } else if (claimExpectedState(db, args.expected)) {
-      args.write();
-      committed = true;
-    }
-    db.exec("COMMIT");
-  } catch (error) {
-    try {
-      db.exec("ROLLBACK");
-    } catch {}
-    throw error;
-  }
-  if (leaseLost) {
-    throw new Error(`Dream lease lost during smart-note ${args.phase} commit`);
-  }
-  if (!committed) {
-    log(`[debug] smart note #${args.expected.noteId}: discarded stale ${args.phase} result`);
-  }
-  return committed;
-}
-function claimExpectedState(db, expected) {
-  if (expected.kind === "compiled-check") {
-    return db.prepare(`UPDATE notes SET id = id
-                     WHERE id = ? AND type = 'smart' AND status = 'pending'
-                       AND check_status = 'compiled' AND compiled_check = ?
-                       AND check_hash IS ? AND check_compiled_at IS ?`).run(expected.noteId, expected.compiledCheck, expected.checkHash, expected.checkCompiledAt).changes > 0;
-  }
-  const statusClause = expected.checkStatus ? " AND check_status = ?" : "";
-  const params = [
-    expected.noteId,
-    expected.content,
-    expected.surfaceCondition,
-    expected.updatedAt
-  ];
-  if (expected.checkStatus)
-    params.push(expected.checkStatus);
-  return db.prepare(`UPDATE notes SET id = id
-                 WHERE id = ? AND type = 'smart' AND status = 'pending'
-                   AND content = ? AND surface_condition IS ? AND updated_at = ?${statusClause}`).run(...params).changes > 0;
-}
-function getDueCompiledSmartNoteChecks(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && (note.checkQuarantinedUntil === null || note.checkQuarantinedUntil <= now) && (note.checkNextDueAt === null || note.checkNextDueAt <= now)).sort((a, b) => (a.checkNextDueAt ?? 0) - (b.checkNextDueAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function getSmartNotesNeedingCompilation(db, projectPath, now, limit) {
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => (note.checkNextDueAt === null || note.checkNextDueAt <= now) && (note.checkStatus === "uncompiled" || note.checkStatus === "failing" || note.compiledCheck === null || note.policyVersion !== SMART_NOTE_CHECK_POLICY_VERSION)).sort((a, b) => a.createdAt - b.createdAt || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function getStaleCompiledSmartNotes(db, projectPath, now, limit) {
-  const staleBefore = now - SMART_NOTE_CHECK_MAX_STALENESS_MS;
-  const livenessBefore = now - SMART_NOTE_CHECK_LIVENESS_RECHECK_MS;
-  return getPendingSmartNotes(db, projectPath).map(toSmartNote).filter((note) => note.checkStatus === "compiled" && note.compiledCheck !== null && note.policyVersion === SMART_NOTE_CHECK_POLICY_VERSION && note.checkFalseSinceAt !== null && note.checkFalseSinceAt <= staleBefore && (note.checkLastLivenessAt === null || note.checkLastLivenessAt <= livenessBefore)).sort((a, b) => (a.checkFalseSinceAt ?? 0) - (b.checkFalseSinceAt ?? 0) || a.id - b.id).slice(0, Math.max(1, limit));
-}
-function storeCompiledSmartNoteCheck(db, args) {
-  db.prepare(`UPDATE notes
-         SET compiled_check = ?,
-             manifest_json = ?,
-             check_hash = ?,
-             check_cron = ?,
-             check_version = 1,
-             check_status = 'compiled',
-             check_failure_count = 0,
-             check_network_failure_count = 0,
-             check_quarantined_until = NULL,
-             check_next_due_at = ?,
-             check_compiled_at = ?,
-             check_false_since_at = COALESCE(check_false_since_at, ?),
-             check_last_liveness_at = NULL,
-             policy_version = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(args.compiledCheck, JSON.stringify(args.manifest), args.checkHash, args.checkCron, args.nextDueAt, args.now, args.now, SMART_NOTE_CHECK_POLICY_VERSION, args.now, args.noteId);
-}
-function markCompiledCheckFalse(db, noteId, nextDueAt, now) {
-  db.prepare(`UPDATE notes
-         SET last_checked_at = ?,
-             updated_at = ?,
-             check_next_due_at = ?,
-             check_failure_count = 0,
-             check_network_failure_count = 0,
-             check_false_since_at = COALESCE(check_false_since_at, ?)
-         WHERE id = ? AND type = 'smart'`).run(now, now, nextDueAt, now, noteId);
+    uses.add(match[1]);
+  return uses;
 }
-function markCompiledCheckLogicFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
-  const status = failureCount >= maxFailures ? "failing" : "compiled";
-  db.prepare(`UPDATE notes
-         SET check_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+function literalCalls(code, method) {
+  const regex = new RegExp(`\\bcap\\s*\\.\\s*${method}\\s*\\(\\s*(["'])((?:\\\\.|(?!\\1)[^\\\\])*)\\1`, "g");
+  const values = [];
+  for (const match of code.matchAll(regex)) {
+    values.push(match[2].replace(/\\([\\"'])/g, "$1"));
+  }
+  return values;
 }
-function markCompiledCheckNetworkFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_network_failure_count") + 1;
-  const quarantinedUntil = now + backoffMs(failureCount);
-  const status = failureCount >= maxFailures ? "failing" : "compiled";
-  db.prepare(`UPDATE notes
-         SET check_network_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             check_quarantined_until = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, quarantinedUntil, quarantinedUntil, now, noteId);
+function normalizeCron(cron) {
+  if (cron.length > MAX_CRON_CHARS)
+    throw new Error("check_cron exceeds 256 characters");
+  const normalized = cron.trim() || "0 * * * *";
+  const parsed = parseCron(normalized);
+  if (!parsed.ok)
+    throw new Error(`invalid check_cron: ${parsed.error}`);
+  const next = nextOccurrence(parsed.cron, new Date, undefined, SMART_NOTE_CHECK_CEILING_MS);
+  if (!next)
+    throw new Error("check_cron has no occurrence within the scheduling ceiling");
+  return normalized;
 }
-function markSmartNoteLivenessChecked(db, noteId, now) {
-  db.prepare(`UPDATE notes
-         SET check_last_liveness_at = ?, updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(now, now, noteId);
+function unique(items) {
+  return [...new Set(items)];
 }
-function markSmartNoteCheckStatus(db, noteId, status, now) {
-  db.prepare(`UPDATE notes SET check_status = ?, updated_at = ? WHERE id = ? AND type = 'smart'`).run(status, now, noteId);
+function uniqueStrings(items, normalize = (value) => value) {
+  if (!Array.isArray(items))
+    return;
+  const values = unique(items.slice(0, MAX_MANIFEST_ENTRIES).filter((item) => typeof item === "string" && item.length > 0).map(normalize));
+  return values.length > 0 ? values : undefined;
 }
-function markSmartNoteCompilationFailure(db, noteId, now, maxFailures) {
-  const failureCount = readFailureCount(db, noteId, "check_failure_count") + 1;
-  const status = failureCount >= maxFailures ? "fallback" : "uncompiled";
-  db.prepare(`UPDATE notes
-         SET check_failure_count = ?,
-             check_status = ?,
-             check_next_due_at = ?,
-             updated_at = ?
-         WHERE id = ? AND type = 'smart'`).run(failureCount, status, now + backoffMs(failureCount), now, noteId);
+function boundedError(error) {
+  return error.slice(0, MAX_COMPILER_ERROR_CHARS);
 }
-function readFailureCount(db, noteId, column) {
-  if (column !== "check_failure_count" && column !== "check_network_failure_count")
-    return 0;
-  const row = db.prepare(`SELECT ${column} AS count FROM notes WHERE id = ?`).get(noteId);
-  return row?.count ?? 0;
+
+// ../plugin/src/features/magic-context/smart-notes/schedule.ts
+function nextSmartNoteCheckDueAt(cron, options = {}) {
+  const now = options.now ?? Date.now();
+  const floorMs = options.floorMs ?? SMART_NOTE_CHECK_FLOOR_MS;
+  const ceilingMs = options.ceilingMs ?? SMART_NOTE_CHECK_CEILING_MS;
+  const rawNext = cron?.trim() ? nextDueAtMs(cron, now, undefined, ceilingMs) : null;
+  const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
+  const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
+  const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
+  const bounded = Math.min(ceilingMs, Math.max(floorMs, jittered));
+  return now + bounded;
 }
-function backoffMs(failureCount) {
-  const minutes = Math.min(24 * 60, 5 * 2 ** Math.max(0, failureCount - 1));
-  return minutes * 60 * 1000;
+function deterministicJitterMs(intervalMs, noteId, hash) {
+  const max = Math.min(60000, Math.floor(intervalMs * 0.1));
+  if (max <= 0)
+    return 0;
+  const seed = `${noteId ?? 0}:${hash ?? ""}`;
+  let h = 2166136261;
+  for (let i = 0;i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  const unsigned = h >>> 0;
+  return unsigned % (max * 2 + 1) - max;
 }
 
 // ../plugin/src/features/magic-context/smart-notes/runner.ts
@@ -6681,12 +7195,12 @@ async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSig
     });
   };
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: `magic-context-smart-note-confirm-${noteId}`
-      },
-      query: { directory: args.sessionDirectory ?? args.projectIdentity }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: `magic-context-smart-note-confirm-${noteId}`,
+      directory: args.sessionDirectory ?? args.projectIdentity
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -7019,6 +7533,7 @@ async function mapMemories(args) {
       result.independent += counts.independent;
       result.remaining -= counts.mapped + counts.independent;
       result.batches += 1;
+      args.onProgress?.(result.mapped + result.independent);
     }
     result.complete = result.remaining === 0;
     log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
@@ -7031,12 +7546,12 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
   let agentSessionId = null;
   const startedAt = Date.now();
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-map-memories"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-map-memories",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -7620,6 +8135,7 @@ async function refreshPrimers(args) {
         result.refreshed += 1;
       else
         result.skipped += 1;
+      args.onProgress?.(result.refreshed + result.skipped);
     }
     log(`[dreamer] refresh-primers: refreshed=${result.refreshed} skipped=${result.skipped}`);
     return result;
@@ -7648,12 +8164,12 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
   let agentSessionId = null;
   const startedAt = Date.now();
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-refresh-primers"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-refresh-primers",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -8151,8 +8667,8 @@ function extractToolRows(parts) {
     const record = part;
     if (record.type !== "tool" || typeof record.tool !== "string")
       continue;
-    const state = record.state;
-    const stateRecord = state && typeof state === "object" ? state : {};
+    const state2 = record.state;
+    const stateRecord = state2 && typeof state2 === "object" ? state2 : {};
     const output = stringifyToolOutput(stateRecord.output);
     const errorText = stringifyToolOutput(stateRecord.error);
     const status = typeof stateRecord.status === "string" ? stateRecord.status : "";
@@ -8467,6 +8983,7 @@ async function runVerify(args) {
       result.archived += counts.archived;
       result.remaining -= counts.verified + counts.updated + counts.archived;
       result.batches += 1;
+      args.onProgress?.(result.verified + result.updated + result.archived);
     }
     result.complete = result.remaining === 0;
     log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
@@ -8479,12 +8996,12 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
   let agentSessionId = null;
   const startedAt = Date.now();
   try {
-    const createResponse = await args.client.session.create({
-      body: {
-        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
-        title: "magic-context-dream-verify"
-      },
-      query: { directory: args.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: args.client,
+      db: args.db,
+      parentSessionId: args.parentSessionId,
+      title: "magic-context-dream-verify",
+      directory: args.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -8758,6 +9275,20 @@ function createDreamTaskExecutor(deps) {
     const { db, projectIdentity, holderId, leaseKey } = ctx;
     const startedAt = Date.now();
     const deadline = startedAt + config.timeoutMinutes * 60 * 1000;
+    const backlogAtStart = getDreamTaskBacklog(db, projectIdentity, config.task);
+    const reportProgress = (processed) => {
+      deps.onProgress?.({
+        task: config.task,
+        processed: Math.max(0, processed),
+        total: backlogAtStart.pending,
+        startedAt
+      });
+    };
+    reportProgress(0);
+    const incompleteMessage = (remaining) => {
+      const processed = processedDreamTaskItems(backlogAtStart.pending, remaining);
+      return `${config.task} incomplete: ${remaining} remain (was ${backlogAtStart.pending} at run start; processed ${processed} this run)`;
+    };
     const parent = await resolveParentSessionId();
     let moduleRoute;
     if (config.task === "map-memories" || config.task === "compress-cues" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
@@ -8786,7 +9317,19 @@ function createDreamTaskExecutor(deps) {
               name: config.task,
               durationMs: Date.now() - startedAt,
               resultChars: 0,
-              ...error ? { error } : {}
+              ...error ? { error } : {},
+              backlog: (() => {
+                const end = getDreamTaskBacklog(db, projectIdentity, config.task);
+                const processed = processedDreamTaskItems(backlogAtStart.pending, end.pending);
+                const value = {
+                  pendingAtStart: backlogAtStart.pending,
+                  totalAtStart: backlogAtStart.total,
+                  pendingAtEnd: end.pending,
+                  totalAtEnd: end.total,
+                  processed
+                };
+                return value;
+              })()
             }
           ],
           tasksSucceeded: status === "completed" ? 1 : 0,
@@ -8820,8 +9363,8 @@ function createDreamTaskExecutor(deps) {
     }
     try {
       if (config.task === "compress-cues") {
-        if (deps.experimentalMural?.enabled !== true) {
-          log("[dreamer] compress-cues: skipped (experimental.mural is not enabled)");
+        if (deps.mural?.enabled !== true) {
+          log("[dreamer] compress-cues: skipped (mural is not enabled)");
           recordRun("completed", null);
           return { status: "completed" };
         }
@@ -8840,12 +9383,13 @@ function createDreamTaskExecutor(deps) {
           holderId,
           leaseKey,
           deadline,
-          model: config.model ?? deps.experimentalMural.model ?? deps.dreamerModel,
-          fallbackModels: config.fallbackModels
+          model: config.model ?? deps.mural.model ?? deps.dreamerModel,
+          fallbackModels: config.fallbackModels,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] compress-cues: compressed=${result.compressed} skipped=${result.skipped} chunks=${result.chunks} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `compress-cues incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -8882,11 +9426,12 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model,
           fallbackModels: config.fallbackModels,
-          moduleRoute
+          moduleRoute,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `map-memories incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -8908,10 +9453,11 @@ function createDreamTaskExecutor(deps) {
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
-          moduleRoute
+          moduleRoute,
+          onProgress: (processed) => reportProgress(processed)
         });
         if (!result.complete) {
-          const error = `${config.task} incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
             memoryChanges: computeMemoryDelta(memoryBefore)
           });
@@ -8970,11 +9516,12 @@ function createDreamTaskExecutor(deps) {
           deadline,
           model: config.model,
           fallbackModels: config.fallbackModels,
-          ...moduleArgs
+          ...moduleArgs,
+          onProgress: (processed) => reportProgress(processed)
         });
         log(`[dreamer] classify-memories: stage=${result.stage} classified=${result.classified} changed=${result.changed} chunks=${result.chunks} remaining=${result.remaining}`);
         if (!result.complete) {
-          const error = `classify-memories incomplete: ${result.remaining} selected memories remain`;
+          const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
         }
@@ -9010,7 +9557,8 @@ function createDreamTaskExecutor(deps) {
           model: config.model,
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
-          rawProviderFactory: deps.primerRawProviderFactory
+          rawProviderFactory: deps.primerRawProviderFactory,
+          onProgress: (processed) => reportProgress(processed)
         });
         recordRun("completed", null);
         log(`[dreamer] refresh-primers: refreshed=${result.refreshed} skipped=${result.skipped}`);
@@ -9064,6 +9612,8 @@ function createDreamTaskExecutor(deps) {
       recordRun("failed", brief);
       log(`[dreamer] task ${config.task} failed (transient=${transient}): ${brief}`);
       return { status: "failed", transient, error: brief };
+    } finally {
+      deps.onProgress?.(null, config.task);
     }
   };
 }
@@ -9171,12 +9721,12 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   });
   let childSessionId = null;
   try {
-    const createResponse = await deps.client.session.create({
-      body: {
-        ...parent ? { parentID: parent } : {},
-        title: "magic-context-dream-retrospective"
-      },
-      query: { directory: deps.sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client: deps.client,
+      db,
+      parentSessionId: parent ?? undefined,
+      title: "magic-context-dream-retrospective",
+      directory: deps.sessionDirectory
     });
     const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     childSessionId = typeof created?.id === "string" ? created.id : null;
@@ -9361,12 +9911,12 @@ async function runAgenticTask(config, ctx, helpers) {
   });
   let childSessionId = null;
   try {
-    const createResponse = await deps.client.session.create({
-      body: {
-        ...parent ? { parentID: parent } : {},
-        title: `magic-context-dream-${task}`
-      },
-      query: { directory: docsDir }
+    const createResponse = await createChildSessionWithFence({
+      client: deps.client,
+      db,
+      parentSessionId: parent ?? undefined,
+      title: `magic-context-dream-${task}`,
+      directory: docsDir
     });
     const created = normalizeSDKResponse(createResponse, null, {
       preferResponseOnMissingData: true
@@ -9439,66 +9989,6 @@ async function runAgenticTask(config, ctx, helpers) {
   }
 }
 
-// ../plugin/src/features/magic-context/dreamer/task-gates.ts
-function countActiveMemories(db, projectPath) {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
-  return row?.cnt ?? 0;
-}
-function countUnmappedActiveMemories(db, projectPath) {
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM memories m
-              WHERE m.project_path = ?
-                AND m.status IN ('active','permanent')
-                AND NOT EXISTS (
-                    SELECT 1 FROM memory_verifications v WHERE v.memory_id = m.id
-                )`).get(projectPath);
-  return row?.cnt ?? 0;
-}
-function countCompartmentsSince(db, projectPath, since) {
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM compartments c
-               JOIN session_projects sp ON sp.session_id = c.session_id
-              WHERE sp.project_path = ? AND c.created_at > ?`).get(projectPath, since);
-  return row?.cnt ?? 0;
-}
-function countProjectSessionsSince(db, projectPath, since) {
-  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ? AND updated_at > ?").get(projectPath, since);
-  return row?.cnt ?? 0;
-}
-function evaluateTaskGate(task, ctx) {
-  const { db, projectIdentity: project, lastRunAt } = ctx;
-  switch (task) {
-    case "map-memories":
-      return countUnmappedActiveMemories(db, project) > 0;
-    case "verify":
-      return countActiveMemories(db, project) > 0;
-    case "verify-broad":
-      return countActiveMemories(db, project) > 0;
-    case "curate":
-      return countActiveMemories(db, project) > 0;
-    case "compress-cues":
-      return countActiveMemories(db, project) > 0;
-    case "classify-memories":
-      return countActiveMemories(db, project) > 0;
-    case "retrospective":
-      return countProjectSessionsSince(db, project, ctx.retrospectiveWatermarkMs ?? null) > 0;
-    case "maintain-docs":
-      return countCompartmentsSince(db, project, lastRunAt ?? 0) > 0;
-    case "evaluate-smart-notes":
-      return getSmartNotesNeedingCompilation(db, project, Date.now(), 1).length > 0 || getStaleCompiledSmartNotes(db, project, Date.now(), 1).length > 0 || getPendingSmartNotes(db, project).some((note) => note.checkStatus === "fallback");
-    case "review-user-memories":
-      return getUserMemoryCandidates(db).length >= ctx.promotionThreshold;
-    case "promote-primers":
-      return countPrimerCandidatesForProject(db, project) >= (ctx.promotionThreshold ?? 2);
-    case "refresh-primers":
-      return getActivePrimers(db, project).some((primer) => !primer.answer.trim() || primer.answerRefreshedAt == null || (primer.lastObservedAt ?? 0) > primer.answerRefreshedAt);
-    default: {
-      const _exhaustive = task;
-      return Boolean(_exhaustive);
-    }
-  }
-}
-
 // ../plugin/src/features/magic-context/dreamer/task-scheduler.ts
 var MAX_TASK_RETRIES = 3;
 function ensureSeeded(db, projectIdentity, config, now) {
@@ -9538,11 +10028,11 @@ function planDueTasks(db, projectIdentity, tasks, now) {
   const due = [];
   for (const config of tasks) {
     reconcileSchedule(db, projectIdentity, config, now);
-    const state = getTaskScheduleState(db, projectIdentity, config.task);
-    if (!state || state.nextDueAt === null)
+    const state2 = getTaskScheduleState(db, projectIdentity, config.task);
+    if (!state2 || state2.nextDueAt === null)
       continue;
-    if (now >= state.nextDueAt) {
-      due.push({ config, scheduledAt: state.nextDueAt });
+    if (now >= state2.nextDueAt) {
+      due.push({ config, scheduledAt: state2.nextDueAt });
     }
   }
   return due;
@@ -9646,10 +10136,10 @@ async function runDomainGroup(deps, group, cb) {
         cb?.onRan?.(due.config.task);
       } else if (outcome.transient) {
         recordTransientFailure(db, projectIdentity, due, finishedAt, outcome.error ?? null);
-        cb?.onFailed?.(due.config.task);
+        cb?.onFailed?.(due.config.task, outcome.error);
       } else {
         advanceAfterRun(db, projectIdentity, due, finishedAt, "failed", outcome.error ?? null);
-        cb?.onFailed?.(due.config.task);
+        cb?.onFailed?.(due.config.task, outcome.error);
       }
     }
   } finally {
@@ -9658,7 +10148,15 @@ async function runDomainGroup(deps, group, cb) {
 }
 async function runManualDream(deps) {
   const now = Date.now();
-  const result = { ran: [], skippedNoWork: [], deferredBusy: [], failed: [] };
+  const result = {
+    ran: [],
+    skippedNoWork: [],
+    deferredBusy: [],
+    failed: [],
+    failureDetails: [],
+    backlogBefore: {},
+    backlogAfter: {}
+  };
   let selected;
   let forceGate = false;
   if (deps.task) {
@@ -9672,6 +10170,9 @@ async function runManualDream(deps) {
   }
   if (selected.length === 0)
     return result;
+  const selectedTaskNames = selected.map((config) => config.task);
+  result.backlogBefore = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
+  result.backlogAfter = { ...result.backlogBefore };
   for (const cfg of selected)
     ensureSeeded(deps.db, deps.projectIdentity, cfg, now);
   const dueAll = selected.map((config) => ({ config, scheduledAt: now }));
@@ -9693,8 +10194,10 @@ async function runManualDream(deps) {
     else
       result.skippedNoWork.push(d.config.task);
   }
-  if (gated.length === 0)
+  if (gated.length === 0) {
+    result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
     return result;
+  }
   const groups = new Map;
   for (const d of gated) {
     const kind = leaseKindFor(d.config.task);
@@ -9706,9 +10209,14 @@ async function runManualDream(deps) {
     forceGate,
     leaseWaitMs: MANUAL_RUN_LEASE_WAIT_MS,
     onRan: (t) => result.ran.push(t),
-    onFailed: (t) => result.failed.push(t),
+    onFailed: (task, error) => {
+      result.failed.push(task);
+      if (error)
+        result.failureDetails?.push(`${task}: ${error}`);
+    },
     onBusy: (t) => result.deferredBusy.push(t)
   })));
+  result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
   return result;
 }
 async function runDueTasksForProject(deps) {
@@ -10023,10 +10531,11 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
       ensureProjectRegistered: reg.ensureRegistered,
       language: reg.language,
       dreamerModel: dreamerConfig.model,
-      experimentalMural: reg.experimentalMural,
+      mural: reg.mural,
       memoryInjectionBudgetTokens: reg.memoryInjectionBudgetTokens,
       transformMode: reg.transformMode,
-      moduleClient: reg.moduleClient
+      moduleClient: reg.moduleClient,
+      onProgress: (progress, completedTask) => reg.onDreamerProgress?.(progress, completedTask)
     });
     const ran = await runDueTasksForProject({
       db,
@@ -10696,13 +11205,18 @@ Unknown task "${requested}".`,
         });
         return;
       }
+      const backlogTasks = task ? [task] : CANONICAL_DREAM_TASKS;
+      const backlogBefore = getDreamTaskBacklogs(deps.db, project.projectIdentity, backlogTasks);
       sendCtxStatusMessage(pi, {
         title: "/ctx-dream",
         text: [
           "## /ctx-dream",
           "",
           task ? `Running dream task "${task}" for ${project.projectIdentity}…` : `Starting dream run for ${project.projectIdentity}…`,
-          `Project directory: ${project.projectDir}`
+          `Project directory: ${project.projectDir}`,
+          "",
+          "Backlog before starting:",
+          formatDreamTaskBacklogs(backlogBefore, backlogTasks)
         ].join(`
 `),
         level: "info"
@@ -10717,10 +11231,16 @@ Unknown task "${requested}".`,
           lines.push(`Ran: ${result.ran.join(", ")}`);
         if (result.failed.length > 0)
           lines.push(`Failed: ${result.failed.join(", ")}`);
+        if ((result.failureDetails?.length ?? 0) > 0) {
+          lines.push("Failure details:", ...(result.failureDetails ?? []).map((detail) => `- ${detail}`));
+        }
         if (result.skippedNoWork.length > 0)
           lines.push(`Skipped (no work): ${result.skippedNoWork.join(", ")}`);
         if (result.deferredBusy.length > 0)
           lines.push(`Busy: ${result.deferredBusy.join(", ")} — another dream task holds this domain's lease; retry in a minute`);
+        if (Object.keys(result.backlogAfter ?? {}).length > 0) {
+          lines.push("", "Backlog at run end:", formatDreamTaskBacklogs(result.backlogAfter));
+        }
         if (lines.length === 0)
           lines.push("No enabled dream tasks to run.");
         sendCtxStatusMessage(pi, {
@@ -11047,6 +11567,101 @@ function executeFlush(db, sessionId) {
   }
 }
 
+// src/compaction-off-pi.ts
+var COMPACTION_OFF_COMMAND_UNAVAILABLE = `Unavailable: magic-context is in compaction-off mode (${COMPACTION_ENABLED_PATH}=false).`;
+var NO_TRANSITION = {
+  recordToWrite: null,
+  invalidatedBaseline: false,
+  clearDeferredMarkerState: false,
+  historianCatchUpSignaled: false,
+  notice: null
+};
+var PI_COMPACTION_OFF_NOTICE = "Magic Context is in compaction-off mode. Native Pi compaction now owns this session's context window; the first turn after disabling may trigger one native compaction cycle on long sessions.";
+var PI_COMPACTION_ON_NOTICE = "Magic Context context-window management resumed. Run /ctx-wrapup to digest history accumulated while compaction was off.";
+function reconcilePiCompactionMode(args) {
+  const stored = getCompactionModeRecord(args.db, args.sessionId);
+  if (stored === "on_notice_pending") {
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: "on",
+      notice: PI_COMPACTION_ON_NOTICE
+    };
+  }
+  if (stored === "off_notice_pending") {
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: "off",
+      notice: PI_COMPACTION_OFF_NOTICE
+    };
+  }
+  if (!args.compactionOff) {
+    if (stored === null || resolveCompactionModeRecord(stored) === "on") {
+      return stored === null ? { ...NO_TRANSITION, recordToWrite: "on" } : NO_TRANSITION;
+    }
+    clearCachedM0M1(args.db, args.sessionId);
+    if (!args.historianRunnable) {
+      return {
+        ...NO_TRANSITION,
+        recordToWrite: "on",
+        invalidatedBaseline: true
+      };
+    }
+    updateSessionMeta(args.db, args.sessionId, {
+      compartmentInProgress: true
+    });
+    setCompactionModeRecord(args.db, args.sessionId, "on_notice_pending");
+    return {
+      recordToWrite: "on",
+      invalidatedBaseline: true,
+      clearDeferredMarkerState: false,
+      historianCatchUpSignaled: true,
+      notice: PI_COMPACTION_ON_NOTICE
+    };
+  }
+  if (resolveCompactionModeRecord(stored) === "off")
+    return NO_TRANSITION;
+  let clearedSomething = false;
+  if (getPendingPiCompactionMarkerState(args.db, args.sessionId) !== null) {
+    setPendingPiCompactionMarkerState(args.db, args.sessionId, null);
+    clearedSomething = true;
+  }
+  if (getOverflowState(args.db, args.sessionId).needsEmergencyRecovery) {
+    clearEmergencyRecovery(args.db, args.sessionId);
+    clearedSomething = true;
+  }
+  const channel2 = getChannel2NudgeState(args.db, args.sessionId);
+  if (channel2 === "pending" || channel2 === "claimed") {
+    setChannel2NudgeState(args.db, args.sessionId, "");
+    clearedSomething = true;
+  }
+  if (getPendingOps(args.db, args.sessionId).length > 0) {
+    clearPendingOps(args.db, args.sessionId);
+    clearedSomething = true;
+  }
+  const meta = getOrCreateSessionMeta(args.db, args.sessionId);
+  if (meta.compartmentInProgress) {
+    updateSessionMeta(args.db, args.sessionId, {
+      compartmentInProgress: false
+    });
+  }
+  clearCachedM0M1(args.db, args.sessionId);
+  sessionLog(args.sessionId, `Pi compaction-off transition: clearedPendingMarker=${clearedSomething}`);
+  const notice = clearedSomething ? PI_COMPACTION_OFF_NOTICE : null;
+  if (notice) {
+    setCompactionModeRecord(args.db, args.sessionId, "off_notice_pending");
+  }
+  return {
+    recordToWrite: "off",
+    invalidatedBaseline: true,
+    clearDeferredMarkerState: true,
+    historianCatchUpSignaled: false,
+    notice
+  };
+}
+function commitPiCompactionModeRecord(db, sessionId, record) {
+  setCompactionModeRecord(db, sessionId, record);
+}
+
 // src/context-handler.ts
 import * as crypto3 from "node:crypto";
 
@@ -11060,6 +11675,9 @@ var UNIT_TO_MS = {
 };
 function parseCacheTtl(ttl) {
   const normalizedTtl = ttl.trim();
+  if (normalizedTtl.toLowerCase() === "never") {
+    return Number.POSITIVE_INFINITY;
+  }
   if (NUMERIC_PATTERN.test(normalizedTtl)) {
     return Number(normalizedTtl);
   }
@@ -11775,9 +12393,9 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
 }
 
 // ../plugin/src/hooks/magic-context/boundary-execution.ts
-var FORCE_MATERIALIZE_PERCENTAGE = 85;
 function detectMidTurnBypassReason(input) {
-  if (input.contextUsage.percentage >= FORCE_MATERIALIZE_PERCENTAGE)
+  const { forceMaterializationPercentage } = escalationBands(input.effectiveExecuteThresholdPercentage);
+  if (input.contextUsage.percentage >= forceMaterializationPercentage)
     return "force-materialize";
   if (input.historyRefreshSessions.has(input.sessionId))
     return "explicit-bust";
@@ -12270,29 +12888,29 @@ function callIdFromPart(part) {
   const direct = firstStringField(part, ["callID", "callId", "toolCallId", "tool_call_id", "id"]);
   if (direct)
     return direct;
-  const state = isRecord(part.state) ? part.state : null;
-  return state ? firstStringField(state, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
+  const state2 = isRecord(part.state) ? part.state : null;
+  return state2 ? firstStringField(state2, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
 }
 function toolSignalFromPart(part) {
   if (!isRecord(part))
     return null;
   const type = partType(part);
-  const state = isRecord(part.state) ? part.state : null;
+  const state2 = isRecord(part.state) ? part.state : null;
   const callId = callIdFromPart(part);
   if (!callId && type !== "tool")
     return null;
   if (type === "tool") {
-    const hasInput = state !== null && hasOwn(state, "input");
-    const outputKey = state ? hasOwn(state, "output") ? "output" : hasOwn(state, "error") ? "error" : hasOwn(state, "result") ? "result" : null : null;
+    const hasInput = state2 !== null && hasOwn(state2, "input");
+    const outputKey = state2 ? hasOwn(state2, "output") ? "output" : hasOwn(state2, "error") ? "error" : hasOwn(state2, "result") ? "result" : null : null;
     const hasOutput = outputKey !== null;
-    const outputValue = outputKey && state ? state[outputKey] : undefined;
+    const outputValue = outputKey && state2 ? state2[outputKey] : undefined;
     const providerExecuted = part.providerExecuted === true;
     const openInvocation = !providerExecuted && !hasOutput;
     return {
       callId,
       hasInput: hasInput || openInvocation,
       hasOutput,
-      inputText: hasInput && state ? stringValue(state.input) : "",
+      inputText: hasInput && state2 ? stringValue(state2.input) : "",
       outputText: hasOutput ? stringValue(outputValue) : ""
     };
   }
@@ -12520,24 +13138,27 @@ function tokenForMessage(message, options) {
 function buildTrueRawTokenIndex(sessionId, messages, options) {
   const ordered = [...messages].sort((a, b) => a.ordinal - b.ordinal);
   const sliceCount = ordered.length;
-  const maxOrdinal = ordered.length > 0 ? ordered[ordered.length - 1].ordinal : 0;
-  const rawMessageCount = Math.max(sliceCount, maxOrdinal, options.absoluteMessageCount ?? sliceCount);
+  const firstOrdinal = ordered.length > 0 ? ordered[0].ordinal : 1;
+  const terminalOrdinal = ordered.length > 0 ? ordered[ordered.length - 1].ordinal : 0;
+  const rawMessageCount = Math.max(sliceCount, terminalOrdinal, options.absoluteMessageCount ?? sliceCount);
+  const ordinalSpan = terminalOrdinal >= firstOrdinal ? terminalOrdinal - firstOrdinal + 1 : 0;
   const tokensByOrdinal = new Map;
   const idsByOrdinal = new Map;
-  const prefix = new Array(rawMessageCount + 1).fill(0);
+  const prefix = new Array(ordinalSpan + 1).fill(0);
   for (const message of ordered) {
     const stored = options.storedTotalForMessage?.(message);
     const total = stored !== undefined && stored !== null ? stored : tokenForMessage(message, options).total;
     tokensByOrdinal.set(message.ordinal, total);
     idsByOrdinal.set(message.ordinal, message.id);
-    if (message.ordinal >= 1 && message.ordinal <= rawMessageCount) {
-      prefix[message.ordinal] = total;
+    const relative = message.ordinal - firstOrdinal + 1;
+    if (relative >= 1 && relative <= ordinalSpan) {
+      prefix[relative] = total;
     }
   }
-  for (let k = 1;k <= rawMessageCount; k += 1) {
+  for (let k = 1;k <= ordinalSpan; k += 1) {
     prefix[k] += prefix[k - 1];
   }
-  const ordinalToIndex = (ordinal) => Math.max(0, Math.min(rawMessageCount, ordinal - 1));
+  const ordinalToIndex = (ordinal) => Math.max(0, Math.min(ordinalSpan, ordinal - firstOrdinal));
   return {
     sessionId,
     providerShapeVersion: options.providerShapeVersion,
@@ -12549,27 +13170,27 @@ function buildTrueRawTokenIndex(sessionId, messages, options) {
       return idsByOrdinal.get(ordinal) ?? null;
     },
     suffixTokensFromOrdinal(ordinal) {
-      if (ordinal <= 1)
-        return prefix[rawMessageCount];
-      if (ordinal > rawMessageCount)
+      if (ordinal <= firstOrdinal)
+        return prefix[ordinalSpan];
+      if (ordinal > terminalOrdinal)
         return 0;
-      return prefix[rawMessageCount] - prefix[ordinalToIndex(ordinal)];
+      return prefix[ordinalSpan] - prefix[ordinalToIndex(ordinal)];
     },
     rangeTokens(startInclusive, endExclusive) {
-      const start = Math.max(1, startInclusive);
-      const end = Math.max(start, Math.min(rawMessageCount + 1, endExclusive));
-      return prefix[end - 1] - prefix[start - 1];
+      const start = Math.max(firstOrdinal, startInclusive);
+      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
+      return prefix[end - firstOrdinal] - prefix[start - firstOrdinal];
     },
     findSuffixStartForTokens(tokens) {
       if (!Number.isFinite(tokens) || tokens <= 0)
-        return rawMessageCount + 1;
+        return terminalOrdinal + 1;
       const target = Math.max(0, Math.floor(tokens));
-      const total = prefix[rawMessageCount];
+      const total = prefix[ordinalSpan];
       if (total < target)
-        return 1;
+        return firstOrdinal;
       const cut = total - target;
       let lo = 0;
-      let hi = rawMessageCount;
+      let hi = ordinalSpan;
       let best = 0;
       while (lo <= hi) {
         const mid = lo + hi >> 1;
@@ -12580,29 +13201,31 @@ function buildTrueRawTokenIndex(sessionId, messages, options) {
           hi = mid - 1;
         }
       }
-      return best + 1;
+      return firstOrdinal + best;
     },
     findHeadEndForCap(startInclusive, endExclusive, capTokens) {
-      const start = Math.max(1, Math.min(rawMessageCount + 1, startInclusive));
-      const end = Math.max(start, Math.min(rawMessageCount + 1, endExclusive));
+      const start = Math.max(firstOrdinal, Math.min(terminalOrdinal + 1, startInclusive));
+      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
       if (!Number.isFinite(capTokens) || capTokens <= 0)
         return start;
-      const startPrefix = prefix[start - 1];
-      const cut = startPrefix + Math.floor(capTokens);
-      let lo = start;
-      let hi = end - 1;
-      let bestEnd = start;
+      const startIndex = start - firstOrdinal;
+      const endIndex = end - firstOrdinal;
+      const cut = prefix[startIndex] + Math.floor(capTokens);
+      let lo = startIndex + 1;
+      let hi = endIndex;
+      let bestEndIndex = startIndex;
       while (lo <= hi) {
         const mid = lo + hi >> 1;
         if (prefix[mid] <= cut) {
-          bestEnd = mid + 1;
+          bestEndIndex = mid;
           lo = mid + 1;
         } else {
           hi = mid - 1;
         }
       }
+      let bestEnd = firstOrdinal + bestEndIndex;
       if (bestEnd === start && start < end)
-        return start + 1;
+        bestEnd = start + 1;
       return Math.min(bestEnd, end);
     }
   };
@@ -12918,7 +13541,8 @@ function resolveProtectedTailBoundary(ctx) {
   if (ctx.migrationFloorActive)
     runtimeFloor = Math.max(runtimeFloor, ctx.priorBoundaryOrdinal);
   let protectedTailStart = Math.max(boundary, runtimeFloor);
-  if (!ctx.emergencyTailScale && usagePercentage < 80) {
+  const forceMaterializationPercentage = escalationBands(ctx.executeThresholdPercentage).forceMaterializationPercentage;
+  if (!ctx.emergencyTailScale && usagePercentage < forceMaterializationPercentage) {
     let lastMeaningfulUserOrdinal = 0;
     for (let i = messages.length - 1;i >= 0; i--) {
       const message = messages[i];
@@ -13159,7 +13783,8 @@ function getRawHistoryEligibility(db, sessionId) {
 function hasRunnableCompartmentWindow(snapshot) {
   if (snapshot.offset >= snapshot.protectedTailStart)
     return false;
-  if (snapshot.usagePercentage >= 80 || snapshot.emergencyTailScale) {
+  const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
+  if (snapshot.usagePercentage >= forceMaterializationPercentage || snapshot.emergencyTailScale) {
     return snapshot.trueRawEligibleTokens >= deriveMinForceEligibleTokens(snapshot.N) || snapshot.eligibleEndOrdinal > snapshot.offset;
   }
   return snapshot.eligibleEndOrdinal > snapshot.offset;
@@ -13222,11 +13847,18 @@ function validateBoundarySnapshot(args) {
   return { ok: true };
 }
 function recordHighPressureNoEligibleHead(db, snapshot) {
-  if (snapshot.usagePercentage < 80 && !snapshot.emergencyTailScale)
+  const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
+  if (snapshot.usagePercentage < forceMaterializationPercentage && !snapshot.emergencyTailScale) {
     return 0;
+  }
   return recordProtectedTailNoEligibleHead(db, snapshot.sessionId);
 }
 
+// ../plugin/src/hooks/magic-context/sentinel.ts
+function modelAcceptsEmptyContent(providerID) {
+  return providerID === "anthropic";
+}
+
 // ../plugin/src/hooks/magic-context/compartment-trigger.ts
 var PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
 var POST_DROP_TARGET_RATIO = 0.75;
@@ -13234,7 +13866,6 @@ var MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE = 6000;
 var MIN_PROACTIVE_TAIL_MESSAGE_COUNT = 12;
 var DEFAULT_MIN_COMMIT_CLUSTERS_FOR_TRIGGER = 3;
 var TAIL_SIZE_TRIGGER_MULTIPLIER = 3;
-var FORCE_COMPARTMENT_PERCENTAGE = 80;
 var BLOCK_UNTIL_DONE_PERCENTAGE = 95;
 var CONTENT_TAG_OWNER_SUFFIX = /:(?:p|file)\d+$/;
 function tagOwnerMessageId(row) {
@@ -13271,7 +13902,7 @@ function estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, tag
 function getProactiveCompartmentTriggerPercentage(executeThresholdPercentage) {
   return Math.max(0, executeThresholdPercentage - PROACTIVE_TRIGGER_OFFSET_PERCENTAGE);
 }
-function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, clearReasoningAge, clearedReasoningThroughTag) {
+function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, clearReasoningAge, clearedReasoningThroughTag, canClearReasoning) {
   const totalActiveBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   if (totalActiveBytes === 0)
     return null;
@@ -13282,7 +13913,7 @@ function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, c
     droppableBytes += activeTags.filter((tag) => pendingDropTagIds.has(tag.tagNumber)).reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   }
   const maxTag = activeTags.reduce((max, t) => Math.max(max, t.tagNumber), 0);
-  if (clearReasoningAge !== undefined && clearedReasoningThroughTag !== undefined) {
+  if (canClearReasoning && clearReasoningAge !== undefined && clearedReasoningThroughTag !== undefined) {
     const reasoningAgeCutoff = maxTag - clearReasoningAge;
     for (const tag of activeTags) {
       if (tag.type !== "message")
@@ -13382,7 +14013,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
     }
   });
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -13436,18 +14067,20 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     }
     return { shouldFire: false };
   }
-  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), clearReasoningAge, sessionMeta.clearedReasoningThroughTag);
+  const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
+  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), clearReasoningAge, sessionMeta.clearedReasoningThroughTag, canClearReasoning);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
-  if (usage.percentage >= FORCE_COMPARTMENT_PERCENTAGE) {
+  const forceMaterializationPercentage = escalationBands(executeThresholdPercentage).forceMaterializationPercentage;
+  if (usage.percentage >= forceMaterializationPercentage) {
     if (projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
-      sessionLog(sessionId, `compartment trigger: skipping force-${FORCE_COMPARTMENT_PERCENTAGE} because projected post-drop usage is ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%)`);
+      sessionLog(sessionId, `compartment trigger: skipping force band ${forceMaterializationPercentage}% because projected post-drop usage is ${projectedPostDropPercentage.toFixed(1)}% (target ${relativePostDropTarget.toFixed(1)}%)`);
       return { shouldFire: false };
     }
     sessionLog(sessionId, `compartment trigger: force-firing at ${usage.percentage.toFixed(1)}% (projected post-drop ${projectedPostDropPercentage?.toFixed(1) ?? "none"}%)`);
     if (tailInfo.boundarySnapshot && hasRunnableCompartmentWindow(tailInfo.boundarySnapshot)) {
       return {
         shouldFire: true,
-        reason: "force_80",
+        reason: "force_band",
         boundarySnapshot: tailInfo.boundarySnapshot
       };
     }
@@ -13472,9 +14105,9 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       });
     });
     if (hasRunnableCompartmentWindow(scaledBoundary)) {
-      return { shouldFire: true, reason: "force_80", boundarySnapshot: scaledBoundary };
+      return { shouldFire: true, reason: "force_band", boundarySnapshot: scaledBoundary };
     }
-    sessionLog(sessionId, "compartment trigger: force_80 skipped — raw exists but protected head genuinely empty after emergency tail scale");
+    sessionLog(sessionId, "compartment trigger: force_band skipped — raw exists but protected head genuinely empty after emergency tail scale");
     return { shouldFire: false };
   }
   const clusterEnabled = commitClusterTrigger?.enabled ?? true;
@@ -13639,11 +14272,6 @@ ${body}${hintText}
 </system-reminder>`;
 }
 
-// ../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;
@@ -14958,16 +15586,16 @@ function sealDeliveredAfterUnconfirmedSend(db, sessionId) {
   }
 }
 var channel1StateBySession = new Map;
-function setPiChannel1Baseline(sessionId, state) {
-  channel1StateBySession.set(sessionId, state);
+function setPiChannel1Baseline(sessionId, state2) {
+  channel1StateBySession.set(sessionId, state2);
 }
 function clearPiChannel1State(sessionId) {
   channel1StateBySession.delete(sessionId);
 }
 function markPiChannel1Reduced(sessionId, db) {
-  const state = channel1StateBySession.get(sessionId);
-  if (state)
-    state.reducedSinceRefresh = true;
+  const state2 = channel1StateBySession.get(sessionId);
+  if (state2)
+    state2.reducedSinceRefresh = true;
   if (db)
     resetLastNudgeCycle(db, sessionId);
 }
@@ -15042,11 +15670,11 @@ function computeTailTokenEstimatePi(messages) {
 }
 function maybeChannel1ReminderForToolResult(args) {
   const { db, sessionId, toolName } = args;
-  const state = channel1StateBySession.get(sessionId);
-  if (!state)
+  const state2 = channel1StateBySession.get(sessionId);
+  if (!state2)
     return null;
   if (toolName === "ctx_reduce") {
-    state.reducedSinceRefresh = true;
+    state2.reducedSinceRefresh = true;
     resetLastNudgeCycle(db, sessionId);
     return null;
   }
@@ -15055,21 +15683,21 @@ function maybeChannel1ReminderForToolResult(args) {
     return null;
   if (text.includes(CHANNEL1_SENTINEL))
     return null;
-  state.turnToolTokens += toolOutputTokens(text);
-  if (state.reducedSinceRefresh)
+  state2.turnToolTokens += toolOutputTokens(text);
+  if (state2.reducedSinceRefresh)
     return null;
-  const undroppedTokens = state.tailToolTokens + state.turnToolTokens;
+  const undroppedTokens = state2.tailToolTokens + state2.turnToolTokens;
   const pressure = computePressure({
-    lastInputTokens: state.lastInputTokens,
-    turnToolTokens: state.turnToolTokens,
-    contextLimit: state.contextLimit,
-    executeThresholdPercentage: state.executeThresholdPercentage
+    lastInputTokens: state2.lastInputTokens,
+    turnToolTokens: state2.turnToolTokens,
+    contextLimit: state2.contextLimit,
+    executeThresholdPercentage: state2.executeThresholdPercentage
   });
-  const workingWindowTokens = Math.round(state.contextLimit * state.executeThresholdPercentage / 100);
+  const workingWindowTokens = Math.round(state2.contextLimit * state2.executeThresholdPercentage / 100);
   const decision = decideChannel1({
     undroppedTokens,
     pressure,
-    estimatedInputTokens: state.lastInputTokens + state.turnToolTokens,
+    estimatedInputTokens: state2.lastInputTokens + state2.turnToolTokens,
     workingWindowTokens,
     lastNudgeUndropped: getLastNudgeUndropped(db, sessionId),
     lastNudgeLevel: getLastNudgeLevel(db, sessionId),
@@ -15081,18 +15709,18 @@ function maybeChannel1ReminderForToolResult(args) {
     return null;
   return {
     type: "text",
-    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state.oldestReclaimableToolTags)
+    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state2.oldestReclaimableToolTags)
   };
 }
 var CHANNEL2_NUDGE_CUSTOM_TYPE = "magic-context:ceiling-nudge";
 function maybeDeliverChannel2Pi(pi, db, sessionId, deliverAs = "followUp") {
-  let state;
+  let state2;
   try {
-    state = getChannel2NudgeState(db, sessionId);
+    state2 = getChannel2NudgeState(db, sessionId);
   } catch {
     return false;
   }
-  if (state !== "pending")
+  if (state2 !== "pending")
     return false;
   const baseline = channel1StateBySession.get(sessionId);
   if (!baseline)
@@ -15764,14 +16392,17 @@ var EMPTY_PI_PROJECT_DOCS = {
   renderedBlock: "",
   canonicalHash: ""
 };
-function readProjectDocsForPiM0(state) {
-  return state.injectDocs !== false ? readProjectDocsCanonical(state.projectDirectory) : EMPTY_PI_PROJECT_DOCS;
+function getRenderableCompartmentsPi(db, state2) {
+  return state2.compactionOff ? [] : getCompartments(db, state2.sessionId);
+}
+function readProjectDocsForPiM0(state2) {
+  return state2.injectDocs !== false ? readProjectDocsCanonical(state2.projectDirectory) : EMPTY_PI_PROJECT_DOCS;
 }
-function memoryProjectPath(state) {
-  return state.memoryEnabled === false ? undefined : state.projectIdentity;
+function memoryProjectPath(state2) {
+  return state2.memoryEnabled === false ? undefined : state2.projectIdentity;
 }
-function resolveWorkspaceRenderContextPi(state, db) {
-  const memPath = memoryProjectPath(state);
+function resolveWorkspaceRenderContextPi(state2, db) {
+  const memPath = memoryProjectPath(state2);
   if (!memPath) {
     return {
       identities: [],
@@ -15847,12 +16478,12 @@ function piImageFromDataUrl(dataUrl) {
     return null;
   return { type: "image", mimeType: match[1], data: match[2] };
 }
-function resolveMuralForM0Pi(state, db, modelKey, budgetTokens) {
-  if (state.mural)
-    return state.mural;
-  if (!state.muralEnabled)
+function resolveMuralForM0Pi(state2, db, modelKey, budgetTokens) {
+  if (state2.mural)
+    return state2.mural;
+  if (!state2.muralEnabled)
     return;
-  return resolveMuralWire(db, memoryProjectPath(state), modelKey, true, budgetTokens);
+  return resolveMuralWire(db, memoryProjectPath(state2), modelKey, true, budgetTokens);
 }
 function cachedInjectionTokenCounts(sessionId, m0, m1) {
   const cached = injectionTokenCountsBySession.get(sessionId);
@@ -15905,17 +16536,17 @@ function trimPiMessagesToCachedBoundary(db, sessionId, piMessages, entryIds) {
 function setCachedBoundary(db, sessionId, boundary) {
   db.prepare("UPDATE session_meta SET cached_m0_last_baseline_end_message_id = ? WHERE session_id = ?").run(boundary, sessionId);
 }
-function getCachedMarkers(db, state, compartmentsForNormalization) {
-  const meta = getOrCreateSessionMeta(db, state.sessionId);
+function getCachedMarkers(db, state2, compartmentsForNormalization) {
+  const meta = getOrCreateSessionMeta(db, state2.sessionId);
   if (!meta.cachedM0Bytes)
     return null;
   if (meta.cachedM0MaxCompartmentSeq === null || meta.cachedM0MaxMemoryId === null || meta.cachedM0MaxMutationId === null || meta.cachedM0MaxMemoryMutationId === null || meta.cachedM0ProjectMemoryEpoch === null || meta.cachedM0ProjectUserProfileVersion === null || meta.cachedM0ProjectDocsHash === null || meta.cachedM0SessionFactsVersion === null || meta.cachedM0MaterializedAt === null || meta.cachedM0UpgradeState === null) {
     return null;
   }
-  const compartments = compartmentsForNormalization ?? getCompartments(db, state.sessionId);
+  const compartments = compartmentsForNormalization ?? getRenderableCompartmentsPi(db, state2);
   const cachedUpgradeIdentity = decodeCachedM0UpgradeIdentity(meta.cachedM0UpgradeState);
   const maxCompartmentSeq = normalizeCachedMaxCompartmentSeq(meta.cachedM0MaxCompartmentSeq, compartments);
-  const cachedBoundary = getCachedBoundary(db, state.sessionId);
+  const cachedBoundary = getCachedBoundary(db, state2.sessionId);
   const liveBoundary = lastBaselineEndMessageId(compartments);
   if (maxCompartmentSeq >= 0 && cachedBoundary === null && liveBoundary !== null) {
     return null;
@@ -15943,38 +16574,38 @@ function lastBaselineEndMessageId(compartments) {
   const last = compartments.at(-1);
   return last?.endMessageId && last.endMessageId.length > 0 ? last.endMessageId : null;
 }
-function readCurrentMarkers(db, state, projectDocsHash) {
-  return readCurrentMarkersFromCompartments(db, state, getCompartments(db, state.sessionId), projectDocsHash);
+function readCurrentMarkers(db, state2, projectDocsHash) {
+  return readCurrentMarkersFromCompartments(db, state2, getRenderableCompartmentsPi(db, state2), projectDocsHash);
 }
-function readCurrentMarkersFromCompartments(db, state, compartments, projectDocsHash) {
-  const memPath = memoryProjectPath(state);
-  const workspace = resolveWorkspaceRenderContextPi(state, db);
+function readCurrentMarkersFromCompartments(db, state2, compartments, projectDocsHash) {
+  const memPath = memoryProjectPath(state2);
+  const workspace = resolveWorkspaceRenderContextPi(state2, db);
   const maxMemoryId = memPath ? workspace.isWorkspaced ? getMaxMemoryIdForProjects(db, workspace.expandedIdentities, workspace.ownIdentities, workspace.shareCategories) : getMaxMemoryIdForProjects(db, [memPath]) : 0;
   const projectState = memPath ? getProjectState(db, memPath) : undefined;
   const globalState = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH);
   return {
     maxCompartmentSeq: compartments.length > 0 ? compartments.reduce((max, compartment) => compartment.sequence > max ? compartment.sequence : max, EMPTY_MAX_COMPARTMENT_SEQ) : EMPTY_MAX_COMPARTMENT_SEQ,
     maxMemoryId,
-    maxMutationId: getMaxM0MutationId(db, state.sessionId) ?? 0,
+    maxMutationId: getMaxM0MutationId(db, state2.sessionId) ?? 0,
     maxMemoryMutationId: memPath ? workspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(db, workspace.expandedIdentities) ?? 0 : getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
     projectMemoryEpoch: projectState?.projectMemoryEpoch ?? 0,
     workspaceFingerprint: workspace.isWorkspaced ? computeWorkspaceEpochFingerprint(db, workspace.identities) : null,
     projectUserProfileVersion: globalState?.projectUserProfileVersion ?? 0,
-    projectDocsHash: projectDocsHash ?? readProjectDocsForPiM0(state).canonicalHash,
-    sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
+    projectDocsHash: projectDocsHash ?? readProjectDocsForPiM0(state2).canonicalHash,
+    sessionFactsVersion: getSessionFactsVersion(db, state2.sessionId),
     materializedAt: Date.now(),
     upgradeState: `${PI_M0_UPGRADE_STATE}:${compartments.some((c) => c.legacy === 1) ? "legacy" : "ready"}`,
     compartmentRenderEpoch: COMPARTMENT_RENDER_EPOCH,
     lastBaselineEndMessageId: lastBaselineEndMessageId(compartments),
-    systemHash: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
-    modelKey: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
-    projectIdentity: state.projectIdentity
+    systemHash: (state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
+    modelKey: (state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
+    projectIdentity: state2.projectIdentity
   };
 }
-function mustMaterializePi(state, db, currentCompartmentsOverride) {
-  const meta = getOrCreateSessionMeta(db, state.sessionId);
-  const currentCompartments = currentCompartmentsOverride ?? getCompartments(db, state.sessionId);
-  const current = readCurrentMarkersFromCompartments(db, state, currentCompartments, meta.cachedM0ProjectDocsHash ?? undefined);
+function mustMaterializePi(state2, db, currentCompartmentsOverride) {
+  const meta = getOrCreateSessionMeta(db, state2.sessionId);
+  const currentCompartments = currentCompartmentsOverride ?? getRenderableCompartmentsPi(db, state2);
+  const current = readCurrentMarkersFromCompartments(db, state2, currentCompartments, meta.cachedM0ProjectDocsHash ?? undefined);
   if (!meta.cachedM0Bytes)
     return { value: true, reason: "first_render" };
   if (!meta.cachedM1Bytes)
@@ -15982,21 +16613,21 @@ function mustMaterializePi(state, db, currentCompartmentsOverride) {
   if (!decodeCachedM0(meta.cachedM0Bytes)) {
     return { value: true, reason: "cache_invalid" };
   }
-  const cached = getCachedMarkers(db, state, currentCompartments);
+  const cached = getCachedMarkers(db, state2, currentCompartments);
   if (cached === null) {
     return { value: true, reason: "cache_invalid" };
   }
   if (cached.compartmentRenderEpoch !== current.compartmentRenderEpoch) {
     return { value: true, reason: "compartment_render_epoch" };
   }
-  const hard = state.hardSignals ?? EMPTY_PI_HARD_SIGNALS;
+  const hard = state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS;
   if (hard.modelKey !== "" && hard.modelKey !== (meta.cachedM0ModelKey ?? "")) {
     return { value: true, reason: "model_change" };
   }
   if (hard.systemHash !== "" && hard.systemHash !== (meta.cachedM0SystemHash ?? "")) {
     return { value: true, reason: "system_hash" };
   }
-  if (meta.cachedM0ProjectIdentity !== null && meta.cachedM0ProjectIdentity !== state.projectIdentity) {
+  if (meta.cachedM0ProjectIdentity !== null && meta.cachedM0ProjectIdentity !== state2.projectIdentity) {
     return { value: true, reason: "project_change" };
   }
   if (hard.cacheExpired && hard.lastResponseTime > 0 && hard.lastResponseTime > (meta.cachedM0MaterializedAt ?? 0)) {
@@ -16026,9 +16657,9 @@ ${memories.map((memory) => `- ${escapeXmlContent(memory.content)}`).join(`
 `)}
 </${wrapper}>`;
 }
-function renderM0Pi(state, db, projectDocs = readProjectDocsForPiM0(state).renderedBlock, decayPressureMultiplier = 1, memoriesOverride, compartmentsOverride, userProfileOverride, workspaceOverride, mural) {
-  const memPath = memoryProjectPath(state);
-  const workspace = workspaceOverride ?? resolveWorkspaceRenderContextPi(state, db);
+function renderM0Pi(state2, db, projectDocs = readProjectDocsForPiM0(state2).renderedBlock, decayPressureMultiplier = 1, memoriesOverride, compartmentsOverride, userProfileOverride, workspaceOverride, mural) {
+  const memPath = memoryProjectPath(state2);
+  const workspace = workspaceOverride ?? resolveWorkspaceRenderContextPi(state2, db);
   const allMemories = memoriesOverride ?? (memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"]) : []);
   const memoryRenderOptions = {
     sourceNameByMemoryId: sourceNamesForPiMemories({
@@ -16037,23 +16668,25 @@ function renderM0Pi(state, db, projectDocs = readProjectDocsForPiM0(state).rende
       workspace
     })
   };
-  const memories = allMemories.length > 0 ? workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state.sessionId, allMemories, state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, workspace, memoryRenderOptions).renderOrder : trimMemoriesToBudgetV2(state.sessionId, allMemories, state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS).renderOrder : allMemories;
+  const memories = allMemories.length > 0 ? workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state2.sessionId, allMemories, state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, workspace, memoryRenderOptions).renderOrder : trimMemoriesToBudgetV2(state2.sessionId, allMemories, state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS).renderOrder : allMemories;
   const memoryBlock = memories.length > 0 ? renderMemoryBlockV2(memories, "project-memory", memoryRenderOptions) : undefined;
-  const baseHistoryBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  const baseHistoryBudget = state2.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   const decayed = renderDecayedCompartments({
-    compartments: compartmentsOverride ?? getCompartments(db, state.sessionId),
+    compartments: compartmentsOverride ?? getRenderableCompartmentsPi(db, state2),
     historyBudgetTokens: baseHistoryBudget / Math.max(1, decayPressureMultiplier)
   });
   const sections = [];
   if (projectDocs.length > 0)
     sections.push(projectDocs);
-  const trimmedProfile = trimUserMemoriesToBudget(userProfileOverride ?? safeGetActiveUserMemoriesPi(db), state.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS);
+  const trimmedProfile = trimUserMemoriesToBudget(userProfileOverride ?? safeGetActiveUserMemoriesPi(db), state2.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS);
   const userProfile = renderUserProfileBlock(db, "user-profile", trimmedProfile);
   if (userProfile.length > 0)
     sections.push(userProfile);
-  sections.push(decayed.length > 0 ? `<session-history>
+  if (!state2.compactionOff) {
+    sections.push(decayed.length > 0 ? `<session-history>
 ${decayed}
 </session-history>` : "<session-history></session-history>");
+  }
   if (memoryBlock)
     sections.push(memoryBlock);
   if (mural?.enabled && mural.supportsVision && mural.dataUrl) {
@@ -16065,18 +16698,18 @@ The project memory mural image follows.
 
 `).trim();
 }
-function renderedMemoryIdsForPi(state, memories, workspace, db) {
+function renderedMemoryIdsForPi(state2, memories, workspace, db) {
   if (memories.length === 0)
     return [];
-  const resolvedWorkspace = workspace ?? (db ? resolveWorkspaceRenderContextPi(state, db) : undefined);
+  const resolvedWorkspace = workspace ?? (db ? resolveWorkspaceRenderContextPi(state2, db) : undefined);
   const renderOptions = resolvedWorkspace ? {
     sourceNameByMemoryId: sourceNamesForPiMemories({
       memories,
-      projectPath: memoryProjectPath(state),
+      projectPath: memoryProjectPath(state2),
       workspace: resolvedWorkspace
     })
   } : {};
-  const trimmed = resolvedWorkspace?.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state.sessionId, [...memories], state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, resolvedWorkspace, renderOptions) : trimMemoriesToBudgetV2(state.sessionId, [...memories], state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS);
+  const trimmed = resolvedWorkspace?.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state2.sessionId, [...memories], state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, resolvedWorkspace, renderOptions) : trimMemoriesToBudgetV2(state2.sessionId, [...memories], state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS);
   return trimmed.renderOrder.map((memory) => memory.id);
 }
 function isTransientSqliteLockError(error) {
@@ -16099,11 +16732,11 @@ class PiMaterializeContentionError extends Error {
     this.name = "PiMaterializeContentionError";
   }
 }
-function readFrozenM0InputsPi(state, db, docs = readProjectDocsForPiM0(state), memoryCutoff) {
-  const memPath = memoryProjectPath(state);
+function readFrozenM0InputsPi(state2, db, docs = readProjectDocsForPiM0(state2), memoryCutoff) {
+  const memPath = memoryProjectPath(state2);
   const read = db.transaction(() => {
-    const workspace = resolveWorkspaceRenderContextPi(state, db);
-    const compartments = getCompartments(db, state.sessionId);
+    const workspace = resolveWorkspaceRenderContextPi(state2, db);
+    const compartments = getRenderableCompartmentsPi(db, state2);
     const memories = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], memoryCutoff, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"], memoryCutoff) : [];
     const userProfile = safeGetActiveUserMemoriesPi(db);
     const projectState = memPath ? getProjectState(db, memPath) : undefined;
@@ -16111,72 +16744,72 @@ function readFrozenM0InputsPi(state, db, docs = readProjectDocsForPiM0(state), m
     const markers = {
       maxCompartmentSeq: compartments.reduce((max, compartment) => compartment.sequence > max ? compartment.sequence : max, EMPTY_MAX_COMPARTMENT_SEQ),
       maxMemoryId: memPath ? workspace.isWorkspaced ? getMaxMemoryIdForProjects(db, workspace.expandedIdentities, workspace.ownIdentities, workspace.shareCategories) : getMaxMemoryIdForProjects(db, [memPath]) : 0,
-      maxMutationId: getMaxM0MutationId(db, state.sessionId) ?? 0,
+      maxMutationId: getMaxM0MutationId(db, state2.sessionId) ?? 0,
       maxMemoryMutationId: memPath ? workspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(db, workspace.expandedIdentities) ?? 0 : getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
       projectMemoryEpoch: projectState?.projectMemoryEpoch ?? 0,
       workspaceFingerprint: workspace.isWorkspaced ? computeWorkspaceEpochFingerprint(db, workspace.identities) : null,
       projectUserProfileVersion: globalState?.projectUserProfileVersion ?? 0,
       projectDocsHash: docs.canonicalHash,
-      sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
+      sessionFactsVersion: getSessionFactsVersion(db, state2.sessionId),
       materializedAt: memoryCutoff ?? Date.now(),
       upgradeState: `${PI_M0_UPGRADE_STATE}:${compartments.some((c) => c.legacy === 1) ? "legacy" : "ready"}`,
       compartmentRenderEpoch: COMPARTMENT_RENDER_EPOCH,
       lastBaselineEndMessageId: lastBaselineEndMessageId(compartments),
-      systemHash: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
-      modelKey: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
-      projectIdentity: state.projectIdentity
+      systemHash: (state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
+      modelKey: (state2.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey,
+      projectIdentity: state2.projectIdentity
     };
     return { docs, markers, compartments, memories, userProfile, workspace };
   });
   return read();
 }
-function renderFreshM0PiNonPersisted(state, db) {
-  const docs = readProjectDocsForPiM0(state);
-  const cachedMaterializedAt = getOrCreateSessionMeta(db, state.sessionId).cachedM0MaterializedAt ?? 0;
-  const frozen = readFrozenM0InputsPi(state, db, docs, cachedMaterializedAt);
+function renderFreshM0PiNonPersisted(state2, db) {
+  const docs = readProjectDocsForPiM0(state2);
+  const cachedMaterializedAt = getOrCreateSessionMeta(db, state2.sessionId).cachedM0MaterializedAt ?? 0;
+  const frozen = readFrozenM0InputsPi(state2, db, docs, cachedMaterializedAt);
   frozen.markers.materializedAt = cachedMaterializedAt;
-  const historyBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
-  const memoryBudget = state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
-  const mural = resolveMuralForM0Pi(state, db, frozen.markers.modelKey, memoryBudget);
-  rememberPiMural(state.sessionId, mural);
+  const historyBudget = state2.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  const memoryBudget = state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
+  const mural = resolveMuralForM0Pi(state2, db, frozen.markers.modelKey, memoryBudget);
+  rememberPiMural(state2.sessionId, mural);
   let dpm = 1;
-  let m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace, mural);
+  let m0 = renderM0Pi(state2, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace, mural);
   let attempts = 0;
   while (historyBudget > 0 && historySliceTokensPi(m0) > historyBudget * 1.05 && attempts < 3) {
     dpm *= 1.15;
-    m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace, mural);
+    m0 = renderM0Pi(state2, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace, mural);
     attempts += 1;
   }
   return {
     m0,
     snapshotMarkers: frozen.markers,
-    renderedMemoryIds: renderedMemoryIdsForPi(state, frozen.memories, frozen.workspace, db)
+    renderedMemoryIds: renderedMemoryIdsForPi(state2, frozen.memories, frozen.workspace, db)
   };
 }
-function materializeM0Pi(state, db) {
-  const docs = readProjectDocsForPiM0(state);
+function materializeM0Pi(state2, db) {
+  const docs = readProjectDocsForPiM0(state2);
   const foldMaterializedAt = Date.now();
-  const frozen = readFrozenM0InputsPi(state, db, docs, foldMaterializedAt);
+  const frozen = readFrozenM0InputsPi(state2, db, docs, foldMaterializedAt);
   const snapshotMarkers = frozen.markers;
   const snapshotMemories = frozen.memories;
   const snapshotCompartments = frozen.compartments;
   const snapshotUserProfile = frozen.userProfile;
-  const renderedMemoryIds = renderedMemoryIdsForPi(state, snapshotMemories, frozen.workspace, db);
-  const memoryBudget = state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
-  const mural = resolveMuralForM0Pi(state, db, snapshotMarkers.modelKey, memoryBudget);
+  const renderedMemoryIds = renderedMemoryIdsForPi(state2, snapshotMemories, frozen.workspace, db);
+  const memoryBudget = state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
+  const mural = resolveMuralForM0Pi(state2, db, snapshotMarkers.modelKey, memoryBudget);
   const frozenMuralDataUrl = mural?.enabled && mural.supportsVision ? mural.dataUrl ?? null : null;
   const frozenMuralHash = mural?.enabled && mural.supportsVision ? mural.contentHash ?? null : null;
   let decayPressureMultiplier = 1;
-  let m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace, mural);
-  const historyBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  let m0 = renderM0Pi(state2, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace, mural);
+  const historyBudget = state2.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   let attempts = 0;
   while (historyBudget > 0 && historySliceTokensPi(m0) > historyBudget * 1.05 && attempts < 3) {
     decayPressureMultiplier *= 1.15;
-    m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace, mural);
+    m0 = renderM0Pi(state2, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace, mural);
     attempts += 1;
   }
   const m0Bytes = Buffer.from(m0, "utf8");
-  const phase3ProjectDocsHash = readProjectDocsForPiM0(state).canonicalHash;
+  const phase3ProjectDocsHash = readProjectDocsForPiM0(state2).canonicalHash;
   try {
     db.exec("BEGIN IMMEDIATE");
   } catch (error) {
@@ -16186,7 +16819,7 @@ function materializeM0Pi(state, db) {
     throw error;
   }
   try {
-    const current = readCurrentMarkers(db, state, phase3ProjectDocsHash);
+    const current = readCurrentMarkers(db, state2, phase3ProjectDocsHash);
     const memoryEpochStale = current.workspaceFingerprint !== null || snapshotMarkers.workspaceFingerprint !== null ? current.workspaceFingerprint !== snapshotMarkers.workspaceFingerprint : current.projectMemoryEpoch !== snapshotMarkers.projectMemoryEpoch;
     const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.projectIdentity !== snapshotMarkers.projectIdentity || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState;
     if (stale) {
@@ -16194,9 +16827,9 @@ function materializeM0Pi(state, db) {
       throw new PiMaterializeContentionError("snapshot changed before persist");
     }
     snapshotMarkers.materializedAt = foldMaterializedAt;
-    const m1Render = renderM1PiWithMetadata(state, db, snapshotMarkers, renderedMemoryIds);
+    const m1Render = renderM1PiWithMetadata(state2, db, snapshotMarkers, renderedMemoryIds);
     const m1Bytes = Buffer.from(m1Render.text, "utf8");
-    persistCachedM0(db, state.sessionId, {
+    persistCachedM0(db, state2.sessionId, {
       m0Bytes,
       muralDataUrl: frozenMuralDataUrl,
       muralHash: frozenMuralHash,
@@ -16216,10 +16849,10 @@ function materializeM0Pi(state, db) {
       modelKey: snapshotMarkers.modelKey,
       projectIdentity: snapshotMarkers.projectIdentity
     });
-    db.prepare("UPDATE session_meta SET memory_block_count = ?, memory_block_ids = ? WHERE session_id = ?").run(renderedMemoryIds.length, JSON.stringify(renderedMemoryIds), state.sessionId);
-    setCachedBoundary(db, state.sessionId, snapshotMarkers.lastBaselineEndMessageId);
+    db.prepare("UPDATE session_meta SET memory_block_count = ?, memory_block_ids = ? WHERE session_id = ?").run(renderedMemoryIds.length, JSON.stringify(renderedMemoryIds), state2.sessionId);
+    setCachedBoundary(db, state2.sessionId, snapshotMarkers.lastBaselineEndMessageId);
     db.exec("COMMIT");
-    rememberPiMuralPayload(state.sessionId, frozenMuralDataUrl, frozenMuralHash);
+    rememberPiMuralPayload(state2.sessionId, frozenMuralDataUrl, frozenMuralHash);
     return {
       m0,
       m1: m1Render.text,
@@ -16233,11 +16866,11 @@ function materializeM0Pi(state, db) {
     throw error;
   }
 }
-function materializeM0PiWithRetry(state, db, maxRetries = 3) {
+function materializeM0PiWithRetry(state2, db, maxRetries = 3) {
   let lastError = null;
   for (let attempt = 0;attempt < maxRetries; attempt++) {
     try {
-      return materializeM0Pi(state, db);
+      return materializeM0Pi(state2, db);
     } catch (error) {
       if (!(error instanceof PiMaterializeContentionError))
         throw error;
@@ -16279,10 +16912,10 @@ ${lines.join(`
     count: mutations.length
   };
 }
-function renderM1PiWithMetadata(state, db, markers, renderedMemoryIds, compartmentsOverride) {
+function renderM1PiWithMetadata(state2, db, markers, renderedMemoryIds, compartmentsOverride) {
   const sections = [];
-  const workspace = resolveWorkspaceRenderContextPi(state, db);
-  const memPath = memoryProjectPath(state);
+  const workspace = resolveWorkspaceRenderContextPi(state2, db);
+  const memPath = memoryProjectPath(state2);
   const memoryUpdates = memPath ? renderMemoryUpdatesBlockPi({
     db,
     projectPath: memPath,
@@ -16292,7 +16925,7 @@ function renderM1PiWithMetadata(state, db, markers, renderedMemoryIds, compartme
   }) : { block: undefined, count: 0 };
   if (memoryUpdates.block)
     sections.push(memoryUpdates.block);
-  const newCompartments = (compartmentsOverride ?? getCompartments(db, state.sessionId)).filter((compartment) => compartment.sequence > markers.maxCompartmentSeq);
+  const newCompartments = (compartmentsOverride ?? getRenderableCompartmentsPi(db, state2)).filter((compartment) => compartment.sequence > markers.maxCompartmentSeq);
   if (newCompartments.length > 0) {
     const body = newCompartments.map((compartment) => renderCompartmentAtTier(compartment, 1)).join(`
 
@@ -16303,7 +16936,7 @@ ${body}
   }
   const newMemories = memPath ? workspace.isWorkspaced ? readNewMemoriesForM1Union(db, workspace.expandedIdentities, markers.maxMemoryId, markers.materializedAt, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"], markers.materializedAt).filter((memory) => memory.id > markers.maxMemoryId) : [];
   if (newMemories.length > 0) {
-    const memoryBudget = state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
+    const memoryBudget = state2.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
     const memoryRenderOptions = {
       sourceNameByMemoryId: sourceNamesForPiMemories({
         memories: newMemories,
@@ -16311,14 +16944,14 @@ ${body}
         workspace
       })
     };
-    const trimmedNewMemories = trimMemoriesToBudgetV2(state.sessionId, newMemories, Math.max(1, Math.floor(memoryBudget * 0.25)), memoryRenderOptions).renderOrder;
+    const trimmedNewMemories = trimMemoriesToBudgetV2(state2.sessionId, newMemories, Math.max(1, Math.floor(memoryBudget * 0.25)), memoryRenderOptions).renderOrder;
     const newMemoriesBlock = renderMemoryBlockV2(trimmedNewMemories, "new-memories", memoryRenderOptions);
     if (newMemoriesBlock)
       sections.push(newMemoriesBlock);
   }
   const currentUserProfileVersion = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH)?.projectUserProfileVersion ?? 0;
   if (currentUserProfileVersion !== markers.projectUserProfileVersion) {
-    const profileBudget = state.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS;
+    const profileBudget = state2.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS;
     const trimmedProfile = trimUserMemoriesToBudget(safeGetActiveUserMemoriesPi(db), Math.max(1, Math.floor(profileBudget * 0.25)));
     const profileBlock = renderUserProfileBlock(db, "new-user-profile", trimmedProfile);
     if (profileBlock)
@@ -16331,7 +16964,10 @@ ${body}
     };
   }
   return {
-    text: `<session-history-since>
+    text: state2.compactionOff ? `<knowledge-updates>
+${sections.join(`
+`)}
+</knowledge-updates>` : `<session-history-since>
 ${sections.join(`
 `)}
 </session-history-since>`,
@@ -16427,8 +17063,8 @@ function cachedPiRowMatchesSnapshot(args) {
     return false;
   return bufferEqualsNullable(args.row.cached_m0_bytes, args.m0Bytes) && rowMarkers.projectMemoryEpoch === args.markers.projectMemoryEpoch && rowMarkers.projectUserProfileVersion === args.markers.projectUserProfileVersion && rowMarkers.maxCompartmentSeq === args.markers.maxCompartmentSeq && rowMarkers.maxMemoryId === args.markers.maxMemoryId && rowMarkers.maxMutationId === args.markers.maxMutationId && rowMarkers.maxMemoryMutationId === args.markers.maxMemoryMutationId && rowMarkers.materializedAt === args.markers.materializedAt && rowMarkers.sessionFactsVersion === args.markers.sessionFactsVersion && (rowMarkers.upgradeState ?? null) === (args.markers.upgradeState ?? null) && rowMarkers.compartmentRenderEpoch === args.markers.compartmentRenderEpoch && (rowMarkers.systemHash ?? "") === (args.markers.systemHash ?? "") && (rowMarkers.modelKey ?? "") === (args.markers.modelKey ?? "") && (rowMarkers.projectIdentity ?? null) === (args.markers.projectIdentity ?? null) && (rowMarkers.workspaceFingerprint ?? null) === (args.markers.workspaceFingerprint ?? null);
 }
-function adoptCachedPiProjectIdentity(db, state) {
-  db.prepare("UPDATE session_meta SET cached_m0_project_identity = ? WHERE session_id = ? AND cached_m0_project_identity IS NULL").run(state.projectIdentity, state.sessionId);
+function adoptCachedPiProjectIdentity(db, state2) {
+  db.prepare("UPDATE session_meta SET cached_m0_project_identity = ? WHERE session_id = ? AND cached_m0_project_identity IS NULL").run(state2.projectIdentity, state2.sessionId);
 }
 function decodeCachedM1(row, sessionId) {
   if (!row.cached_m1_bytes) {
@@ -16449,12 +17085,12 @@ function applyCachedPiRow(args) {
     markers
   };
 }
-function replayCachedM1Pi(db, state, compartmentsForNormalization) {
-  const row = readCachedPiM0M1Row(db, state.sessionId);
+function replayCachedM1Pi(db, state2, compartmentsForNormalization) {
+  const row = readCachedPiM0M1Row(db, state2.sessionId);
   if (!row) {
-    throw new PiMaterializeContentionError(`missing cached m[0]/m[1] for ${state.sessionId}`);
+    throw new PiMaterializeContentionError(`missing cached m[0]/m[1] for ${state2.sessionId}`);
   }
-  return applyCachedPiRow({ row, state, compartmentsForNormalization });
+  return applyCachedPiRow({ row, state: state2, compartmentsForNormalization });
 }
 function softRefreshCachedM1Pi(args) {
   args.db.exec("BEGIN IMMEDIATE");
@@ -16471,7 +17107,7 @@ function softRefreshCachedM1Pi(args) {
       if (!sibling) {
         throw new PiMaterializeContentionError(`missing sibling cached m[0]/m[1] for ${args.state.sessionId}`);
       }
-      const siblingCompartments = getCompartments(args.db, args.state.sessionId);
+      const siblingCompartments = getRenderableCompartmentsPi(args.db, args.state);
       return {
         ...applyCachedPiRow({
           row: sibling,
@@ -16538,9 +17174,9 @@ function prependM0M1Messages(piMessages, m0, m1, mural) {
     timestamp: baseTimestamp - 1
   });
 }
-function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = false) {
-  const currentCompartments = getCompartments(db, state.sessionId);
-  let decision = mustMaterializePi(state, db, currentCompartments);
+function injectM0M1Pi(state2, db, piMessages, entryIds, recomputeM1ThisPass = false) {
+  const currentCompartments = getRenderableCompartmentsPi(db, state2);
+  let decision = mustMaterializePi(state2, db, currentCompartments);
   let m0 = "";
   let m1 = PI_M1_PLACEHOLDER;
   let markers = null;
@@ -16551,7 +17187,7 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
   let freshFallbackRenderedMemoryIds = null;
   if (decision.value) {
     try {
-      const result = materializeM0PiWithRetry(state, db);
+      const result = materializeM0PiWithRetry(state2, db);
       m0 = result.m0;
       m1 = result.m1;
       markers = result.snapshotMarkers;
@@ -16561,30 +17197,30 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
       if (!(error instanceof PiMaterializeContentionError))
         throw error;
       try {
-        const cached = replayCachedM1Pi(db, state, currentCompartments);
+        const cached = replayCachedM1Pi(db, state2, currentCompartments);
         contentionExhausted = true;
         m0 = cached.m0;
         m1 = cached.m1;
         markers = cached.markers;
-        sessionLog(state.sessionId, "pi m[0] materialization contention exhausted; reusing cached m[0]/m[1]");
+        sessionLog(state2.sessionId, "pi m[0] materialization contention exhausted; reusing cached m[0]/m[1]");
       } catch {
-        const fresh = renderFreshM0PiNonPersisted(state, db);
+        const fresh = renderFreshM0PiNonPersisted(state2, db);
         m0 = fresh.m0;
         markers = fresh.snapshotMarkers;
         freshFallbackRenderedMemoryIds = fresh.renderedMemoryIds;
         contentionExhausted = true;
-        sessionLog(state.sessionId, "pi m[0] materialization contention exhausted with no cached fallback; rendered fresh non-persisted m[0]/m[1]");
+        sessionLog(state2.sessionId, "pi m[0] materialization contention exhausted with no cached fallback; rendered fresh non-persisted m[0]/m[1]");
       }
     }
   } else {
-    const meta = getOrCreateSessionMeta(db, state.sessionId);
+    const meta = getOrCreateSessionMeta(db, state2.sessionId);
     m0 = decodeCachedM0(meta.cachedM0Bytes) ?? "";
-    rememberPiMuralPayload(state.sessionId, meta.cachedM0MuralDataUrl, meta.cachedM0MuralHash);
-    markers = getCachedMarkers(db, state, currentCompartments);
+    rememberPiMuralPayload(state2.sessionId, meta.cachedM0MuralDataUrl, meta.cachedM0MuralHash);
+    markers = getCachedMarkers(db, state2, currentCompartments);
     if (!m0 || !markers) {
       decision = { value: true, reason: "cache_invalid" };
       try {
-        const result = materializeM0PiWithRetry(state, db);
+        const result = materializeM0PiWithRetry(state2, db);
         m0 = result.m0;
         m1 = result.m1;
         markers = result.snapshotMarkers;
@@ -16593,30 +17229,30 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
       } catch (error) {
         if (!(error instanceof PiMaterializeContentionError))
           throw error;
-        const fresh = renderFreshM0PiNonPersisted(state, db);
+        const fresh = renderFreshM0PiNonPersisted(state2, db);
         m0 = fresh.m0;
         markers = fresh.snapshotMarkers;
         freshFallbackRenderedMemoryIds = fresh.renderedMemoryIds;
         contentionExhausted = true;
-        sessionLog(state.sessionId, "pi m[0] cache_invalid materialization contention exhausted; rendered fresh non-persisted m[0]/m[1]");
+        sessionLog(state2.sessionId, "pi m[0] cache_invalid materialization contention exhausted; rendered fresh non-persisted m[0]/m[1]");
       }
     }
   }
   if (!markers) {
-    throw new PiMaterializeContentionError(`missing m[0] markers for ${state.sessionId}`);
+    throw new PiMaterializeContentionError(`missing m[0] markers for ${state2.sessionId}`);
   }
   if (!materialized && markers.projectIdentity === null) {
-    adoptCachedPiProjectIdentity(db, state);
-    markers = { ...markers, projectIdentity: state.projectIdentity };
+    adoptCachedPiProjectIdentity(db, state2);
+    markers = { ...markers, projectIdentity: state2.projectIdentity };
   }
   if (materialized) {} else if (contentionExhausted && freshFallbackRenderedMemoryIds) {
-    const freshM1 = renderM1PiWithMetadata(state, db, markers, freshFallbackRenderedMemoryIds);
+    const freshM1 = renderM1PiWithMetadata(state2, db, markers, freshFallbackRenderedMemoryIds);
     m1 = freshM1.text;
     memoryUpdateCount = freshM1.memoryUpdateCount;
     m1Recomputed = true;
   } else if (contentionExhausted) {} else if (recomputeM1ThisPass) {
     const refreshed = softRefreshCachedM1Pi({
-      state,
+      state: state2,
       db,
       m0Bytes: Buffer.from(m0, "utf8"),
       markers,
@@ -16628,7 +17264,7 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
     memoryUpdateCount = refreshed.memoryUpdateCount;
     m1Recomputed = refreshed.recomputed;
   } else {
-    const replayed = replayCachedM1Pi(db, state, currentCompartments);
+    const replayed = replayCachedM1Pi(db, state2, currentCompartments);
     m0 = replayed.m0;
     m1 = replayed.m1;
     markers = replayed.markers;
@@ -16636,14 +17272,14 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
   const M0_DRIFT_RATIO_FLOOR_TOKENS = 500;
   const M1_DRIFT_RATIO = 0.15;
   const M1_ABSOLUTE_CAP_RATIO = 0.2;
-  const m1AbsoluteBudget = (state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS) * M1_ABSOLUTE_CAP_RATIO;
+  const m1AbsoluteBudget = (state2.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS) * M1_ABSOLUTE_CAP_RATIO;
   const m1HasContent = m1 !== PI_M1_PLACEHOLDER;
-  const { m0Tokens, m1Tokens } = cachedInjectionTokenCounts(state.sessionId, m0, m1);
+  const { m0Tokens, m1Tokens } = cachedInjectionTokenCounts(state2.sessionId, m0, m1);
   const m1OverAbsoluteCap = m1HasContent && m1Tokens > m1AbsoluteBudget;
   if (!materialized && !contentionExhausted && m1Recomputed && recomputeM1ThisPass && (memoryUpdateCount > 40 || m1OverAbsoluteCap || m1HasContent && m0Tokens >= M0_DRIFT_RATIO_FLOOR_TOKENS && m1Tokens > m0Tokens * M1_DRIFT_RATIO)) {
     decision = { value: true, reason: "drift" };
     try {
-      const result = materializeM0PiWithRetry(state, db);
+      const result = materializeM0PiWithRetry(state2, db);
       m0 = result.m0;
       m1 = result.m1;
       markers = result.snapshotMarkers;
@@ -16666,17 +17302,17 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
     }
   }
   const skippedVisibleMessages = boundaryId ? trimPiMessagesToBoundary(piMessages, entryIds, boundaryId) : 0;
-  const muralWire = m0.includes("<memory-mural>") ? muralForWire(state.sessionId) : undefined;
+  const muralWire = m0.includes("<memory-mural>") ? muralForWire(state2.sessionId) : undefined;
   if (!muralWire)
     m0 = stripMemoryMuralBlock(m0);
   prependM0M1Messages(piMessages, m0, m1, muralWire);
-  sessionLog(state.sessionId, `injected m[0]/m[1] into Pi messages (${m0.length} + ${m1.length} bytes, materialized=${materialized}${decision.reason ? ` reason=${decision.reason}` : ""})`);
-  const memPath = memoryProjectPath(state);
-  const workspace = resolveWorkspaceRenderContextPi(state, db);
+  sessionLog(state2.sessionId, `injected m[0]/m[1] into Pi messages (${m0.length} + ${m1.length} bytes, materialized=${materialized}${decision.reason ? ` reason=${decision.reason}` : ""})`);
+  const memPath = memoryProjectPath(state2);
+  const workspace = resolveWorkspaceRenderContextPi(state2, db);
   const memoryCount = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories).length : getMemoriesByProject(db, memPath, ["active", "permanent"]).length : 0;
   return {
     injected: true,
-    compartmentCount: getCompartments(db, state.sessionId).length,
+    compartmentCount: currentCompartments.length,
     factCount: 0,
     memoryCount,
     skippedVisibleMessages,
@@ -16738,6 +17374,16 @@ function isSentinelPart(part) {
   return p.type === "text" && typeof p.text === "string" && (p.text === "" || p.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT);
 }
 
+// src/pi-context-limit.ts
+function resolvePiUsableContextLimit(args) {
+  const rawContext = isSaneLimit(args.rawContextWindow) ? args.rawContextWindow : undefined;
+  const detected = typeof args.detectedContextLimit === "number" && Number.isFinite(args.detectedContextLimit) && args.detectedContextLimit >= 1024 ? args.detectedContextLimit : undefined;
+  const context = rawContext !== undefined && detected !== undefined ? Math.min(rawContext, detected) : rawContext ?? detected;
+  if (context === undefined)
+    return;
+  return resolveLimit({ context, output: args.model?.maxTokens }, args.model?.provider ?? "unknown", args.model?.id ?? "unknown");
+}
+
 // src/pi-historian-runner.ts
 import * as crypto2 from "node:crypto";
 
@@ -19928,6 +20574,7 @@ async function runPiHistorian(deps) {
     twoPass,
     thinkingLevel,
     memoryEnabled,
+    allowHomeProject,
     autoPromote,
     userMemoriesEnabled,
     onPublished,
@@ -20066,7 +20713,7 @@ async function runPiHistorian(deps) {
         rollbackDrainReservation();
         return;
       }
-      const projectPath = resolveProjectIdentityForSession(directory);
+      const projectPath = resolveProjectIdentityForSession(directory, allowHomeProject);
       if (!projectPath) {
         rollbackDrainReservation();
         return;
@@ -22021,7 +22668,6 @@ function extractStableId(msg, index, entryIds) {
 }
 
 // src/context-handler.ts
-var FORCE_MATERIALIZATION_PERCENTAGE = 85;
 var EMERGENCY_BLOCK_PERCENTAGE = 95;
 var FORWARD_PRESSURE_LIMIT_FACTOR = 0.85;
 function applyForwardPressureFloor(trailingPercentage, trailingInputTokens, piUsageTokens, correctedLimit) {
@@ -22643,8 +23289,8 @@ function parsePiFallbackToolOwnerId(ownerMsgId) {
   return { timestamp, role: match[2] ?? "" };
 }
 function databaseIsInTransaction(db) {
-  const state = db;
-  return state.inTransaction === true || state.isTransaction === true;
+  const state2 = db;
+  return state2.inTransaction === true || state2.isTransaction === true;
 }
 function runImmediateTransaction(db, fn) {
   if (databaseIsInTransaction(db)) {
@@ -22770,7 +23416,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const options = baseOptions.resolveForProject?.(projectDirectory) ?? baseOptions;
       const schedulerConfig = options.scheduler ?? DEFAULT_SCHEDULER_CONFIG;
       const scheduler = schedulerFor(options);
-      const projectIdentity = resolveProjectIdentityForSession(projectDirectory) ?? "";
+      const projectIdentity = resolveProjectIdentityForSession(projectDirectory, options.allowHomeProject) ?? "";
       updateSessionProjectTracking(sessionId, projectIdentity, options.db);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
       const tEntryBranch = performance.now();
@@ -22792,7 +23438,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const alignedEntryIds = branchLookup?.alignedEntryIds ?? null;
       const resolvedEntryIds = alignedEntryIds?.length === event.messages.length ? alignedEntryIds : branchEntries === null ? null : collectMessageEntryIdsByRef(ctx, event.messages, sessionId, branchEntries);
       const strictEntryIds = resolvedEntryIds ? [...resolvedEntryIds] : null;
-      if (strictEntryIds && options.injection) {
+      if (strictEntryIds && options.injection && !options.compactionOff) {
         const removed = trimPiMessagesToCachedBoundary(options.db, sessionId, event.messages, strictEntryIds);
         if (removed > 0) {
           logTransformTiming(sessionId, "cachedBoundaryEarlyTrim", tEntryBranch, `removed=${removed}`);
@@ -22840,6 +23486,30 @@ function registerPiContextHandler(pi, baseOptions) {
       const tMeta = performance.now();
       const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
       logTransformTiming(sessionId, "getOrCreateSessionMeta", tMeta);
+      const compactionTransition = reconcilePiCompactionMode({
+        db: options.db,
+        sessionId,
+        compactionOff: options.compactionOff === true,
+        historianRunnable: options.historian !== undefined
+      });
+      if (compactionTransition.recordToWrite) {
+        if (compactionTransition.clearDeferredMarkerState) {
+          clearPiCompactionOffInMemoryState(sessionId);
+        }
+        if (compactionTransition.invalidatedBaseline) {
+          clearPiInjectionTokenCountCache(sessionId);
+          sessionMetaForUsage.cachedM0Bytes = null;
+          sessionMetaForUsage.cachedM1Bytes = null;
+        }
+        let noticeDelivered = compactionTransition.notice === null;
+        if (compactionTransition.notice && ctx.ui?.notify) {
+          ctx.ui.notify(compactionTransition.notice, "info");
+          noticeDelivered = true;
+        }
+        if (noticeDelivered) {
+          commitPiCompactionModeRecord(options.db, sessionId, compactionTransition.recordToWrite);
+        }
+      }
       const usageReset = {
         lastContextPercentage: 0,
         lastInputTokens: 0,
@@ -22883,12 +23553,14 @@ function registerPiContextHandler(pi, baseOptions) {
         usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
       }
       let usageContextLimit = isSaneLimit(piUsage?.contextWindow) ? piUsage.contextWindow : undefined;
+      let detectedContextLimit;
       const tEmergencyRecovery = performance.now();
       let needsEmergencyBump = false;
       let emergencyRecoveryArmed = false;
       try {
-        const overflowState = getOverflowState(options.db, sessionId);
+        const overflowState = options.compactionOff ? { detectedContextLimit: 0, needsEmergencyRecovery: false } : getOverflowState(options.db, sessionId);
         if (overflowState.detectedContextLimit > 0) {
+          detectedContextLimit = overflowState.detectedContextLimit;
           usageContextLimit = Math.min(usageContextLimit ?? overflowState.detectedContextLimit, overflowState.detectedContextLimit);
         }
         emergencyRecoveryArmed = overflowState.needsEmergencyRecovery;
@@ -22906,6 +23578,17 @@ function registerPiContextHandler(pi, baseOptions) {
           usageContextLimit = modelWindow;
         }
       }
+      usageContextLimit = resolvePiUsableContextLimit({
+        rawContextWindow: usageContextLimit,
+        model: ctx.model,
+        detectedContextLimit
+      });
+      const effectiveExecuteThresholdPercentage = resolveExecuteThreshold(schedulerConfig.executeThresholdPercentage, modelKey, 65, {
+        tokensConfig: schedulerConfig.executeThresholdTokens,
+        contextLimit: usageContextLimit,
+        sessionId
+      });
+      const { forceMaterializationPercentage } = escalationBands(effectiveExecuteThresholdPercentage);
       if (!usedPersistedUsage && isSaneLimit(usageContextLimit) && usageInputTokens > 0) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
@@ -22926,7 +23609,7 @@ function registerPiContextHandler(pi, baseOptions) {
       logTransformTiming(sessionId, "schedulerAndUsage", tScheduler);
       const piMessageCount = fullWireMessageCount;
       const looksLikeImportedSession = schedulerDecision === "defer" && usagePercentage === 0 && sessionMeta.lastResponseTime === 0 && piMessageCount >= 50;
-      if (looksLikeImportedSession) {
+      if (looksLikeImportedSession && !options.compactionOff) {
         schedulerDecision = "execute";
         sessionLog(sessionId, `transform: large imported session detected (${piMessageCount} messages, no usage baseline) — forcing execute on first pass`);
       }
@@ -22937,7 +23620,7 @@ function registerPiContextHandler(pi, baseOptions) {
       if (storedStableIdScheme < PI_STABLE_ID_SCHEME && !realEntryIdsAvailable) {
         sessionLog(sessionId, `stable-id scheme cutover deferred: real SessionEntry ids unavailable this pass (branch resolution failed) — will retry when getBranch() succeeds`);
       }
-      if (stableIdSchemeCutover) {
+      if (stableIdSchemeCutover && !options.compactionOff) {
         schedulerDecision = "execute";
         signalPiPendingMaterialization(sessionId);
         sessionLog(sessionId, `stable-id scheme cutover: stored=${storedStableIdScheme} < current=${PI_STABLE_ID_SCHEME} — forcing execute+materialize this pass`);
@@ -22949,14 +23632,18 @@ function registerPiContextHandler(pi, baseOptions) {
         contextUsage: { percentage: usagePercentage },
         sessionMeta,
         historyRefreshSessions,
-        sessionId
+        sessionId,
+        effectiveExecuteThresholdPercentage
       });
-      const { midTurnAdjustedSchedulerDecision, sideEffect } = applyMidTurnDeferral({
+      const { midTurnAdjustedSchedulerDecision, sideEffect } = options.compactionOff ? {
+        midTurnAdjustedSchedulerDecision: "defer",
+        sideEffect: "none"
+      } : applyMidTurnDeferral({
         base: schedulerDecisionEarly,
         bypassReason,
         midTurn
       });
-      if (sideEffect === "set-flag") {
+      if (sideEffect === "set-flag" && !options.compactionOff) {
         const flagPayload = {
           id: crypto3.randomUUID(),
           reason: `${schedulerDecisionEarly}-${bypassReason}`,
@@ -22966,8 +23653,8 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       schedulerDecision = midTurnAdjustedSchedulerDecision;
       sessionLog(sessionId, `[boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
-      const forceMaterialization = usagePercentage >= FORCE_MATERIALIZATION_PERCENTAGE;
-      const isEmergency = usagePercentage >= EMERGENCY_BLOCK_PERCENTAGE;
+      const forceMaterialization = !options.compactionOff && usagePercentage >= forceMaterializationPercentage;
+      const isEmergency = !options.compactionOff && usagePercentage >= EMERGENCY_BLOCK_PERCENTAGE;
       if (isEmergency) {
         const lastNotifiedAt = lastEmergencyNotificationAtMs.get(sessionId) ?? 0;
         const now = Date.now();
@@ -22983,7 +23670,7 @@ function registerPiContextHandler(pi, baseOptions) {
             sessionLog(sessionId, "EMERGENCY: historian wait completed (or timed out)");
           } catch {}
         }
-        if (emergencyRecoveryArmed && realUsagePercentageBeforeEmergencyBump < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && !hasEligiblePiCompartmentHistory(options.db, sessionId)) {
+        if (emergencyRecoveryArmed && realUsagePercentageBeforeEmergencyBump < forceMaterializationPercentage && !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%)");
@@ -23035,6 +23722,7 @@ function registerPiContextHandler(pi, baseOptions) {
         stableIdSchemeCutover,
         schedulerDecision,
         forceMaterialization: forceMaterialization || isEmergency,
+        forceMaterializationPercentage,
         contextUsage: {
           percentage: usagePercentage,
           inputTokens: usageInputTokens
@@ -23047,7 +23735,8 @@ function registerPiContextHandler(pi, baseOptions) {
         temporalAwareness: options.injection?.temporalAwareness === true,
         appendCompaction: resolvePiAppendCompaction(ctx),
         readBranchEntries: resolvePiReadBranchEntries(ctx),
-        isSubagent: sessionMeta.isSubagent
+        isSubagent: sessionMeta.isSubagent,
+        compactionOff: options.compactionOff === true
       });
       logTransformTiming(sessionId, "runPipeline", tRunPipeline);
       const postPipelineStart = performance.now();
@@ -23071,7 +23760,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       logTransformTiming(sessionId, "transformDecisionAndReuseState", tTransformDecision);
       const tHistorianScheduling = performance.now();
-      if (options.historian) {
+      if (options.historian && !options.compactionOff) {
         maybeFireHistorian({
           pi,
           ctx,
@@ -23089,22 +23778,24 @@ function registerPiContextHandler(pi, baseOptions) {
       let outputMessages = result.messages;
       const tNoteNudges = performance.now();
       try {
-        outputMessages = applyNoteNudges({
-          sessionId,
-          db: options.db,
-          messages: outputMessages,
-          projectIdentity,
-          entryIds: strictEntryIds,
-          entryIdByRef: result.postCommitEntryIdByRef,
-          isCacheBusting: isCacheBusting || result.executedWorkThisPass,
-          syntheticLeadingCount: result.syntheticLeadingCount
-        });
+        if (!options.compactionOff) {
+          outputMessages = applyNoteNudges({
+            sessionId,
+            db: options.db,
+            messages: outputMessages,
+            projectIdentity,
+            entryIds: strictEntryIds,
+            entryIdByRef: result.postCommitEntryIdByRef,
+            isCacheBusting: isCacheBusting || result.executedWorkThisPass,
+            syntheticLeadingCount: result.syntheticLeadingCount
+          });
+        }
       } catch (err) {
         sessionLog(sessionId, `note nudges failed: ${err instanceof Error ? err.message : String(err)}`);
       }
       logTransformTiming(sessionId, "noteNudges", tNoteNudges);
       const tAutoSearch = performance.now();
-      if (options.autoSearch?.enabled) {
+      if (options.autoSearch?.enabled && !options.compactionOff) {
         try {
           outputMessages = await runAutoSearchHintForPi({
             sessionId,
@@ -23129,7 +23820,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const tTodoCapture = performance.now();
       try {
         const sessionMetaForTodo = getOrCreateSessionMeta(options.db, sessionId);
-        if (!sessionMetaForTodo.isSubagent && sessionMetaForTodo.lastTodoState !== "") {
+        if (!options.compactionOff && !sessionMetaForTodo.isSubagent && sessionMetaForTodo.lastTodoState !== "") {
           const isCacheBustingForTodo = isCacheBusting || result.executedWorkThisPass;
           outputMessages = injectSyntheticTodowriteForPi({
             db: options.db,
@@ -23147,7 +23838,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const tChannelAccounting = performance.now();
       try {
         const sessionMetaForCh1 = getOrCreateSessionMeta(options.db, sessionId);
-        if (!sessionMetaForCh1.isSubagent) {
+        if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
           const resolvedExecuteThresholdPct = resolveExecuteThreshold(schedulerConfig.executeThresholdPercentage ?? 65, liveModelBySession.get(sessionId), 65, {
             tokensConfig: schedulerConfig.executeThresholdTokens,
             contextLimit: usageContextLimit ?? 0
@@ -23214,7 +23905,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
       const tStableIdSchemePersist = performance.now();
-      if (stableIdSchemeCutover) {
+      if (stableIdSchemeCutover && !options.compactionOff) {
         persistStableIdSchemeForRun(options.db, sessionId, {
           piStableIdScheme: PI_STABLE_ID_SCHEME
         });
@@ -23239,7 +23930,7 @@ function registerPiContextHandler(pi, baseOptions) {
       sessionLog(sessionId, `transform completed in ${transformElapsedMs.toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       return { messages: outputMessages };
     } catch (err) {
-      if (isFailClosedBlockingError(err))
+      if (isFailClosedBlockingError(err) && !baseOptions.compactionOff)
         throw err;
       const message = err instanceof Error ? err.message : String(err);
       const stack = err instanceof Error ? err.stack : undefined;
@@ -23396,6 +24087,7 @@ function spawnPiHistorianRun(args) {
         twoPass: historian.twoPass,
         thinkingLevel: historian.thinkingLevel,
         memoryEnabled: historian.memoryEnabled,
+        allowHomeProject: historian.allowHomeProject,
         autoPromote: historian.autoPromote,
         userMemoriesEnabled: historian.userMemoriesEnabled,
         language: historian.language,
@@ -23475,15 +24167,22 @@ function maybeFireHistorian(args) {
     const piUsage = ctx.getContextUsage?.();
     let usageSource;
     usageContextLimit = isSaneLimit(piUsage?.contextWindow) ? piUsage.contextWindow : undefined;
+    let detectedContextLimit;
     if (usageContextLimit === undefined && isSaneLimit(ctx.model?.contextWindow)) {
       usageContextLimit = ctx.model.contextWindow;
     }
     try {
       const overflowState = getOverflowState(db, sessionId);
       if (overflowState.detectedContextLimit > 0) {
+        detectedContextLimit = overflowState.detectedContextLimit;
         usageContextLimit = Math.min(usageContextLimit ?? overflowState.detectedContextLimit, overflowState.detectedContextLimit);
       }
     } catch {}
+    usageContextLimit = resolvePiUsableContextLimit({
+      rawContextWindow: usageContextLimit,
+      model: ctx.model,
+      detectedContextLimit
+    });
     const sessionMetaForUsage = getOrCreateSessionMeta(db, sessionId);
     if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
       usage = {
@@ -23522,6 +24221,7 @@ function maybeFireHistorian(args) {
     modelKey,
     usageContextLimit
   });
+  const historianForceMaterializationPercentage = escalationBands(triggerInputs.executeThresholdPercentage).forceMaterializationPercentage;
   const boundaryContextLimit = triggerInputs.contextLimit;
   const resolvePiBoundarySnapshot = (emergencyTailScale) => resolveProtectedTailBoundary(resolveBoundaryContext({
     db,
@@ -23537,7 +24237,7 @@ function maybeFireHistorian(args) {
   }));
   const resolveRunnablePiBoundarySnapshot = () => {
     let snapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot());
-    if (!hasRunnableCompartmentWindow(snapshot) && usage.percentage >= 80) {
+    if (!hasRunnableCompartmentWindow(snapshot) && usage.percentage >= historianForceMaterializationPercentage) {
       snapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot(usage.percentage >= 95 ? 0.25 : 0.5));
     }
     return snapshot;
@@ -23581,15 +24281,15 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
     const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit, () => {
       const messages = provider.readMessages();
       return { messages, absoluteMessageCount: messages.length };
-    }, args.taggerFloor);
+    }, args.taggerFloor, { canClearReasoning: true });
     if (!trigger.shouldFire) {
       sessionLog(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
       try {
         const overflowState = getOverflowState(db, sessionId);
-        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId)) {
+        if (overflowState.needsEmergencyRecovery && usage.percentage < historianForceMaterializationPercentage && !inFlightHistorian.has(sessionId)) {
           boundarySnapshot ??= resolveRunnablePiBoundarySnapshot();
         }
-        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && boundarySnapshot !== undefined && !hasRunnableCompartmentWindow(boundarySnapshot)) {
+        if (overflowState.needsEmergencyRecovery && usage.percentage < historianForceMaterializationPercentage && !inFlightHistorian.has(sessionId) && boundarySnapshot !== undefined && !hasRunnableCompartmentWindow(boundarySnapshot)) {
           clearEmergencyRecovery(db, sessionId);
           sessionLog(sessionId, `historian: disarming stale emergency recovery — real pressure ${usage.percentage.toFixed(1)}% with no runnable compartment window (would otherwise bump to 95% every pass)`);
         }
@@ -23677,7 +24377,45 @@ function captureReasoningMutationRollback(messages) {
     }
   };
 }
+async function runCompactionOffPipeline(args) {
+  let injectionResult = null;
+  if (args.injection) {
+    injectionResult = injectM0M1Pi({
+      sessionId: args.sessionId,
+      projectIdentity: args.projectIdentity,
+      projectDirectory: args.projectDirectory,
+      memoryEnabled: args.injection.memoryEnabled,
+      injectDocs: args.injection.injectDocs,
+      injectionBudgetTokens: args.injection.injectionBudgetTokens,
+      historyBudgetTokens: args.injection.historyBudgetTokens,
+      muralEnabled: args.injection.muralEnabled === true,
+      compactionOff: true
+    }, args.db, args.messages, args.entryIds, false);
+  }
+  return {
+    messages: args.messages,
+    heuristicsExecuted: false,
+    executedWorkThisPass: false,
+    historyInjected: false,
+    syntheticLeadingCount: injectionResult?.syntheticLeadingCount ?? 0,
+    heuristicsResult: null,
+    injectionResult,
+    materialized: injectionResult?.m0Materialized === true,
+    materializeReason: injectionResult?.m0Reason ?? null,
+    droppedTokens: 0,
+    droppedCount: 0,
+    emergency: false,
+    bustedThisPass: injectionResult?.m0Materialized === true,
+    targetCount: 0,
+    reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
+    activeTags: [],
+    postCommitEntryIdByRef: new Map
+  };
+}
 async function runPipeline(args) {
+  if (args.compactionOff)
+    return runCompactionOffPipeline(args);
+  const forceMaterializationPercentage = args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage;
   let executedWorkThisPass = false;
   let historyWasConsumedThisPass = false;
   let materializationSatisfiedThisPass = false;
@@ -23716,7 +24454,7 @@ async function runPipeline(args) {
   })();
   const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
   const ctxReduceCallable = !args.sessionMeta.isSubagent;
-  const canConsumeDeferredLate = args.schedulerDecision === "execute" || args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
+  const canConsumeDeferredLate = args.schedulerDecision === "execute" || args.forceMaterialization === true || args.contextUsage.percentage >= forceMaterializationPercentage;
   const deferredMaterializeEligible = canConsumeDeferredLate && deferredMaterializationSessions.has(args.sessionId);
   const piHardSignals = args.injection ? (() => {
     const hardMeta = args.sessionMeta;
@@ -23966,7 +24704,7 @@ async function runPipeline(args) {
   }
   const toolReclaimExecutePass = args.schedulerDecision === "execute";
   const alreadyMutatingThisPass = pendingOpsDidMutate || heuristicOrReasoningDidMutate;
-  const emergencyDropEligible = args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
+  const emergencyDropEligible = args.forceMaterialization === true || args.contextUsage.percentage >= forceMaterializationPercentage;
   let autoReclaimTargetCount = 0;
   let autoReclaimDidMutate = false;
   if (toolReclaimExecutePass && alreadyMutatingThisPass && !emergencyDropEligible) {
@@ -24353,6 +25091,13 @@ function appendReminderToPiUserMessage(message, reminder) {
   }
   contentArr.push({ type: "text", text: reminder.trimStart() });
 }
+function clearPiCompactionOffInMemoryState(sessionId) {
+  historyRefreshSessions.delete(sessionId);
+  deferredHistoryRefreshSessions.delete(sessionId);
+  pendingMaterializationSessions.delete(sessionId);
+  deferredMaterializationSessions.delete(sessionId);
+  clearPiChannel1State(sessionId);
+}
 function clearContextHandlerSession(sessionId) {
   invalidateTrueRawTokenCache({ sessionId, reason: "pi.branch.changed" });
   activeContextHandlerSessions.delete(sessionId);
@@ -24411,6 +25156,14 @@ No active Pi session is available.`,
         });
         return;
       }
+      if (deps.compactionOff) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-flush",
+          text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
+          level: "warning"
+        });
+        return;
+      }
       const pendingBefore = getPendingOps(deps.db, sessionId).length;
       const result = executeFlush(deps.db, sessionId);
       signalPiHistoryRefresh(sessionId);
@@ -24455,6 +25208,24 @@ function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
 }
 var MAX_HISTORIAN_RETRIES2 = 2;
+var HISTORIAN_REASONING_PART_TYPES = new Set(["reasoning", "thinking", "redacted_thinking"]);
+function extractLatestHistorianReasoning(messages) {
+  if (!Array.isArray(messages))
+    return null;
+  const latest = messages.filter((message) => isRecord(message) && isRecord(message.info) && message.info.role === "assistant").sort((left, right) => historianMessageCreatedAt(right) - historianMessageCreatedAt(left))[0];
+  if (!latest || !Array.isArray(latest.parts))
+    return null;
+  return latest.parts.filter(isHistorianReasoningPart).map((part) => part.text).join(`
+`) || null;
+}
+function isHistorianReasoningPart(part) {
+  return isRecord(part) && typeof part.type === "string" && HISTORIAN_REASONING_PART_TYPES.has(part.type) && typeof part.text === "string" && part.text.length > 0;
+}
+function historianMessageCreatedAt(message) {
+  if (!isRecord(message.info) || !isRecord(message.info.time))
+    return 0;
+  return typeof message.info.time.created === "number" ? message.info.time.created : 0;
+}
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -24520,6 +25291,7 @@ async function runEditorPassOrFallback(args) {
   sessionLog(args.parentSessionId, "historian two-pass: running editor on draft");
   const editorRun = await runHistorianPrompt({
     client: args.client,
+    db: args.db,
     parentSessionId: args.parentSessionId,
     sessionDirectory: args.sessionDirectory,
     prompt: buildHistorianEditorPrompt(args.draftXml),
@@ -24546,6 +25318,7 @@ async function runEditorPassOrFallback(args) {
 async function runHistorianPrompt(args) {
   const {
     client,
+    db,
     parentSessionId,
     sessionDirectory,
     prompt,
@@ -24579,12 +25352,12 @@ async function runHistorianPrompt(args) {
   };
   try {
     sessionLog(parentSessionId, `historian: creating child session (agent=${agentId}, model=${modelOverride ? `${modelOverride.providerID}/${modelOverride.modelID}` : `agent:${agentId}`})`);
-    const createResponse = await client.session.create({
-      body: {
-        parentID: parentSessionId,
-        title: "magic-context-compartment"
-      },
-      query: { directory: sessionDirectory }
+    const createResponse = await createChildSessionWithFence({
+      client,
+      db,
+      parentSessionId,
+      title: "magic-context-compartment",
+      directory: sessionDirectory
     });
     const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
@@ -24632,7 +25405,18 @@ async function runHistorianPrompt(args) {
       preferResponseOnMissingData: true
     });
     const invocationId = recordInvocation5({ status: "completed", messages });
-    const result = extractLatestAssistantText(messages);
+    const lengthCapped = hasLengthCappedOutput(messages);
+    const textResult = extractLatestAssistantText(messages);
+    const reasoningResult = textResult ? null : extractLatestHistorianReasoning(messages);
+    if (!textResult && reasoningResult && lengthCapped) {
+      const outputTokens = sumTokensFromChildMessages(messages).output;
+      return {
+        ok: false,
+        error: `historian output length-capped at ${outputTokens} tokens (all reasoning, no text) — set historian.maxTokens or route historian.model to a low-reasoning lane/variant`,
+        invocationId: invocationId ?? undefined
+      };
+    }
+    const result = textResult ?? reasoningResult;
     if (!result) {
       return {
         ok: false,
@@ -24684,6 +25468,7 @@ async function runFallbackHistorianPass(args) {
     args.callbacks?.onModelFallback?.(modelId, i + 1, chain.length);
     const fallbackRun = await runHistorianPrompt({
       client: args.client,
+      db: args.db,
       parentSessionId: args.parentSessionId,
       sessionDirectory: args.sessionDirectory,
       prompt: args.prompt,
@@ -24779,116 +25564,6 @@ function sanitizeDumpName(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "-");
 }
 
-// ../plugin/src/hooks/magic-context/send-session-notification.ts
-function hasNotificationSessionClient(client) {
-  if (client === null || typeof client !== "object")
-    return false;
-  const candidate = client;
-  if (candidate.session === undefined)
-    return true;
-  if (candidate.session === null || typeof candidate.session !== "object")
-    return false;
-  const session = candidate.session;
-  return (session.prompt === undefined || typeof session.prompt === "function") && (session.promptAsync === undefined || typeof session.promptAsync === "function");
-}
-function inferToastVariant(text) {
-  const lower = text.toLowerCase();
-  if (lower.includes("error") || lower.includes("failed") || lower.includes("alert"))
-    return "error";
-  if (lower.includes("warning") || lower.includes("⚠"))
-    return "warning";
-  if (lower.includes("complete") || lower.includes("success") || lower.includes("✓") || lower.includes("finished"))
-    return "success";
-  return "info";
-}
-function extractToastTitle(text) {
-  const headingMatch = text.match(/^#+\s+(.+)/m);
-  if (headingMatch)
-    return headingMatch[1].trim();
-  const firstLine = text.split(`
-`)[0].trim();
-  if (firstLine.length <= 80)
-    return firstLine;
-  return "Magic Context";
-}
-async function sendIgnoredMessage(client, sessionId, text, params, forcePersist = false) {
-  const title = extractToastTitle(text);
-  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
-  const toastVariant = inferToastVariant(text);
-  const duration = params.toastDurationMs ?? 5000;
-  const { isTuiConnected: checkTui } = await import("./rpc-notifications-td0amw6w.js");
-  if (!forcePersist && checkTui(sessionId)) {
-    try {
-      const { pushNotification } = await import("./rpc-notifications-td0amw6w.js");
-      pushNotification("toast", {
-        title,
-        message,
-        variant: toastVariant,
-        duration
-      }, sessionId);
-      return "sent";
-    } catch {
-      sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
-    }
-  }
-  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-ng8ygena.js");
-  if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
-    sessionLog(sessionId, "notification skipped (session not titled yet)");
-    return "skipped";
-  }
-  if (!hasNotificationSessionClient(client)) {
-    sessionLog(sessionId, "session prompt API unavailable for notification");
-    return "failed";
-  }
-  const c = client;
-  let agent = params.agent || undefined;
-  let variant = params.variant || undefined;
-  let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
-  if (!agent || !model || !variant) {
-    try {
-      const { resolvePromptContext } = await import("./prompt-context-602yq94t.js");
-      const resolved = await resolvePromptContext(client, sessionId);
-      if (resolved) {
-        agent = agent ?? resolved.agent;
-        model = model ?? resolved.model;
-        variant = variant ?? resolved.variant;
-      }
-    } catch {}
-  }
-  const input = {
-    path: { id: sessionId },
-    body: {
-      noReply: true,
-      agent,
-      model,
-      variant,
-      parts: [
-        {
-          type: "text",
-          text,
-          ignored: true
-        }
-      ]
-    }
-  };
-  try {
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(input));
-      return "sent";
-    }
-    if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(input);
-      return "sent";
-    }
-    sessionLog(sessionId, "session prompt API unavailable for notification");
-    return "failed";
-  } catch (error) {
-    const msg = getErrorMessage(error);
-    sessionLog(sessionId, "failed to send notification:", msg);
-    return "failed";
-  }
-}
-
 // ../plugin/src/hooks/magic-context/compartment-runner-incremental.ts
 var HISTORIAN_ALERT_COOLDOWN_MS2 = 60 * 1000;
 var lastHistorianAlertBySession2 = new Map;
@@ -25106,6 +25781,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
       emitProgress(`Running historian (pass ${passCount + 1})…`);
       const validatedPass = await runValidatedHistorianPass({
         client,
+        db,
         parentSessionId: sessionId,
         sessionDirectory,
         prompt,
@@ -25525,6 +26201,7 @@ ${chunk.text}`,
 Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${chunk.startIndex}-${chunk.endIndex}.`, notifParams());
       const validatedPass = await runValidatedHistorianPass({
         client,
+        db,
         parentSessionId: sessionId,
         sessionDirectory,
         prompt,
@@ -25880,8 +26557,8 @@ function renderStatusText(ctx, db, sessionId) {
   const inputTokens = typeof usage?.tokens === "number" ? usage.tokens : undefined;
   const pct = typeof usage?.percent === "number" ? usage.percent : undefined;
   const meta = readSessionMetaStatus(db, sessionId);
-  const state = renderHistorianState(meta, recompSessions.has(sessionId));
-  return `mc: ${inputTokens === undefined ? "--" : fmt(inputTokens)} (${pct === undefined ? "--" : `${Math.round(pct)}%`}) · ${state}`;
+  const state2 = renderHistorianState(meta, recompSessions.has(sessionId));
+  return `mc: ${inputTokens === undefined ? "--" : fmt(inputTokens)} (${pct === undefined ? "--" : `${Math.round(pct)}%`}) · ${state2}`;
 }
 function renderHistorianState(meta, recompActive) {
   const failureCount = meta?.historian_failure_count ?? 0;
@@ -25984,6 +26661,14 @@ No active Pi session is available.`,
         return;
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      if (currentDeps.compactionOff) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-recomp",
+          text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
+          level: "warning"
+        });
+        return;
+      }
       const parsed = parseRecompArgs(args);
       if (parsed.kind === "error") {
         sendCtxStatusMessage(pi, {
@@ -26336,7 +27021,7 @@ function contextualizeUpgradeReason(reason) {
 // src/pi-memory-migration.ts
 var MIGRATION_SYSTEM_PROMPT2 = "You re-organize a software project's long-term memory into a stricter taxonomy. " + "Follow the user instructions exactly. Output ONLY the requested XML blocks, nothing else.";
 async function runPiMemoryMigration(deps) {
-  const projectPath = resolveProjectIdentityForSession(deps.directory);
+  const projectPath = resolveProjectIdentityForSession(deps.directory, deps.allowHomeProject);
   if (!projectPath) {
     return {
       ran: false,
@@ -26451,6 +27136,14 @@ No active Pi session is available.`,
         return;
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      if (currentDeps.compactionOff) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-session-upgrade",
+          text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
+          level: "warning"
+        });
+        return;
+      }
       if (!currentDeps.historianModel) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-session-upgrade",
@@ -26497,6 +27190,7 @@ An upgrade or recomp is already running for this session in the background. Wait
             timeoutMs: currentDeps.historianTimeoutMs,
             thinkingLevel: currentDeps.historianThinkingLevel,
             directory: ctx.cwd,
+            allowHomeProject: currentDeps.allowHomeProject,
             sessionId,
             userMemoriesEnabled: currentDeps.userMemoriesEnabled,
             language: currentDeps.language
@@ -26507,7 +27201,7 @@ An upgrade or recomp is already running for this session in the background. Wait
         }
       };
       if (upgradableCount === 0) {
-        const projectPath = resolveProjectIdentityForSession(ctx.cwd);
+        const projectPath = resolveProjectIdentityForSession(ctx.cwd, currentDeps.allowHomeProject);
         if (!projectPath)
           return;
         const migrationPending = migrationEnabled && !isMemoryMigrationDone(currentDeps.db, projectPath);
@@ -26683,7 +27377,7 @@ function formatExecuteThreshold(detail, contextLimit) {
   }
   return `${percentage}%${clampNote}`;
 }
-function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit) {
+function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer) {
   const thresholdDetail = resolveExecuteThresholdDetail(executeThresholdPercentageConfig, liveModelKey, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, {
     tokensConfig: executeThresholdTokens,
     contextLimit,
@@ -26728,8 +27422,8 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       "### Cache TTL",
       `- Configured: ${meta.cacheTtl}`,
       `- Last response: ${meta.lastResponseTime > 0 ? `${Math.round(elapsed / 1000)}s ago` : "never"}`,
-      `- Remaining: ${cacheExpired ? "expired" : `${Math.round(remainingMs / 1000)}s`}`,
-      `- Queue will auto-execute: ${cacheExpired ? "yes (cache expired)" : `when TTL expires or context >= ${executeThresholdPercentage}%`}`,
+      `- Remaining: ${cacheExpired ? "expired" : ttlMs === Number.POSITIVE_INFINITY ? "never expires (always-warm lane)" : `${Math.round(remainingMs / 1000)}s`}`,
+      `- Queue will auto-execute: ${cacheExpired ? "yes (cache expired)" : ttlMs === Number.POSITIVE_INFINITY ? `when context >= ${executeThresholdPercentage}%` : `when TTL expires or context >= ${executeThresholdPercentage}%`}`,
       "",
       "### Execute Threshold",
       `- Execute threshold: ${formatExecuteThreshold(thresholdDetail, displayContextLimit)}`,
@@ -26738,6 +27432,11 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       `**Protected tags:** ${protectedTags}`,
       `**Subagent session:** ${meta.isSubagent}`
     ];
+    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
+      lines.push("", "### Dreamer", ...dreamer.progress ? [
+        `- Running: ${dreamer.progress.task} — ${dreamer.progress.processed}/${dreamer.progress.total} processed`
+      ] : [], ...formatDreamTaskBacklogs(dreamer.backlog).split("\\n"));
+    }
     if (meta.lastContextPercentage > 0 || meta.lastInputTokens > 0) {
       lines.push("", "### Context Usage", `- Last percentage: ${meta.lastContextPercentage.toFixed(1)}%`, `- Last input tokens: ${meta.lastInputTokens.toLocaleString()}`, `- Resolved context limit: ${displayContextLimit > 0 ? displayContextLimit.toLocaleString() : "unknown"}`, `- Proactive compartment evaluation: ${proactiveCompartmentTrigger}%`, `- Post-drop target for historian: ${(executeThresholdPercentage * POST_DROP_TARGET_RATIO).toFixed(0)}% (${executeThresholdPercentage}% * ${POST_DROP_TARGET_RATIO})`, `- Commit cluster trigger: ${commitClusterTrigger?.enabled !== false ? `enabled (min ${commitClusterTrigger?.min_clusters ?? 3} clusters)` : "disabled"}, tail-size trigger: > 3x compartment budget`);
     }
@@ -26760,6 +27459,12 @@ ${c.content}
         lines.push(`- §${op.tagId}§ → ${op.operation}`);
       }
     }
+    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
+      lines.push("", "### Dreamer Backlog", formatDreamTaskBacklogs(dreamer.backlog));
+    }
+    if (dreamer?.progress) {
+      lines.push("", "### Dreamer Progress", `- ${dreamer.progress.task}: ${dreamer.progress.processed}/${dreamer.progress.total} processed this run`);
+    }
     return lines.join(`
 `);
   } catch (error) {
@@ -26834,7 +27539,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.33.1",
+  version: "0.34.1",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -27004,7 +27709,7 @@ function renderInner(s, theme, innerWidth) {
     lines.push(`Upgrade: ${theme.fg("accent", "up to date")}`);
   }
   lines.push(`Pending drops: ${s.pendingOpsCount}`);
-  lines.push(`Cache TTL: ${s.cacheTtl} · last response ${s.lastResponseTime > 0 ? `${Math.round((Date.now() - s.lastResponseTime) / 1000)}s ago` : "never"} · ${s.cacheExpired ? theme.fg("warning", "expired") : `${Math.round(s.cacheRemainingMs / 1000)}s remaining`}`);
+  lines.push(`Cache TTL: ${s.cacheTtl} · last response ${s.lastResponseTime > 0 ? `${Math.round((Date.now() - s.lastResponseTime) / 1000)}s ago` : "never"} · ${s.cacheExpired ? theme.fg("warning", "expired") : s.cacheRemainingMs === Number.POSITIVE_INFINITY ? "never expires (always-warm lane)" : `${Math.round(s.cacheRemainingMs / 1000)}s remaining`}`);
   lines.push("");
   lines.push(theme.fg("muted", "Tags"));
   lines.push(`Active ${s.activeTags} (~${formatBytes(s.activeBytes)}) · Dropped ${s.droppedTags} · Total ${s.totalTags}`);
@@ -27046,8 +27751,18 @@ function buildPiStatusDetail(pi, ctx, deps, sessionId) {
   const usage = ctx.getContextUsage?.();
   const meta = getOrCreateSessionMeta(deps.db, sessionId);
   const inputTokens = typeof usage?.tokens === "number" ? usage.tokens : meta.lastInputTokens;
-  const usagePercentage = typeof usage?.percent === "number" ? usage.percent : meta.lastContextPercentage;
-  const contextLimit = typeof usage?.contextWindow === "number" && usage.contextWindow > 0 ? usage.contextWindow : usagePercentage > 0 ? Math.round(inputTokens / (usagePercentage / 100)) : 0;
+  let detectedContextLimit;
+  try {
+    const detected = getOverflowState(deps.db, sessionId).detectedContextLimit;
+    if (detected > 0)
+      detectedContextLimit = detected;
+  } catch {}
+  const contextLimit = resolvePiUsableContextLimit({
+    rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
+    model: ctx.model,
+    detectedContextLimit
+  }) ?? (meta.lastContextPercentage > 0 ? Math.round(inputTokens / (meta.lastContextPercentage / 100)) : 0);
+  const usagePercentage = contextLimit > 0 && inputTokens > 0 ? inputTokens / contextLimit * 100 : meta.lastContextPercentage;
   const compartments = getCompartments(deps.db, sessionId);
   const metaRow = readSessionMetaRow(deps.db, sessionId);
   const memoryBlockCount = Number(metaRow?.memory_block_count ?? 0);
@@ -27095,9 +27810,15 @@ ${safeStringify(tool.parameters)}`);
     sessionId
   });
   const cacheTtl = meta.cacheTtl || "5m";
-  const cacheTtlMs = parseTtlString(cacheTtl);
+  let cacheTtlMs;
+  try {
+    cacheTtlMs = parseCacheTtl(cacheTtl);
+  } catch {
+    cacheTtlMs = 5 * 60 * 1000;
+  }
+  const neverExpires = cacheTtlMs === Number.POSITIVE_INFINITY;
   const elapsed = meta.lastResponseTime > 0 ? Date.now() - meta.lastResponseTime : 0;
-  const cacheRemainingMs = meta.lastResponseTime > 0 ? Math.max(0, cacheTtlMs - elapsed) : cacheTtlMs;
+  const cacheRemainingMs = neverExpires ? Number.POSITIVE_INFINITY : meta.lastResponseTime > 0 ? Math.max(0, cacheTtlMs - elapsed) : cacheTtlMs;
   const cacheExpired = meta.lastResponseTime > 0 && cacheRemainingMs === 0;
   const historyBlockTokens = compartmentTokens + factTokens;
   const historyBudgetPercentage = deps.historyBudgetPercentage ?? 0.15;
@@ -27252,22 +27973,6 @@ function readPendingOpsCount(db, sessionId) {
     return 0;
   }
 }
-function parseTtlString(ttl) {
-  const match = ttl.match(/^(\d+)(s|m|h)$/);
-  if (!match)
-    return 5 * 60 * 1000;
-  const val = Number.parseInt(match[1] ?? "5", 10);
-  switch (match[2]) {
-    case "s":
-      return val * 1000;
-    case "m":
-      return val * 60 * 1000;
-    case "h":
-      return val * 3600 * 1000;
-    default:
-      return 5 * 60 * 1000;
-  }
-}
 function safeRead(fn, fallback) {
   try {
     return fn();
@@ -27331,7 +28036,20 @@ No active Pi session is available.`,
         }
         const usage = ctx.getContextUsage?.();
         const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
-        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usage?.contextWindow);
+        let detectedContextLimit;
+        try {
+          const detected = getOverflowState(currentDeps.db, sessionId).detectedContextLimit;
+          if (detected > 0)
+            detectedContextLimit = detected;
+        } catch {}
+        const usableContextLimit = resolvePiUsableContextLimit({
+          rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
+          model: ctx.model,
+          detectedContextLimit
+        });
+        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit, {
+          backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
+        });
         const details = buildStatusDetails(currentDeps, sessionId);
         sendCtxStatusMessage(pi, { title: "/ctx-status", text: statusText, level: "info" }, details);
       } catch (error) {
@@ -27373,6 +28091,7 @@ function buildStatusDetails(deps, sessionId) {
     dreamer: {
       enabled: deps.dreamer?.runnable === true,
       scheduleSummary: deps.dreamer?.scheduleSummary ?? null,
+      backlog: getDreamTaskBacklogs(deps.db, deps.projectIdentity, CANONICAL_DREAM_TASKS),
       lastRunAt: getMostRecentTaskRunAt(deps.db, deps.projectIdentity)
     },
     historian: readHistorianState(deps.db, sessionId, meta)
@@ -27433,6 +28152,14 @@ No active Pi session is available.`,
         return;
       }
       const currentDeps = deps.resolveRuntimeDeps?.(ctx) ?? deps;
+      if (currentDeps.compactionOff) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: COMPACTION_OFF_COMMAND_UNAVAILABLE,
+          level: "warning"
+        });
+        return;
+      }
       const sessionMeta = getOrCreateSessionMeta(currentDeps.db, sessionId);
       if (sessionMeta.isSubagent) {
         sendCtxStatusMessage(pi, {
@@ -27485,7 +28212,7 @@ async function runPiWrapup(pi, deps, ctx, sessionId, messagesToKeep) {
   const unregister = setRawMessageProvider(sessionId, provider);
   let holderId = "";
   try {
-    const contextLimit = resolvePiContextLimit(ctx);
+    const contextLimit = resolvePiContextLimit(ctx, deps.db, sessionId);
     const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
     const executeThresholdPercentage = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, modelKey, 65, {
       tokensConfig: deps.executeThresholdTokens,
@@ -27714,15 +28441,19 @@ Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments.
     unregister();
   }
 }
-function resolvePiContextLimit(ctx) {
+function resolvePiContextLimit(ctx, db, sessionId) {
   const usage = ctx.getContextUsage?.();
-  if (typeof usage?.contextWindow === "number" && usage.contextWindow > 0) {
-    return usage.contextWindow;
-  }
-  if (typeof ctx.model?.contextWindow === "number" && ctx.model.contextWindow > 0) {
-    return ctx.model.contextWindow;
-  }
-  return 128000;
+  let detectedContextLimit;
+  try {
+    const detected = getOverflowState(db, sessionId).detectedContextLimit;
+    if (detected > 0)
+      detectedContextLimit = detected;
+  } catch {}
+  return resolvePiUsableContextLimit({
+    rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
+    model: ctx.model,
+    detectedContextLimit
+  }) ?? 128000;
 }
 async function acquireCompartmentLeaseEventually(db, sessionId, renewWrapupMarker, maxWaitMs) {
   const waitStartedAt = Date.now();
@@ -27742,15 +28473,15 @@ async function acquireCompartmentLeaseEventually(db, sessionId, renewWrapupMarke
 function estimateChunks(tokens, chunkTokens) {
   return Math.max(1, Math.ceil(Math.max(0, tokens) / Math.max(1, chunkTokens)));
 }
-function formatExistingWrapup(state) {
-  if (!state) {
+function formatExistingWrapup(state2) {
+  if (!state2) {
     return `## Magic Wrapup — Skipped
 
 Another /ctx-wrapup is already compacting this session. Wait for it to finish, then try again.`;
   }
   return `## Magic Wrapup — Skipped
 
-Another /ctx-wrapup is already compacting this session (chunk ${state.chunkIndex}/${Math.max(state.chunkIndex, state.expectedChunks)}, wrapped through message ${state.lastCompartmentEnd}). Wait for it to finish, then try again.`;
+Another /ctx-wrapup is already compacting this session (chunk ${state2.chunkIndex}/${Math.max(state2.chunkIndex, state2.expectedChunks)}, wrapped through message ${state2.lastCompartmentEnd}). Wait for it to finish, then try again.`;
 }
 function readBranchEntries(ctx) {
   const getBranch = ctx.sessionManager.getBranch;
@@ -27874,15 +28605,43 @@ function stripTagPrefixFromAssistantMessage(message) {
 
 // src/index.ts
 var PREFIX2 = "[magic-context][pi]";
-function resolveCurrentProject(ctx) {
+var PI_ACTIVE_LATCH = Symbol.for("magic-context.pi.active");
+function isPiMagicContextActiveInProcess() {
+  return globalThis[PI_ACTIVE_LATCH] === true;
+}
+function markPiMagicContextActive() {
+  globalThis[PI_ACTIVE_LATCH] = true;
+}
+function clearPiMagicContextActive() {
+  try {
+    delete globalThis[PI_ACTIVE_LATCH];
+  } catch {
+    globalThis[PI_ACTIVE_LATCH] = undefined;
+  }
+}
+function resolveCurrentProject(ctx, allowHomeProject = false) {
   const projectDir = ctx.cwd;
-  const projectIdentity = resolveProjectIdentityForSession(projectDir) ?? "";
+  const projectIdentity = resolveProjectIdentityForSession(projectDir, allowHomeProject) ?? "";
   return { projectDir, projectIdentity };
 }
 function signalPiDeferredCompactionMarkerDrain(sessionId) {
   signalPiDeferredHistoryRefresh(sessionId);
   signalPiDeferredMaterialization(sessionId);
 }
+async function handlePiSessionBeforeCompact(args) {
+  try {
+    const sessionId = args.ctx.sessionManager?.getSessionId?.();
+    if (typeof sessionId === "string" && sessionId.length > 0) {
+      clearPiM0Cache(args.db, sessionId, "session_before_compact");
+    }
+  } catch {}
+  if (args.compactionOff) {
+    info("session_before_compact: native Pi compaction proceeds (compaction-off mode)");
+    return;
+  }
+  info("session_before_compact: cancelling — magic-context owns compaction");
+  return { cancel: true };
+}
 function persistPiMessageEndModelMeta(args) {
   if (!args.message || typeof args.message !== "object")
     return;
@@ -27988,7 +28747,10 @@ var __test = {
   logPiConfigLoad,
   resetLoggedPiConfigDirs() {
     loggedPiConfigDirs.clear();
-  }
+  },
+  isPiMagicContextActiveInProcess,
+  markPiMagicContextActive,
+  clearPiMagicContextActive
 };
 function formatTokens(value) {
   return value.toLocaleString();
@@ -28004,23 +28766,28 @@ function getPiMessageModel(message) {
   };
 }
 function resolvePiPressureContextLimit(args) {
-  let effectiveContextLimit = isSaneLimit(args.piContextWindow) ? args.piContextWindow : 0;
+  let detectedContextLimit;
   try {
     const overflowState = getOverflowState(args.db, args.sessionId);
     if (overflowState.detectedContextLimit > 0) {
-      effectiveContextLimit = effectiveContextLimit > 0 ? Math.min(effectiveContextLimit, overflowState.detectedContextLimit) : overflowState.detectedContextLimit;
+      detectedContextLimit = overflowState.detectedContextLimit;
     }
   } catch (err) {
     warn("message_end: getOverflowState failed:", err);
   }
-  return effectiveContextLimit;
+  return resolvePiUsableContextLimit({
+    rawContextWindow: args.piContextWindow,
+    model: args.model,
+    detectedContextLimit
+  }) ?? 0;
 }
 async function persistPiPressureFromMessageEnd(args) {
   const { provider, model } = getPiMessageModel(args.message);
   const effectiveContextLimit = resolvePiPressureContextLimit({
     db: args.db,
     sessionId: args.sessionId,
-    piContextWindow: args.piContextWindow
+    piContextWindow: args.piContextWindow,
+    model: args.piModel ?? { provider, id: model }
   });
   const usage = extractAssistantUsage(args.message);
   const pressure = computePiPressure(usage, effectiveContextLimit);
@@ -28047,8 +28814,8 @@ async function persistPiPressureFromMessageEnd(args) {
     }
   } else if (typeof args.piTokens === "number") {
     updates.lastInputTokens = args.piTokens;
-    if (args.piContextWindow > 0) {
-      updates.lastContextPercentage = args.piTokens / args.piContextWindow * 100;
+    if (effectiveContextLimit > 0) {
+      updates.lastContextPercentage = args.piTokens / effectiveContextLimit * 100;
     }
   }
   updateSessionMeta(args.db, args.sessionId, updates);
@@ -28075,7 +28842,8 @@ function resolveSidekickFromConfig(config) {
     timeoutMs: sidekick.timeout_ms,
     thinking_level: sidekick.thinking_level,
     fallbackModels: resolveFallbackChain(sidekick.fallback_models),
-    language: config.language
+    language: config.language,
+    allowHomeProject: config.allow_home_project
   };
 }
 function resolveHistorianFromConfig(config) {
@@ -28105,7 +28873,8 @@ function resolveHistorianFromConfig(config) {
     memoryEnabled: config.memory.enabled,
     autoPromote: config.memory.auto_promote,
     userMemoriesEnabled: userMemoryCollectionEnabled(config.dreamer),
-    language: config.language
+    language: config.language,
+    allowHomeProject: config.allow_home_project
   };
 }
 function resolveAutoSearchFromConfig(config) {
@@ -28125,7 +28894,20 @@ async function src_default(pi) {
     log(`${PREFIX2} subagent child detected (${MAGIC_CONTEXT_PI_SUBAGENT_ENV}=1); skipping full extension registration`);
     return;
   }
+  if (isPiMagicContextActiveInProcess()) {
+    log(`${PREFIX2} in-process re-init detected (Magic Context already active in this process); skipping full extension registration`);
+    return;
+  }
+  markPiMagicContextActive();
   beginBootQuietPeriod();
+  const bootProjectDir = process.cwd();
+  ensureConfigLocationsMigrated(bootProjectDir);
+  const bootConfig = loadPiConfig({ cwd: bootProjectDir });
+  setStoragePrivatePermissionEnforcement(bootConfig.config.storage.enforce_private_permissions);
+  setSqlitePragmaConfig({
+    cacheSizeMb: bootConfig.config.sqlite.cache_size_mb,
+    mmapSizeMb: bootConfig.config.sqlite.mmap_size_mb
+  });
   const storageDir = getMagicContextStorageDir();
   const dbPath = join5(storageDir, "context.db");
   let db;
@@ -28144,16 +28926,26 @@ async function src_default(pi) {
       info("plugin DISABLED via config (enabled: false) — skipping registration");
       return;
     }
+    const migration = getMigrationOnOpenRefusal();
+    const blockingProcesses = migration?.serverPids.map((pid) => ({
+      harness: "OpenCode server",
+      pid
+    })) ?? [];
     const fence = getSchemaFenceRejection();
-    const reason = fence ? {
+    const reason = migration && blockingProcesses.length > 0 ? {
+      kind: "migration_guard",
+      persistedVersion: migration.persistedVersion,
+      supportedVersion: migration.supportedVersion,
+      blockingProcesses
+    } : fence ? {
       kind: "schema_fence",
       persistedVersion: fence.persistedVersion,
       supportedVersion: fence.supportedVersion
     } : {
       kind: "storage_failure",
-      cause: openFailureCause ?? `storage unavailable at ${dbPath} (cache schema newer than this binary, or open failed)`
+      cause: migration?.unreadableFile ? `migration guard could not read RPC discovery file ${migration.unreadableFile}` : openFailureCause ?? `storage unavailable at ${dbPath} (cache schema newer than this binary, or open failed)`
     };
-    if (early.config.fail_closed_blocking === false) {
+    if (early.config.fail_closed_blocking === false || !isCompactionEnabled(early.config)) {
       warn(`Magic Context (pi) storage unavailable at ${dbPath}: ${formatFailClosedBlockingMessage(reason)}. ` + "fail_closed_blocking=false — degrading silently (hooks not registered).");
       return;
     }
@@ -28201,26 +28993,30 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     })();
   }, 0);
   const projectDir = process.cwd();
-  const projectIdentity = resolveProjectIdentityForSession(projectDir) ?? "";
   const seenDreamerProjectIdentities = new Set;
-  if (projectIdentity)
-    seenDreamerProjectIdentities.add(projectIdentity);
-  try {
-    const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
-    for (const sid of pendingPiMarkerSessions) {
-      signalPiDeferredCompactionMarkerDrain(sid);
-    }
-    if (pendingPiMarkerSessions.length > 0) {
-      log(`${PREFIX2} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
-    }
-  } catch (err) {
-    warn(`Magic Context (pi) failed to rehydrate deferred Pi compaction markers: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  info(`loaded v${PLUGIN_VERSION} | harness=pi | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
   ensureConfigLocationsMigrated(projectDir);
   const { config, warnings, loadedFromPaths } = loadPiConfig({
     cwd: projectDir
   });
+  const projectIdentity = resolveProjectIdentityForSession(projectDir, config.allow_home_project) ?? "";
+  if (projectIdentity)
+    seenDreamerProjectIdentities.add(projectIdentity);
+  info(`loaded v${PLUGIN_VERSION} | harness=pi | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
+  const compactionOff = !isCompactionEnabled(config);
+  setCtxReduceRegisteredGlobally(!compactionOff);
+  if (!compactionOff) {
+    try {
+      const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
+      for (const sid of pendingPiMarkerSessions) {
+        signalPiDeferredCompactionMarkerDrain(sid);
+      }
+      if (pendingPiMarkerSessions.length > 0) {
+        log(`${PREFIX2} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
+      }
+    } catch (err) {
+      warn(`Magic Context (pi) failed to rehydrate deferred Pi compaction markers: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   configurePiSubagentExtensions(config.pi?.subagent_extensions);
   logPiConfigLoad({
     dir: projectDir,
@@ -28228,6 +29024,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     warnings,
     dedupe: true
   });
+  setStoragePrivatePermissionEnforcement(config.storage.enforce_private_permissions);
   setSqlitePragmaConfig({
     cacheSizeMb: config.sqlite.cache_size_mb,
     mmapSizeMb: config.sqlite.mmap_size_mb
@@ -28257,7 +29054,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       injectDocs: cfg.dreamer?.inject_docs !== false,
       injectionBudgetTokens: cfg.memory.injection_budget_tokens,
       temporalAwareness: cfg.temporal_awareness === true,
-      muralEnabled: cfg.experimental?.mural?.enabled === true
+      muralEnabled: cfg.mural.enabled === true
     },
     scheduler: {
       executeThresholdPercentage: cfg.execute_threshold_percentage,
@@ -28267,6 +29064,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     language: cfg.language,
     autoSearch: auto,
     resolveForProject: resolveContextOptionsForProject,
+    compactionOff,
+    allowHomeProject: cfg.allow_home_project,
     maybeAutoEmbedSession: (sessionId, dir, identity) => {
       maybeAutoEmbedPiSession({
         db: database,
@@ -28288,7 +29087,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       hist.onStatusChange = (ctx) => {
         updateStatusLine(ctx, {
           db: database,
-          projectIdentity: resolveCurrentProject(ctx).projectIdentity ?? ""
+          projectIdentity: resolveCurrentProject(ctx, cfg.allow_home_project).projectIdentity ?? ""
         });
       };
     }
@@ -28318,14 +29117,13 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       dedupe: true
     });
     const switchedConfig = switchedLoad.config;
-    const switchedIdentity = identityOverride ?? resolveProjectIdentityForSession(dir) ?? "";
+    const switchedIdentity = identityOverride ?? resolveProjectIdentityForSession(dir, switchedConfig.allow_home_project) ?? "";
     const built = buildProjectDeps(dir, switchedIdentity, switchedConfig);
     projectDepsByDir.set(dir, built);
     return built;
   }
   function resolveCurrentProjectDeps(ctx) {
-    const currentProject = resolveCurrentProject(ctx);
-    return resolveProjectDepsForDir(currentProject.projectDir, currentProject.projectIdentity);
+    return resolveProjectDepsForDir(ctx.cwd);
   }
   function resolveContextOptionsForProject(dir) {
     return resolveProjectDepsForDir(dir).contextOptions;
@@ -28341,11 +29139,13 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     memoryToolEnabled: true,
     protectedTags: config.protected_tags ?? 20,
     resolveProtectedTags: (ctx) => resolveCurrentProjectDeps(ctx).config.protected_tags ?? 20,
+    resolveProjectIdentity: (ctx) => resolveCurrentProjectDeps(ctx).projectIdentity,
     dreamerEnabled: isDreamerRunnable(config),
     resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
-    todowriteEnabled
+    todowriteEnabled,
+    compactionOff
   });
-  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)");
+  info(compactionOff ? todowriteEnabled ? "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, todowrite; registered /todos (ctx_reduce unavailable in compaction-off mode)" : "registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand (ctx_reduce unavailable in compaction-off mode; todowrite disabled)" : 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)");
   pi.on("session_start", async (event, ctx) => {
     await handlePiCloneSessionStart(event, ctx, {
       db,
@@ -28389,7 +29189,6 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       return {
         db,
         projectIdentity: current.projectIdentity,
-        resolveProject: resolveCurrentProject,
         protectedTags: current.config.protected_tags,
         executeThresholdPercentage: current.config.execute_threshold_percentage,
         historyBudgetPercentage: current.config.history_budget_percentage,
@@ -28406,7 +29205,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   info("registered /ctx-status");
   registerStatusLine(pi, { db, projectIdentity });
   info("registered magic-context status line");
-  registerCtxFlushCommand(pi, { db });
+  registerCtxFlushCommand(pi, { db, compactionOff });
   info("registered /ctx-flush");
   registerCtxRecompCommand(pi, {
     db,
@@ -28419,6 +29218,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     language: bootProjectDeps.config.language,
     memoryEnabled: bootProjectDeps.config.memory.enabled,
     autoPromote: bootProjectDeps.config.memory.auto_promote,
+    compactionOff,
     resolveRuntimeDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       return {
@@ -28431,7 +29231,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         historianThinkingLevel: current.historianConfig?.thinkingLevel,
         language: current.config.language,
         memoryEnabled: current.config.memory.enabled,
-        autoPromote: current.config.memory.auto_promote
+        autoPromote: current.config.memory.auto_promote,
+        compactionOff
       };
     }
   });
@@ -28447,6 +29248,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     language: bootProjectDeps.config.language,
     memoryEnabled: bootProjectDeps.config.memory.enabled,
     autoPromote: bootProjectDeps.config.memory.auto_promote,
+    compactionOff,
     userMemoriesEnabled: userMemoryCollectionEnabled(bootProjectDeps.config.dreamer),
     executeThresholdPercentage: bootProjectDeps.config.execute_threshold_percentage,
     executeThresholdTokens: bootProjectDeps.config.execute_threshold_tokens,
@@ -28463,6 +29265,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         language: current.config.language,
         memoryEnabled: current.config.memory.enabled,
         autoPromote: current.config.memory.auto_promote,
+        compactionOff,
         userMemoriesEnabled: userMemoryCollectionEnabled(current.config.dreamer),
         executeThresholdPercentage: current.config.execute_threshold_percentage,
         executeThresholdTokens: current.config.execute_threshold_tokens
@@ -28480,7 +29283,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     historianThinkingLevel: bootProjectDeps.historianConfig?.thinkingLevel,
     language: bootProjectDeps.config.language,
     memoryEnabled: bootProjectDeps.config.memory.enabled,
+    allowHomeProject: bootProjectDeps.config.allow_home_project,
     autoPromote: bootProjectDeps.config.memory.auto_promote,
+    compactionOff,
     userMemoriesEnabled: userMemoryCollectionEnabled(bootProjectDeps.config.dreamer),
     resolveRuntimeDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
@@ -28494,7 +29299,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         historianThinkingLevel: current.historianConfig?.thinkingLevel,
         language: current.config.language,
         memoryEnabled: current.config.memory.enabled,
+        allowHomeProject: current.config.allow_home_project,
         autoPromote: current.config.memory.auto_promote,
+        compactionOff,
         userMemoriesEnabled: userMemoryCollectionEnabled(current.config.dreamer)
       };
     }
@@ -28504,7 +29311,13 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     db,
     projectDir,
     projectIdentity,
-    resolveProject: resolveCurrentProject,
+    resolveProject: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        projectDir: current.projectDir,
+        projectIdentity: current.projectIdentity
+      };
+    },
     dreamerEnabled: bootProjectDeps.dreamerEnabled,
     resolveDreamerEnabled: (ctx) => resolveCurrentProjectDeps(ctx).dreamerEnabled,
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
@@ -28516,7 +29329,13 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     projectIdentity,
     memoryEnabled: bootProjectDeps.config.memory.enabled,
     resolveMemoryEnabled: (ctx) => resolveCurrentProjectDeps(ctx).config.memory.enabled,
-    resolveProject: resolveCurrentProject
+    resolveProject: (ctx) => {
+      const current = resolveCurrentProjectDeps(ctx);
+      return {
+        projectDir: current.projectDir,
+        projectIdentity: current.projectIdentity
+      };
+    }
   });
   info("registered /ctx-embed");
   const dreamerConfig = bootProjectDeps.dreamerConfig;
@@ -28605,11 +29424,11 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         try {
           const smForDrain = sm;
           const canDrain = typeof smForDrain.appendCompaction === "function" && typeof smForDrain.getBranch === "function";
-          if (canDrain && getPendingPiCompactionMarkerState(db, sessionId)) {
+          if (!compactionOff && canDrain && getPendingPiCompactionMarkerState(db, sessionId)) {
             signalPiDeferredCompactionMarkerDrain(sessionId);
           }
         } catch {}
-        if (ctx.hasUI && effectiveProjectDeps.historianConfig?.model) {
+        if (!compactionOff && ctx.hasUI && effectiveProjectDeps.historianConfig?.model) {
           maybeSendUpgradeReminder({
             client: null,
             db,
@@ -28637,7 +29456,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         memoryEnabled: effectiveConfig.memory.enabled,
         includeGuidance: true,
         protectedTags: effectiveConfig.protected_tags,
-        ctxReduceCallable: true,
+        ctxReduceCallable: !compactionOff,
         dreamerEnabled: effectiveProjectDeps.dreamerEnabled,
         temporalAwarenessEnabled: effectiveConfig.temporal_awareness ?? false,
         cavemanTextCompressionEnabled: effectiveConfig.caveman_text_compression?.enabled === true,
@@ -28682,7 +29501,7 @@ ${block}` : event.systemPrompt;
       const lastAssistant = Array.isArray(msgs) ? [...msgs].reverse().find((m) => m?.role === "assistant") : undefined;
       if (lastAssistant?.stopReason === "stop") {
         const sessionId = ctx.sessionManager?.getSessionId?.();
-        if (sessionId && db)
+        if (sessionId && db && !compactionOff)
           maybeDeliverChannel2Pi(pi, db, sessionId);
       }
     } catch (err) {
@@ -28707,7 +29526,7 @@ ${block}` : event.systemPrompt;
           toolCallId
         });
         if (Array.isArray(todos) && todos.length > 0 && todos.every((t) => t.status === "completed" || t.status === "cancelled")) {
-          if (sessionMeta && !sessionMeta.isSubagent) {
+          if (!compactionOff && sessionMeta && !sessionMeta.isSubagent) {
             onNoteTrigger(db, sessionId, "todos_complete");
           }
         }
@@ -28723,7 +29542,7 @@ ${block}` : event.systemPrompt;
       const sessionId = ctx.sessionManager.getSessionId();
       if (typeof sessionId !== "string" || sessionId.length === 0)
         return;
-      if (event.toolName === "ctx_reduce") {
+      if (!compactionOff && event.toolName === "ctx_reduce") {
         markPiChannel1Reduced(sessionId, db);
       }
     } catch (err) {
@@ -28735,6 +29554,8 @@ ${block}` : event.systemPrompt;
       const sessionId = ctx.sessionManager.getSessionId();
       if (typeof sessionId !== "string" || sessionId.length === 0)
         return;
+      if (compactionOff)
+        return;
       if (db)
         maybeDeliverChannel2Pi(pi, db, sessionId, "steer");
       const block = maybeChannel1ReminderForToolResult({
@@ -28750,20 +29571,11 @@ ${block}` : event.systemPrompt;
       log(`tool_result hook failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   });
-  pi.on("session_before_compact", async (_event, ctx) => {
-    try {
-      const sessionId = ctx.sessionManager?.getSessionId?.();
-      if (typeof sessionId === "string" && sessionId.length > 0) {
-        clearPiM0Cache(db, sessionId, "session_before_compact");
-      }
-    } catch {}
-    info("session_before_compact: cancelling — magic-context owns compaction");
-    return { cancel: true };
-  });
+  pi.on("session_before_compact", async (_event, ctx) => handlePiSessionBeforeCompact({ db, compactionOff, ctx }));
   pi.on("message_end", async (event, ctx) => {
     try {
       const msg = event.message;
-      if (msg !== null && typeof msg === "object") {
+      if (!compactionOff && msg !== null && typeof msg === "object") {
         stripTagPrefixFromAssistantMessage(msg);
       }
     } catch (err) {
@@ -28795,6 +29607,7 @@ ${block}` : event.systemPrompt;
         sessionId,
         message: event.message,
         piContextWindow,
+        piModel: ctx.model,
         piTokens: piUsage && typeof piUsage.tokens === "number" ? piUsage.tokens : undefined,
         notifyIssue: async (message) => {
           const uiNotify = ctx.ui?.notify;
@@ -28824,6 +29637,8 @@ ${block}` : event.systemPrompt;
       warn("message_end: persist session_meta usage failed:", err);
     }
     try {
+      if (compactionOff)
+        return;
       const sm = ctx.sessionManager;
       const sessionId = sm?.getSessionId?.();
       if (typeof sessionId !== "string" || sessionId.length === 0)
@@ -28841,8 +29656,8 @@ ${block}` : event.systemPrompt;
       if (!detection.isOverflow)
         return;
       const modelKey = typeof msg.provider === "string" && typeof msg.model === "string" && msg.provider.length > 0 && msg.model.length > 0 ? `${msg.provider}/${msg.model}` : undefined;
-      recordOverflowDetected(db, sessionId, detection.reportedLimit, modelKey);
-      log(`[magic-context][${sessionId}] overflow detected: reportedLimit=${detection.reportedLimit ?? "?"} pattern=${detection.matchedPattern ?? "?"}`);
+      recordOverflowDetected(db, sessionId, detection.reportedLimit, modelKey, "provider_overflow", detection.reportedLimitProvenance);
+      log(`[magic-context][${sessionId}] overflow detected: reportedLimit=${detection.reportedLimit ?? "?"} provenance=${detection.reportedLimitProvenance ?? "?"} pattern=${detection.matchedPattern ?? "?"}`);
     } catch (err) {
       warn("message_end: overflow detection failed:", err);
     }
@@ -28879,6 +29694,7 @@ ${block}` : event.systemPrompt;
         clearContextHandlerSession(sessionId);
       }
     } catch {}
+    clearPiMagicContextActive();
   });
   pi.on("session_before_switch", (_event, ctx) => {
     try {
@@ -28907,6 +29723,7 @@ export {
   resolveDreamerFromConfig,
   persistPiPressureFromMessageEnd,
   persistPiMessageEndModelMeta,
+  handlePiSessionBeforeCompact,
   src_default as default,
   capturePiTodowriteMessageIfCompatible,
   capturePiTodowriteArgsIfCompatible,