@cortexkit/opencode-magic-context 0.33.1 → 0.34.1

package/dist/index.js

@@ -2,11 +2,13 @@ import {
   CANONICAL_DREAM_TASKS,
   buildDreamTaskRuntimeConfigs,
   compareTaskOrder,
+  formatDreamTaskBacklogs,
   isCanonicalDreamTask,
   leaseKeyFor,
   leaseKindFor,
+  processedDreamTaskItems,
   userMemoryCollectionEnabled
-} from "./index-56yjaeb2.js";
+} from "./index-2y0ybv5x.js";
 import {
   AGE_RECLAIM_MIN_TOKENS,
   AdmissionClass,
@@ -22,7 +24,9 @@ import {
   GIT_SWEEP_LEASE_RENEWAL_MS,
   GLOBAL_USER_PROFILE_PROJECT_PATH,
   HISTORIAN_EDITOR_SYSTEM_PROMPT,
+  LATEST_SUPPORTED_VERSION,
   MARKER_SUMMARY_TEXT,
+  MAX_EXECUTE_THRESHOLD,
   MagicContextConfigSchema,
   ModuleMemoryAuthorityError,
   PRIMER_CANDIDATE_MAX_AGE_MS,
@@ -73,6 +77,7 @@ import {
   clearNoteNudgeTriggerAndCooldown,
   clearNoteNudgeTriggerOnly,
   clearPendingCompactionMarkerStateIf,
+  clearPendingOps,
   clearPersistedReasoningWatermark,
   clearPersistedTodoSyntheticAnchor,
   clearRecompStaging,
@@ -83,6 +88,7 @@ import {
   cosineSimilarity,
   countEmbeddedCommits,
   countPrimerCandidatesForProject,
+  createChildSessionWithFence,
   createPrimer,
   deleteTagsByMessageId,
   deleteUserMemoryCandidates,
@@ -104,6 +110,7 @@ import {
   enqueueShadowEmbeddingItems,
   ensureContextStoreUuid,
   ensureMemoryEmbeddings,
+  escalationBands,
   estimateTrueRawMessageTokens,
   expandWorkspaceIdentitySetWithAliases,
   exports_external,
@@ -122,6 +129,7 @@ import {
   getCandidateToolOwners,
   getChannel2NudgeClaim,
   getChannel2NudgeState,
+  getCompactionModeRecord,
   getCompartmentEvents,
   getCompartments,
   getContextStoreUuid,
@@ -150,6 +158,7 @@ import {
   getMemoryCountsByStatus,
   getMemoryMutationsForRenderByProjects,
   getMemoryVerifications,
+  getMigrationOnOpenRefusal,
   getMirrorCursor,
   getModuleNoteEvaluationBridge,
   getMural,
@@ -166,6 +175,8 @@ import {
   getPersistedCompactionMarkerState,
   getPersistedNoteNudge,
   getPersistedReasoningWatermark,
+  getPersistedSchemaVersion,
+  getPersistedTodoPermissionDenied,
   getPersistedTodoSyntheticAnchor,
   getPrimaryEmbeddingMeasurementCohort,
   getPrimerCandidatesByIds,
@@ -197,6 +208,7 @@ import {
   hasLengthCappedOutput,
   hasMemoryClassifiedAtColumn,
   hasMemoryShareableColumn,
+  hasMuralCueColumns,
   hasRunnableCompartmentWindow,
   injectM0M1,
   injectTemporalMarkers,
@@ -212,6 +224,7 @@ import {
   isDatabasePersisted,
   isEmbeddingEnabled,
   isEmergencyRecoveryArmed,
+  isPidAlive,
   isProviderOverflowReconfirmed,
   lkgContentDigest,
   loadCompartmentChunkEmbeddingsForSearch,
@@ -239,6 +252,7 @@ import {
   openDatabaseAsync,
   parkGitSweepNonIndexable,
   parseCron,
+  parseRpcPortFile,
   peekDeferredExecutePending,
   peekNoteNudgeText,
   peekProjectEmbeddings,
@@ -278,6 +292,7 @@ import {
   releaseWrapupInProgress,
   removeAutoSearchHintDecisionByMessageId,
   removeCompactionMarkerForSession,
+  removeMcOwnedCompactionMarkers,
   removeNoteNudgeAnchorByMessageId,
   removePendingOp,
   removeStrippedPlaceholderId,
@@ -290,6 +305,7 @@ import {
   resetLastNudgeCycleIfTailShrank,
   resetNoteNudgeCooldownOnly,
   resetProtectedTailNoEligibleHead,
+  resolveCompactionModeRecord,
   resolveGitTopLevel,
   resolveOpenCodeProtectedTailBoundary,
   resolveProjectIdentity,
@@ -299,6 +315,8 @@ import {
   resolveWorkspaceIdentitySet,
   resolveWorkspaceShareCategories,
   resolveWrapupProtectedTailBoundary,
+  rpcPortDir,
+  rpcPortFilePath,
   runCompartmentAgent,
   runManagedRecomp,
   runManagedUpgrade,
@@ -310,6 +328,8 @@ import {
   scheduleAfterBootQuiet,
   searchMemoriesFTS,
   searchMemoriesFTSUnion,
+  setChannel2NudgeState,
+  setCompactionModeRecord,
   setDeferredExecutePendingIfAbsent,
   setEmergencyDropSample,
   setKeepSubagents,
@@ -318,7 +338,9 @@ import {
   setMemoryClassification,
   setMuralCue,
   setNoteLastReadAt,
+  setPersistedCompactionMarkerState,
   setPersistedReasoningWatermark,
+  setPersistedTodoPermissionDenied,
   setPersistedTodoSyntheticAnchor,
   setRecompStarting,
   setRecompTerminal,
@@ -350,7 +372,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-c2gahrks.js";
+} from "./index-x8spt5wy.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -358,20 +380,24 @@ import {
   isSaneLimit,
   refreshModelLimitsAfterAuthOnce,
   refreshModelLimitsFromApi,
-  resolveHistorianContextLimit
-} from "./index-63dq2g4d.js";
+  resolveHistorianContextLimit,
+  setOutputReserveConfig,
+  setStoragePrivatePermissionEnforcement,
+  shouldEnforcePrivateStoragePermissions
+} from "./index-ry8rh8cv.js";
 import {
   modelBodyField,
   resolveFallbackChain
 } from "./index-td9depx5.js";
 import {
+  clearIgnoredMessages,
   describeError,
+  flushIgnoredMessages,
   getErrorMessage,
   sendIgnoredMessage,
   sendUserPrompt
-} from "./index-y1c9tcm3.js";
+} from "./index-cn960ffd.js";
 import {
-  Database,
   ToolMutationBatch,
   advanceToolReclaimWatermark,
   buildFileSourceContent,
@@ -380,7 +406,6 @@ import {
   cleanUserText,
   clearIndexedMessages,
   clearSession,
-  closeQuietly,
   createToolDropTarget,
   deleteIndexedMessage,
   estimateTokens,
@@ -388,12 +413,10 @@ import {
   extractTexts,
   extractToolCallObservation,
   extractToolCallSummaries,
-  findLastAssistantModelFromOpenCodeDb,
   getIndexedMessageCorpusSize,
   getLastIndexedOrdinal,
   getMessageIndexReconciliationStartOrdinal,
   getMessageIndexSourceIdentity,
-  getMessageTimesFromOpenCodeDb,
   getOrCreateSessionMeta,
   getRawSessionStoredMessageCount,
   hasMeaningfulUserText,
@@ -403,7 +426,6 @@ import {
   isFilePart,
   isMessageIndexReconciledThrough,
   isMessageIndexSourceCurrent,
-  isMidTurn,
   isRawCompactionSummaryInfo,
   isRecord,
   isTextPart,
@@ -411,7 +433,6 @@ import {
   isToolPartWithOutput,
   markSessionCleanupPending,
   normalizeText,
-  openCodeDbExists,
   partHasCompletedResult,
   prependTag,
   primeInMemoryTailRawMessageCache,
@@ -429,9 +450,17 @@ import {
   sweepOrphanedOpenCodeMessageIndexes,
   textMentionsRecentCommit,
   updateSessionMeta,
-  withRawSessionMessageCache,
+  withRawSessionMessageCache
+} from "./index-b563sga5.js";
+import {
+  Database,
+  closeQuietly,
+  findLastAssistantModelFromOpenCodeDb,
+  getMessageTimesFromOpenCodeDb,
+  isMidTurn,
+  openCodeDbExists,
   withReadOnlySessionDb
-} from "./index-ey1bc14z.js";
+} from "./index-fcyvznch.js";
 import {
   cleanupConflictWarnings,
   detectConfigFile,
@@ -439,7 +468,7 @@ import {
   parseJsonc,
   sendConflictWarning,
   stripJsonComments
-} from "./index-xyaekybw.js";
+} from "./index-dtas91s5.js";
 import {
   ANNOUNCEMENT_FEATURES,
   ANNOUNCEMENT_FOOTER,
@@ -449,6 +478,13 @@ import {
   markAnnouncementSeen,
   shouldShowAnnouncement
 } from "./index-dmr999a2.js";
+import {
+  acknowledgeNotifications,
+  drainNotifications,
+  isTuiConnected,
+  pushNotification,
+  registerNotificationSink
+} from "./index-d62ypazr.js";
 import"./index-73xz0247.js";
 import {
   log,
@@ -463,13 +499,6 @@ import {
 import {
   resolvePromptContext
 } from "./index-szf8w1p5.js";
-import {
-  acknowledgeNotifications,
-  drainNotifications,
-  isTuiConnected,
-  pushNotification,
-  registerNotificationSink
-} from "./index-d62ypazr.js";
 import {
   __commonJS,
   __require,
@@ -8488,6 +8517,7 @@ function buildHiddenAgentConfig(prompt, allowedTools, maxSteps, overrides, agent
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 
 // src/config/agent-disable.ts
+var COMPACTION_ENABLED_PATH = `compaction${"."}enabled`;
 function isDreamerRunnable(config) {
   return !!config.dreamer && config.dreamer.disable !== true;
 }
@@ -8497,6 +8527,9 @@ function isSidekickRunnable(config) {
 function isHistorianRunnable(config) {
   return config.historian?.disable !== true;
 }
+function isCompactionEnabled(config) {
+  return config.compaction?.enabled !== false;
+}
 function clonePlainObject(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return;
@@ -9135,9 +9168,10 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   const exp = experimental;
   const hasUM = "user_memories" in exp;
   const hasPKF = "pin_key_files" in exp;
+  const hasMural = "mural" in exp;
   const TOP_LEVEL_GRADUATED = ["temporal_awareness", "caveman_text_compression"];
   const MEMORY_GRADUATED = ["auto_search", "git_commit_indexing"];
-  const hasGraduated = TOP_LEVEL_GRADUATED.some((k) => (k in exp)) || MEMORY_GRADUATED.some((k) => (k in exp));
+  const hasGraduated = TOP_LEVEL_GRADUATED.some((k) => (k in exp)) || MEMORY_GRADUATED.some((k) => (k in exp)) || hasMural;
   if (!hasUM && !hasPKF && !hasGraduated) {
     return rawConfig;
   }
@@ -9145,6 +9179,15 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   const dreamer = typeof patched.dreamer === "object" && patched.dreamer !== null ? { ...patched.dreamer } : {};
   const memory = typeof patched.memory === "object" && patched.memory !== null ? { ...patched.memory } : {};
   const newExperimental = { ...exp };
+  const coerceToObject = (value) => {
+    if (typeof value === "boolean") {
+      return { enabled: value };
+    }
+    if (typeof value === "object" && value !== null) {
+      return { ...value };
+    }
+    return;
+  };
   const relocate = (key, dest, destLabel) => {
     if (!(key in exp))
       return;
@@ -9165,15 +9208,20 @@ function migrateLegacyExperimental(rawConfig, warnings) {
     relocate(key, patched, "");
   for (const key of MEMORY_GRADUATED)
     relocate(key, memory, "memory.");
-  const coerceToObject = (value) => {
-    if (typeof value === "boolean") {
-      return { enabled: value };
-    }
-    if (typeof value === "object" && value !== null) {
-      return { ...value };
+  if (hasMural) {
+    const oldMural = coerceToObject(exp.mural);
+    const existingMural = patched.mural;
+    if (existingMural === undefined) {
+      patched.mural = oldMural ?? exp.mural;
+      warnings.push('Deprecated "experimental.mural"; use top-level "mural" instead (migrated in memory; run `doctor` to persist).');
+    } else if (oldMural !== undefined && typeof existingMural === "object" && existingMural !== null && !Array.isArray(existingMural)) {
+      patched.mural = {
+        ...oldMural,
+        ...existingMural
+      };
     }
-    return;
-  };
+    delete newExperimental.mural;
+  }
   if (hasUM) {
     const oldUM = coerceToObject(exp.user_memories);
     if (oldUM !== undefined) {
@@ -9326,6 +9374,19 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.fail_closed_blocking;
     warnings.push("Ignoring fail_closed_blocking from project config (security: only user-level config may disable or force the loud inoperability gate).");
   }
+  if ("allow_home_project" in projectRaw) {
+    delete projectRaw.allow_home_project;
+    warnings.push("Ignoring allow_home_project from project config (security: only user-level config may opt the user's home directory into Magic Context).");
+  }
+  const compaction = projectRaw.compaction;
+  if (isPlainObject(compaction) && "enabled" in compaction) {
+    delete compaction.enabled;
+    warnings.push("Ignoring compaction.enabled from project config (security: only user-level config may disable Magic Context's context-window management; a cloned repo cannot change how the user's window is owned).");
+  }
+  if ("output_reserve" in projectRaw) {
+    delete projectRaw.output_reserve;
+    warnings.push("Ignoring output_reserve from project config (security: output-token reservation only honors user-level config).");
+  }
   if ("language" in projectRaw) {
     delete projectRaw.language;
     warnings.push("Ignoring language from project config (security: output language is a user-level setting).");
@@ -9334,6 +9395,11 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.sqlite;
     warnings.push("Ignoring sqlite.* from project config (security: SQLite cache/mmap PRAGMAs apply to the " + "process-global shared database handle; only user-level config may set them).");
   }
+  const storage = projectRaw.storage;
+  if (isPlainObject(storage) && "enforce_private_permissions" in storage) {
+    delete storage.enforce_private_permissions;
+    warnings.push("Ignoring storage.enforce_private_permissions from project config (security: only user-level config may opt into externally managed shared storage permissions).");
+  }
   const pi = projectRaw.pi;
   if (isPlainObject(pi) && "subagent_extensions" in pi) {
     delete pi.subagent_extensions;
@@ -9371,6 +9437,17 @@ function stripUnsafeProjectConfigFields(projectRaw) {
       warnings.push(`Ignoring historian.${removed.join("/")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
     }
   }
+  const mural = projectRaw.mural;
+  if (isPlainObject(mural) && "model" in mural) {
+    delete mural.model;
+    warnings.push("Ignoring mural.model from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).");
+  }
+  const experimental = projectRaw.experimental;
+  const legacyMural = isPlainObject(experimental) ? experimental.mural : undefined;
+  if (isPlainObject(legacyMural) && "model" in legacyMural) {
+    delete legacyMural.model;
+    warnings.push("Ignoring experimental.mural.model from project config (security: the mural cue-compressor model is a user-level setting; use user-level mural.model).");
+  }
   for (const agentKey of HIDDEN_AGENT_KEYS) {
     const block = projectRaw[agentKey];
     if (!isPlainObject(block))
@@ -9551,8 +9628,15 @@ function pruneNestedConfigLeaf(block, relativePath) {
 }
 
 // src/config/transform-mode.ts
+var RUST_COMPACTION_OFF_WARNING = "compaction-off mode does not support rust transform mode; using the TypeScript transform.";
 var RUST_REQUIRES_USER_SUBC_WARNING = "rust mode requires user-level subc configuration; running ts.";
 function resolveTransformMode(args) {
+  if (args.configured === "rust" && !args.compactionEnabled) {
+    return {
+      mode: "ts",
+      warnings: [RUST_COMPACTION_OFF_WARNING]
+    };
+  }
   if (args.configured === "rust" && !args.userTierHasSubc) {
     return {
       mode: "ts",
@@ -9932,6 +10016,7 @@ function loadPluginConfigDetailed(directory) {
   }
   const recoveredTopLevelKeys = [];
   const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
+  setOutputReserveConfig(config.output_reserve);
   if (config.configWarnings?.length) {
     allWarnings.push(...config.configWarnings.map((w) => {
       if (userLoaded && projectLoaded)
@@ -9943,7 +10028,8 @@ function loadPluginConfigDetailed(directory) {
   }
   const resolvedTransformMode = resolveTransformMode({
     configured: config.transform_mode,
-    userTierHasSubc: hasUserTierSubcConfig(userLoaded?.config)
+    userTierHasSubc: hasUserTierSubcConfig(userLoaded?.config),
+    compactionEnabled: isCompactionEnabled(config)
   });
   config.transform_mode = resolvedTransformMode.mode;
   allWarnings.push(...resolvedTransformMode.warnings.map((warning) => `[config] ${warning}`));
@@ -9970,7 +10056,9 @@ function loadPluginConfigDetailed(directory) {
 }
 
 // src/features/builtin-commands/commands.ts
-function getMagicContextBuiltinCommands() {
+var COMPACTION_ENABLED_PATH2 = `compaction${".enabled"}`;
+function getMagicContextBuiltinCommands(compactionEnabled = true) {
+  const unavailableInCompactionOff = (command) => `Unavailable when ${COMPACTION_ENABLED_PATH2} is false: /${command} manages compacted history.`;
   return {
     "ctx-status": {
       template: "ctx-status",
@@ -9978,11 +10066,11 @@ function getMagicContextBuiltinCommands() {
     },
     "ctx-recomp": {
       template: "ctx-recomp",
-      description: "Rebuild compartments and facts from raw history (full or <start>-<end> range)"
+      description: compactionEnabled ? "Rebuild compartments and facts from raw history (full or <start>-<end> range)" : unavailableInCompactionOff("ctx-recomp")
     },
     "ctx-wrapup": {
       template: "ctx-wrapup",
-      description: "Compact older live history while keeping the newest messages raw"
+      description: compactionEnabled ? "Compact older live history while keeping the newest messages raw" : unavailableInCompactionOff("ctx-wrapup")
     },
     "ctx-session-upgrade": {
       template: "ctx-session-upgrade",
@@ -9990,7 +10078,7 @@ function getMagicContextBuiltinCommands() {
     },
     "ctx-flush": {
       template: "ctx-flush",
-      description: "Force-process all pending magic context operations immediately"
+      description: compactionEnabled ? "Force-process all pending magic context operations immediately" : unavailableInCompactionOff("ctx-flush")
     },
     "ctx-aug": {
       template: "ctx-aug",
@@ -10355,14 +10443,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(" ");
   }
@@ -10434,7 +10549,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;
@@ -10752,12 +10867,12 @@ async function runSidekick(deps) {
     }
   };
   try {
-    const createResponse = await deps.client.session.create({
-      body: {
-        ...deps.sessionId ? { parentID: deps.sessionId } : {},
-        title: "magic-context-sidekick"
-      },
-      query: { directory: deps.sessionDirectory ?? deps.projectPath }
+    const createResponse = await createChildSessionWithFence({
+      client: deps.client,
+      db: openDatabase(),
+      parentSessionId: deps.sessionId,
+      title: "magic-context-sidekick",
+      directory: deps.sessionDirectory ?? deps.projectPath
     });
     const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
     agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
@@ -11700,6 +11815,7 @@ function createLiveSessionState() {
     deferredMaterializationSessions: new Set,
     sessionDirectoryBySession: new Map,
     recompProgressBySession: new Map,
+    dreamerProgressByProject: new Map,
     internalChildSessions: new Set
   };
 }
@@ -12849,7 +12965,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() });
@@ -12950,11 +13066,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);
@@ -12985,12 +13105,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
@@ -13169,12 +13289,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;
@@ -13763,6 +13883,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}`);
@@ -13786,12 +13907,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
@@ -14573,7 +14694,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-ygcng9t8.js")
     ]);
     return newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
   })();
@@ -14792,12 +14913,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
@@ -15578,12 +15699,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
@@ -15916,6 +16037,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}`);
@@ -15928,12 +16050,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
@@ -16517,6 +16639,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;
@@ -16545,12 +16668,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
@@ -16786,6 +16909,191 @@ function insertDreamRun(db, run) {
   getInsertDreamRunStatement(db).run(run.projectPath, run.startedAt, run.finishedAt, run.holderId, JSON.stringify(run.tasks), run.tasksSucceeded, run.tasksFailed, run.smartNotesSurfaced, run.smartNotesPending, run.memoryChanges ? JSON.stringify(run.memoryChanges) : null, run.parentSessionId ?? null);
 }
 
+// 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);
+    }
+  }
+}
+
 // src/features/magic-context/dreamer/verify.ts
 import { createHash as createHash5 } from "node:crypto";
 
@@ -16985,6 +17293,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}`);
@@ -16997,12 +17306,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
@@ -17276,6 +17585,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") {
@@ -17304,7 +17627,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,
@@ -17338,8 +17673,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" };
         }
@@ -17358,12 +17693,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 };
         }
@@ -17400,11 +17736,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 };
         }
@@ -17426,10 +17763,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)
           });
@@ -17488,11 +17826,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 };
         }
@@ -17528,7 +17867,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}`);
@@ -17582,6 +17922,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);
     }
   };
 }
@@ -17689,12 +18031,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;
@@ -17879,12 +18221,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
@@ -17957,66 +18299,6 @@ async function runAgenticTask(config, ctx, helpers) {
   }
 }
 
-// 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);
-    }
-  }
-}
-
 // src/features/magic-context/dreamer/task-scheduler.ts
 var MAX_TASK_RETRIES = 3;
 function ensureSeeded(db, projectIdentity, config, now) {
@@ -18164,10 +18446,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 {
@@ -18176,7 +18458,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) {
@@ -18190,6 +18480,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 }));
@@ -18211,8 +18504,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);
@@ -18224,9 +18519,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) {
@@ -18799,10 +19099,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,
@@ -19172,11 +19473,11 @@ async function resolveEmbeddingRouting(args) {
 
 // src/plugin/embedding-bootstrap.ts
 async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
-  const projectIdentity = resolveProjectIdentityForSession(directory);
+  const detailed = loadPluginConfigDetailed(directory);
+  const projectIdentity = resolveProjectIdentityForSession(directory, detailed.config.allow_home_project);
   if (!projectIdentity)
     return;
   invalidateProject(projectIdentity);
-  const detailed = loadPluginConfigDetailed(directory);
   if (isConfigLoadUntrusted(detailed)) {
     handleUntrustedLoad(db, projectIdentity, directory, detailed);
     return;
@@ -19230,41 +19531,45 @@ function createCompactionHandler() {
 
 // src/hooks/magic-context/event-resolvers.ts
 var DEFAULT_CONTEXT_LIMIT = 128000;
-var MAX_EXECUTE_THRESHOLD = 80;
 function resolveContextLimit(providerID, modelID, ctx) {
-  const fromModelsDev = providerID && modelID ? getSdkContextLimit(providerID, modelID) : undefined;
-  const baseline = fromModelsDev ?? DEFAULT_CONTEXT_LIMIT;
   const modelKey = resolveModelKey(providerID, modelID);
+  let detected;
+  let detectedLimitProvenance = "unknown";
   if (ctx?.db && ctx.sessionID) {
     try {
       const overflow = getOverflowState(ctx.db, ctx.sessionID, modelKey);
-      if (overflow.detectedContextLimit > 0 && overflow.detectedContextLimit < baseline) {
-        return overflow.detectedContextLimit;
+      if (overflow.detectedContextLimit > 0) {
+        detected = overflow.detectedContextLimit;
+        detectedLimitProvenance = overflow.detectedContextLimitProvenance;
       }
     } catch {}
   }
-  return baseline;
+  const fromModelsDev = providerID && modelID ? getSdkContextLimit(providerID, modelID, detected, {
+    reservation: ctx?.reservation,
+    detectedLimitProvenance
+  }) : undefined;
+  return fromModelsDev ?? detected ?? DEFAULT_CONTEXT_LIMIT;
 }
 function resolveTrustedContextLimit(providerID, modelID, ctx) {
-  const fromModelsDev = providerID && modelID ? getSdkContextLimit(providerID, modelID) : undefined;
   const modelKey = resolveModelKey(providerID, modelID);
   let detected;
+  let detectedLimitProvenance = "unknown";
   if (ctx?.db && ctx.sessionID) {
     try {
       const overflow = getOverflowState(ctx.db, ctx.sessionID, modelKey);
       if (overflow.detectedContextLimit > 0) {
         detected = overflow.detectedContextLimit;
+        detectedLimitProvenance = overflow.detectedContextLimitProvenance;
       }
     } catch {}
   }
-  if (typeof fromModelsDev === "number" && fromModelsDev > 0) {
-    if (detected !== undefined && detected < fromModelsDev)
-      return detected;
+  const fromModelsDev = providerID && modelID ? getSdkContextLimit(providerID, modelID, detected, {
+    detectedLimitProvenance
+  }) : undefined;
+  if (typeof fromModelsDev === "number" && fromModelsDev > 0)
     return fromModelsDev;
-  }
-  if (detected !== undefined) {
+  if (detected !== undefined)
     return detected;
-  }
   if (modelKey && ctx?.db && ctx.sessionID) {
     try {
       const persisted = loadPersistedUsage(ctx.db, ctx.sessionID);
@@ -19319,7 +19624,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 {
@@ -19375,7 +19680,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 {
@@ -19448,6 +19753,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);
   }
@@ -19846,6 +20154,75 @@ function formatThresholdClampNote(opts) {
   return ` [clamped: ${opts.configuredValue}% > ${opts.maxPercentage}%]`;
 }
 
+// src/hooks/magic-context/sentinel.ts
+var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
+function modelAcceptsEmptyContent(providerID) {
+  return providerID === "anthropic";
+}
+function variantChangeBustsProviderCache(providerID) {
+  if (providerID === undefined)
+    return true;
+  if (providerID === "anthropic")
+    return true;
+  if (providerID === "google-vertex-anthropic")
+    return true;
+  if (providerID.includes("bedrock"))
+    return true;
+  return false;
+}
+function makeSentinel(originalPart) {
+  const sentinel = {
+    type: "text",
+    text: ""
+  };
+  if (isRecord(originalPart)) {
+    if (originalPart.cache_control !== undefined) {
+      sentinel.cache_control = originalPart.cache_control;
+    }
+    if (originalPart.cacheControl !== undefined) {
+      sentinel.cacheControl = originalPart.cacheControl;
+    }
+  }
+  return sentinel;
+}
+function makeWholeMessageSentinel(providerID) {
+  return {
+    type: "text",
+    text: modelAcceptsEmptyContent(providerID) ? "" : WHOLE_MESSAGE_PLACEHOLDER_TEXT
+  };
+}
+function isSentinel(part) {
+  if (!isRecord(part))
+    return false;
+  if (part.type !== "text")
+    return false;
+  if (typeof part.text !== "string")
+    return false;
+  return part.text === "" || part.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT;
+}
+function replaySentinelByMessageIds(messages, ids, providerID) {
+  if (ids.size === 0)
+    return { replayed: 0, missingIds: [] };
+  const seen = new Set;
+  let replayed = 0;
+  for (const msg of messages) {
+    const id = msg.info.id;
+    if (!id || !ids.has(id))
+      continue;
+    seen.add(id);
+    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
+      continue;
+    msg.parts.length = 0;
+    msg.parts.push(makeWholeMessageSentinel(providerID));
+    replayed++;
+  }
+  const missingIds = [];
+  for (const id of ids)
+    if (!seen.has(id))
+      missingIds.push(id);
+  return { replayed, missingIds };
+}
+
 // src/hooks/magic-context/compartment-trigger.ts
 var PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
 var POST_DROP_TARGET_RATIO = 0.75;
@@ -19853,9 +20230,7 @@ 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 FORCE_MATERIALIZE_PERCENTAGE = 85;
 var CONTENT_TAG_OWNER_SUFFIX = /:(?:p|file)\d+$/;
 function tagOwnerMessageId(row) {
   if (row.type === "tool")
@@ -19909,7 +20284,7 @@ function buildTriggerInMemoryTail(db, sessionId, messages) {
 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;
@@ -19920,7 +20295,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")
@@ -20020,7 +20395,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 };
@@ -20074,18 +20449,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
       };
     }
@@ -20110,9 +20487,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;
@@ -20182,7 +20559,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,
@@ -20227,8 +20604,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)}`,
@@ -20237,6 +20614,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`);
     }
@@ -20259,6 +20641,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) {
@@ -20494,16 +20882,32 @@ ${sidekickResult}
   await sendUserPrompt(deps.sidekick.client, sessionId, augmentedPrompt);
   throwSentinel("CTX-AUG");
 }
+function readDreamTaskBacklogsSafely(db, projectPath, tasks) {
+  try {
+    return getDreamTaskBacklogs(db, projectPath, tasks);
+  } catch {
+    return {};
+  }
+}
 function summarizeManualDream(s) {
   const lines = ["## /ctx-dream", ""];
   if (s.ran.length > 0)
     lines.push(`Ran: ${s.ran.join(", ")}`);
   if (s.failed.length > 0)
     lines.push(`Failed: ${s.failed.join(", ")}`);
+  if ((s.failureDetails?.length ?? 0) > 0) {
+    lines.push("Failure details:", ...(s.failureDetails ?? []).map((detail) => `- ${detail}`));
+  }
   if (s.skippedNoWork.length > 0)
     lines.push(`Skipped (no work): ${s.skippedNoWork.join(", ")}`);
   if (s.deferredBusy.length > 0)
     lines.push(`Busy: ${s.deferredBusy.join(", ")} — another dream task holds this domain's lease; retry in a minute`);
+  if (Object.keys(s.backlogBefore ?? {}).length > 0) {
+    lines.push("", "Backlog at run start:", formatDreamTaskBacklogs(s.backlogBefore ?? {}));
+  }
+  if (Object.keys(s.backlogAfter ?? {}).length > 0) {
+    lines.push("", "Backlog at run end:", formatDreamTaskBacklogs(s.backlogAfter ?? {}));
+  }
   if (s.ran.length === 0 && s.failed.length === 0 && s.skippedNoWork.length === 0 && s.deferredBusy.length === 0) {
     lines.push("No enabled dream tasks to run.");
   }
@@ -20531,7 +20935,17 @@ Unknown task "${requested}". Valid tasks: ${CANONICAL_DREAM_TASKS.join(", ")}.`,
     }
     task = requested;
   }
-  await deps.sendNotification(sessionId, task ? `Running dream task "${task}"...` : "Starting dream run...", dreamNotificationParams);
+  const backlogTasks = task ? [task] : CANONICAL_DREAM_TASKS;
+  const backlogBefore = readDreamTaskBacklogsSafely(deps.db, deps.dreamer.projectPath, backlogTasks);
+  await deps.sendNotification(sessionId, [
+    "## /ctx-dream",
+    "",
+    task ? `Running dream task "${task}"...` : "Starting dream run...",
+    "",
+    "Backlog before starting:",
+    formatDreamTaskBacklogs(backlogBefore, backlogTasks)
+  ].join(`
+`), dreamNotificationParams);
   const summary = await deps.dreamer.runManual(task);
   await deps.sendNotification(sessionId, summarizeManualDream(summary), dreamNotificationParams);
   throwSentinel("CTX-DREAM");
@@ -20579,6 +20993,11 @@ function createMagicContextCommandHandler(deps) {
       }
       const sessionId = input.sessionID;
       let result = "";
+      if (deps.compactionOff && (isFlush || isRecomp || isWrapup)) {
+        const command = `/${input.command}`;
+        await deps.sendNotification(sessionId, `Magic Context compaction is disabled (${COMPACTION_ENABLED_PATH}: false) — ${command} manages compacted history and has no effect in this mode.`, {});
+        throwSentinel(input.command);
+      }
       if (isAug) {
         await executeAugmentation(deps, sessionId, input.arguments);
         return;
@@ -20664,11 +21083,17 @@ Embedding status is unavailable.`;
         }
         const liveModelKey = deps.getLiveModelKey?.(sessionId);
         const liveContextLimit = deps.getContextLimit?.(sessionId);
-        const statusOutput = executeStatus(deps.db, sessionId, deps.protectedTags, deps.executeThresholdPercentage, liveModelKey, deps.historyBudgetPercentage, deps.commitClusterTrigger, deps.executeThresholdTokens, liveContextLimit);
+        const statusOutput = executeStatus(deps.db, sessionId, deps.protectedTags, deps.executeThresholdPercentage, liveModelKey, deps.historyBudgetPercentage, deps.commitClusterTrigger, deps.executeThresholdTokens, liveContextLimit, deps.dreamer ? {
+          backlog: readDreamTaskBacklogsSafely(deps.db, deps.dreamer.projectPath, CANONICAL_DREAM_TASKS),
+          progress: deps.getDreamerProgress?.() ?? null
+        } : undefined);
         const moduleStatus = rustStatus ? `
 
 ${formatRustStatusText(rustStatus)}` : "";
-        const combinedStatus = `${statusOutput}${moduleStatus}`;
+        const modeStatus = deps.compactionOff ? `**Compaction:** disabled (${COMPACTION_ENABLED_PATH}: false) — native compaction owns the context window.
+
+` : "";
+        const combinedStatus = `${modeStatus}${statusOutput}${moduleStatus}`;
         result += result ? `
 
 ${combinedStatus}` : combinedStatus;
@@ -20835,6 +21260,212 @@ ${snap.error}`;
   };
 }
 
+// src/hooks/magic-context/ctx-reduce-availability.ts
+var ctxReduceRegisteredGlobally = true;
+function setCtxReduceRegisteredGlobally(registered) {
+  ctxReduceRegisteredGlobally = registered;
+}
+var CTX_REDUCE_TOOL = "ctx_reduce";
+var TODOWRITE_TOOL = "todowrite";
+var availabilityBySession = new BoundedSessionMap(1000);
+var permissionDeniedBySession = new BoundedSessionMap(2000);
+var ctxReducePermissionDenyLogged = new BoundedSessionMap(1000);
+function permissionCacheKey(toolName, sessionId) {
+  return `${toolName}\x00${sessionId}`;
+}
+function cacheKey(toolName, sessionId) {
+  return `${toolName}\x00${sessionId}`;
+}
+function verdictFromToolsMap(tools, toolName) {
+  if (tools === null || typeof tools !== "object" || Array.isArray(tools))
+    return null;
+  const map = tools;
+  if (map[toolName] === true)
+    return true;
+  if (map[toolName] === false)
+    return false;
+  if (map["*"] === false)
+    return false;
+  return null;
+}
+function resolveToolAvailabilityFromMessages(sessionId, toolName, messages) {
+  if (toolName === CTX_REDUCE_TOOL && !ctxReduceRegisteredGlobally) {
+    return { callable: false, frozen: true };
+  }
+  const key = cacheKey(toolName, sessionId);
+  const cached = availabilityBySession.get(key);
+  if (cached !== undefined)
+    return { callable: cached, frozen: true };
+  for (const message of messages) {
+    if (message.info?.role !== "user")
+      continue;
+    const verdict = verdictFromToolsMap(message.info.tools, toolName) ?? true;
+    availabilityBySession.set(key, verdict);
+    return { callable: verdict, frozen: true };
+  }
+  return { callable: true, frozen: false };
+}
+function resolveToolAvailability(sessionId, toolName) {
+  if (toolName === CTX_REDUCE_TOOL && !ctxReduceRegisteredGlobally) {
+    return { callable: false, frozen: true };
+  }
+  const key = cacheKey(toolName, sessionId);
+  const cached = availabilityBySession.get(key);
+  if (cached !== undefined)
+    return { callable: cached, frozen: true };
+  if (!openCodeDbExists())
+    return { callable: true, frozen: true };
+  try {
+    const row = withReadOnlySessionDb((db) => db.prepare(`SELECT json_extract(data, '$.tools') AS tools FROM message
+                          WHERE session_id = ? AND json_extract(data, '$.role') = 'user'
+                          ORDER BY time_created ASC LIMIT 1`).get(sessionId));
+    if (!row)
+      return { callable: true, frozen: false };
+    const verdict = row.tools === null ? null : verdictFromToolsMap(JSON.parse(row.tools), toolName);
+    const resolved = verdict ?? true;
+    availabilityBySession.set(key, resolved);
+    return { callable: resolved, frozen: true };
+  } catch (error) {
+    sessionLog(sessionId, `${toolName} availability read failed (fail-open):`, error);
+    return { callable: true, frozen: false };
+  }
+}
+function resolveCtxReduceAvailabilityFromMessages(sessionId, messages) {
+  return resolveToolAvailabilityFromMessages(sessionId, CTX_REDUCE_TOOL, messages);
+}
+function resolveCtxReduceAvailability(sessionId) {
+  return resolveToolAvailability(sessionId, CTX_REDUCE_TOOL);
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function responseData(value) {
+  if (isRecord2(value) && Object.hasOwn(value, "data"))
+    return value.data;
+  return value;
+}
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function permissionNameMatches(rulePermission, toolName) {
+  if (rulePermission === "*" || rulePermission === toolName)
+    return true;
+  if (!rulePermission.includes("*"))
+    return false;
+  const pattern = rulePermission.split("*").map(escapeRegExpLiteral).join(".*");
+  return new RegExp(`^${pattern}$`).test(toolName);
+}
+function permissionDisabled(toolName, rules) {
+  let finalRule;
+  for (let index = rules.length - 1;index >= 0; index -= 1) {
+    const rule = rules[index];
+    if (rule && permissionNameMatches(rule.permission, toolName)) {
+      finalRule = rule;
+      break;
+    }
+  }
+  return finalRule?.action === "deny" && finalRule.pattern === "*";
+}
+function actionOf(value) {
+  return value === "ask" || value === "allow" || value === "deny" ? value : null;
+}
+function appendPermissionRule(target, permission, pattern, action) {
+  if (typeof permission !== "string" || permission.length === 0)
+    return;
+  const normalizedAction = actionOf(action);
+  if (!normalizedAction)
+    return;
+  const patterns = Array.isArray(pattern) ? pattern : [pattern ?? "*"];
+  for (const candidate of patterns) {
+    if (typeof candidate === "string") {
+      target.push({ permission, pattern: candidate, action: normalizedAction });
+    }
+  }
+}
+function permissionRules(value) {
+  if (Array.isArray(value)) {
+    const result2 = [];
+    for (const item of value) {
+      if (!isRecord2(item))
+        continue;
+      appendPermissionRule(result2, item.permission ?? item.tool ?? item.name, item.pattern, item.action ?? item.value);
+    }
+    return result2;
+  }
+  if (!isRecord2(value))
+    return [];
+  const result = [];
+  if (Array.isArray(value.rules))
+    result.push(...permissionRules(value.rules));
+  for (const [permission, configured] of Object.entries(value)) {
+    if (permission === "rules")
+      continue;
+    const simpleAction = actionOf(configured);
+    if (simpleAction) {
+      appendPermissionRule(result, permission, "*", simpleAction);
+      continue;
+    }
+    if (!isRecord2(configured))
+      continue;
+    for (const [pattern, action] of Object.entries(configured)) {
+      appendPermissionRule(result, permission, pattern, action);
+    }
+  }
+  return result;
+}
+function activeAgentNameFromSession(value) {
+  if (!isRecord2(value))
+    return;
+  const agent = value.agent;
+  return typeof agent === "string" && agent.length > 0 ? agent : undefined;
+}
+async function resolveToolPermissionDenied(client, sessionId, toolName, activeAgent) {
+  const sdk = client;
+  if (!sdk.app?.agents || !sdk.session?.get) {
+    throw new Error("OpenCode permission APIs are unavailable");
+  }
+  const [agentsResponse, sessionResponse] = await Promise.all([
+    sdk.app.agents(),
+    sdk.session.get({ path: { id: sessionId } })
+  ]);
+  const agents = responseData(agentsResponse);
+  const session = responseData(sessionResponse);
+  const agentName = activeAgent ?? activeAgentNameFromSession(session);
+  const agent = Array.isArray(agents) ? agents.find((candidate) => isRecord2(candidate) && candidate.name === agentName) : undefined;
+  const agentRules = permissionRules(isRecord2(agent) ? agent.permission : undefined);
+  const sessionRules = permissionRules(isRecord2(session) ? session.permission ?? session.permissions : undefined);
+  const denied = permissionDisabled(toolName, [...agentRules, ...sessionRules]);
+  permissionDeniedBySession.set(permissionCacheKey(toolName, sessionId), denied);
+  return denied;
+}
+function todowritePermissionDenied(client, sessionId, activeAgent) {
+  return resolveToolPermissionDenied(client, sessionId, TODOWRITE_TOOL, activeAgent);
+}
+function cachedToolPermissionDenied(sessionId, toolName) {
+  return permissionDeniedBySession.get(permissionCacheKey(toolName, sessionId));
+}
+function clearToolPermissionDenied(sessionId, toolName) {
+  if (toolName) {
+    permissionDeniedBySession.delete(permissionCacheKey(toolName, sessionId));
+  } else {
+    permissionDeniedBySession.delete(permissionCacheKey(TODOWRITE_TOOL, sessionId));
+    permissionDeniedBySession.delete(permissionCacheKey(CTX_REDUCE_TOOL, sessionId));
+  }
+  ctxReducePermissionDenyLogged.delete(sessionId);
+}
+function hasLoggedCtxReducePermissionDeny(sessionId) {
+  return ctxReducePermissionDenyLogged.get(sessionId) === true;
+}
+function markCtxReducePermissionDenyLogged(sessionId) {
+  ctxReducePermissionDenyLogged.set(sessionId, true);
+}
+function resolveTodowriteAvailabilityFromMessages(sessionId, messages) {
+  return resolveToolAvailabilityFromMessages(sessionId, TODOWRITE_TOOL, messages);
+}
+function resolveTodowriteAvailability(sessionId) {
+  return resolveToolAvailability(sessionId, TODOWRITE_TOOL);
+}
+
 // src/hooks/magic-context/embed-session-state.ts
 var embedPauseBySession = new Set;
 var embedRunStateBySession = new Map;
@@ -21615,9 +22246,9 @@ function getMessageRemovedInfo(properties) {
 import * as crypto3 from "node:crypto";
 
 // src/hooks/magic-context/boundary-execution.ts
-var FORCE_MATERIALIZE_PERCENTAGE2 = 85;
 function detectMidTurnBypassReason(input) {
-  if (input.contextUsage.percentage >= FORCE_MATERIALIZE_PERCENTAGE2)
+  const { forceMaterializationPercentage } = escalationBands(input.effectiveExecuteThresholdPercentage);
+  if (input.contextUsage.percentage >= forceMaterializationPercentage)
     return "force-materialize";
   if (input.historyRefreshSessions.has(input.sessionId))
     return "explicit-bust";
@@ -21644,7 +22275,7 @@ function canConsumeDeferredOnThisPass(args) {
     return true;
   if (args.activeRunBlocksMaterialization)
     return false;
-  return args.schedulerDecision === "execute" || args.contextPercentage >= FORCE_MATERIALIZE_PERCENTAGE;
+  return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 
 // src/hooks/magic-context/caveman.ts
@@ -21988,72 +22619,157 @@ function replayCavemanCompression(sessionId, db, targets, tags) {
   return replayed;
 }
 
-// src/hooks/magic-context/ctx-reduce-availability.ts
-var CTX_REDUCE_TOOL = "ctx_reduce";
-var TODOWRITE_TOOL = "todowrite";
-var availabilityBySession = new BoundedSessionMap(1000);
-function cacheKey(toolName, sessionId) {
-  return `${toolName}\x00${sessionId}`;
-}
-function verdictFromToolsMap(tools, toolName) {
-  if (tools === null || typeof tools !== "object" || Array.isArray(tools))
-    return null;
-  const map = tools;
-  if (map[toolName] === true)
-    return true;
-  if (map[toolName] === false)
-    return false;
-  if (map["*"] === false)
-    return false;
-  return null;
-}
-function resolveToolAvailabilityFromMessages(sessionId, toolName, messages) {
-  const key = cacheKey(toolName, sessionId);
-  const cached = availabilityBySession.get(key);
-  if (cached !== undefined)
-    return { callable: cached, frozen: true };
-  for (const message of messages) {
-    if (message.info?.role !== "user")
-      continue;
-    const verdict = verdictFromToolsMap(message.info.tools, toolName) ?? true;
-    availabilityBySession.set(key, verdict);
-    return { callable: verdict, frozen: true };
+// src/hooks/magic-context/compaction-off-transition.ts
+import { existsSync as existsSync11 } from "node:fs";
+var loggedUnverifiedMarkerCleanupRetry = false;
+var COMPACTION_OFF_FLIP_NOTICE = [
+  "## Magic Context — compaction-off mode is now active",
+  "",
+  "Magic Context no longer manages this session's context window; native compaction (or nothing) owns it. Memory, dreamer, notes and ctx_search stay live.",
+  "",
+  "Magic Context's compaction markers for this session were removed, so history previously hidden by them becomes visible again — the first turn after disabling may trigger one native compaction cycle on long sessions."
+].join(`
+`);
+var COMPACTION_ON_WRAPUP_SUGGESTION = [
+  "## Magic Context — compaction re-enabled",
+  "",
+  "Context-window management resumed for this session. History that grew while compaction was off will be picked up by the historian automatically; run `/ctx-wrapup` to digest the backlog now in bounded chunks."
+].join(`
+`);
+var NO_TRANSITION = {
+  recordToWrite: null,
+  notice: null,
+  invalidatedM0Baseline: false,
+  historianCatchUpSignaled: false,
+  clearedCompartmentInProgress: false,
+  clearedSomething: false,
+  markerCleanup: {
+    verified: true,
+    removedLineages: 0,
+    removedRows: 0,
+    retainedLineages: 0
   }
-  return { callable: true, frozen: false };
+};
+function clearCachedM0Baseline(db, sessionId) {
+  const result = db.prepare("UPDATE session_meta SET cached_m0_bytes = NULL, cached_m1_bytes = NULL, cached_m0_mural_data_url = NULL WHERE session_id = ?").run(sessionId);
+  return (result.changes ?? 0) > 0;
 }
-function resolveToolAvailability(sessionId, toolName) {
-  const key = cacheKey(toolName, sessionId);
-  const cached = availabilityBySession.get(key);
-  if (cached !== undefined)
-    return { callable: cached, frozen: true };
-  if (!openCodeDbExists())
-    return { callable: true, frozen: true };
-  try {
-    const row = withReadOnlySessionDb((db) => db.prepare(`SELECT json_extract(data, '$.tools') AS tools FROM message
-                          WHERE session_id = ? AND json_extract(data, '$.role') = 'user'
-                          ORDER BY time_created ASC LIMIT 1`).get(sessionId));
-    if (!row)
-      return { callable: true, frozen: false };
-    const verdict = row.tools === null ? null : verdictFromToolsMap(JSON.parse(row.tools), toolName);
-    const resolved = verdict ?? true;
-    availabilityBySession.set(key, resolved);
-    return { callable: resolved, frozen: true };
-  } catch (error) {
-    sessionLog(sessionId, `${toolName} availability read failed (fail-open):`, error);
-    return { callable: true, frozen: false };
+function cleanupOffMarkers(sessionId) {
+  if (!existsSync11(getOpenCodeDbPath())) {
+    return { verified: true, removedLineages: 0, removedRows: 0, retainedLineages: 0 };
   }
+  return removeMcOwnedCompactionMarkers(sessionId, MARKER_SUMMARY_TEXT);
 }
-function resolveCtxReduceAvailabilityFromMessages(sessionId, messages) {
-  return resolveToolAvailabilityFromMessages(sessionId, CTX_REDUCE_TOOL, messages);
-}
-function resolveCtxReduceAvailability(sessionId) {
-  return resolveToolAvailability(sessionId, CTX_REDUCE_TOOL);
-}
-function resolveTodowriteAvailabilityFromMessages(sessionId, messages) {
-  return resolveToolAvailabilityFromMessages(sessionId, TODOWRITE_TOOL, messages);
+function reconcileCompactionMode(args) {
+  const { db, sessionId } = args;
+  const stored = getCompactionModeRecord(db, sessionId);
+  if (stored === "on_notice_pending") {
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: "on",
+      notice: COMPACTION_ON_WRAPUP_SUGGESTION
+    };
+  }
+  if (stored === "off_notice_pending") {
+    const markerCleanup2 = cleanupOffMarkers(sessionId);
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: markerCleanup2.verified ? "off" : "off_cleanup_pending",
+      notice: COMPACTION_OFF_FLIP_NOTICE,
+      markerCleanup: markerCleanup2
+    };
+  }
+  if (!args.compactionOff) {
+    if (stored === null || resolveCompactionModeRecord(stored) === "on") {
+      return stored === null ? { ...NO_TRANSITION, recordToWrite: "on" } : NO_TRANSITION;
+    }
+    const invalidatedM0Baseline2 = clearCachedM0Baseline(db, sessionId);
+    let historianCatchUpSignaled = false;
+    if (args.historianRunnable) {
+      updateSessionMeta(db, sessionId, { compartmentInProgress: true });
+      historianCatchUpSignaled = true;
+    }
+    if (!historianCatchUpSignaled) {
+      return {
+        ...NO_TRANSITION,
+        recordToWrite: "on",
+        invalidatedM0Baseline: invalidatedM0Baseline2
+      };
+    }
+    setCompactionModeRecord(db, sessionId, "on_notice_pending");
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: "on",
+      notice: COMPACTION_ON_WRAPUP_SUGGESTION,
+      invalidatedM0Baseline: invalidatedM0Baseline2,
+      historianCatchUpSignaled
+    };
+  }
+  if (stored === "off")
+    return NO_TRANSITION;
+  if (stored === "off_cleanup_pending") {
+    const markerCleanup2 = cleanupOffMarkers(sessionId);
+    return {
+      ...NO_TRANSITION,
+      recordToWrite: markerCleanup2.verified ? "off" : null,
+      markerCleanup: markerCleanup2
+    };
+  }
+  let clearedSomething = false;
+  const markerCleanup = cleanupOffMarkers(sessionId);
+  if (markerCleanup.removedRows > 0)
+    clearedSomething = true;
+  if (getPersistedCompactionMarkerState(db, sessionId) !== null) {
+    setPersistedCompactionMarkerState(db, sessionId, null);
+    clearedSomething = true;
+  }
+  const pendingMarker = getPendingCompactionMarkerState(db, sessionId);
+  if (pendingMarker !== null) {
+    clearPendingCompactionMarkerStateIf(db, sessionId, pendingMarker);
+    clearedSomething = true;
+  }
+  if (getOverflowState(db, sessionId).needsEmergencyRecovery) {
+    clearEmergencyRecovery(db, sessionId);
+    clearedSomething = true;
+  }
+  const channel2State = getChannel2NudgeState(db, sessionId);
+  if (channel2State === "pending" || channel2State === "claimed") {
+    setChannel2NudgeState(db, sessionId, "");
+    clearedSomething = true;
+  }
+  if (getPendingOps(db, sessionId).length > 0) {
+    clearPendingOps(db, sessionId);
+    clearedSomething = true;
+  }
+  const invalidatedM0Baseline = clearCachedM0Baseline(db, sessionId);
+  let clearedCompartmentInProgress = false;
+  if (args.compartmentInProgress) {
+    updateSessionMeta(db, sessionId, { compartmentInProgress: false });
+    clearedCompartmentInProgress = true;
+  }
+  sessionLog(sessionId, `compaction-off transition: marker cleanup verified=${markerCleanup.verified}, removed=${markerCleanup.removedLineages} lineage(s)/${markerCleanup.removedRows} row(s), retained=${markerCleanup.retainedLineages}, clearedSomething=${clearedSomething}`);
+  if (!markerCleanup.verified && !loggedUnverifiedMarkerCleanupRetry) {
+    loggedUnverifiedMarkerCleanupRetry = true;
+    sessionLog(sessionId, "compaction-off transition could not verify complete marker cleanup; durable cleanup retry will run on the next pass");
+  }
+  const notice = clearedSomething ? COMPACTION_OFF_FLIP_NOTICE : null;
+  if (notice) {
+    setCompactionModeRecord(db, sessionId, "off_notice_pending");
+  } else if (!markerCleanup.verified) {
+    setCompactionModeRecord(db, sessionId, "off_cleanup_pending");
+  }
+  return {
+    recordToWrite: notice ? markerCleanup.verified ? "off" : "off_cleanup_pending" : markerCleanup.verified ? "off" : null,
+    notice,
+    invalidatedM0Baseline,
+    historianCatchUpSignaled: false,
+    clearedCompartmentInProgress,
+    clearedSomething,
+    markerCleanup
+  };
 }
-function resolveTodowriteAvailability(sessionId) {
-  return resolveToolAvailability(sessionId, TODOWRITE_TOOL);
+function commitCompactionModeRecord(db, sessionId, record) {
+  setCompactionModeRecord(db, sessionId, record);
 }
 
 // src/hooks/magic-context/emergency-fail-closed.ts
@@ -22404,6 +23120,29 @@ function calibrateBuckets(input) {
 }
 
 // src/hooks/magic-context/final-wire-token-estimate.ts
+function compactWireLabel(value, fallback) {
+  if (typeof value !== "string" || value.length === 0)
+    return fallback;
+  return value.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 32) || fallback;
+}
+function wirePartKind(part, role) {
+  const rawType = part !== null && typeof part === "object" && typeof part.type === "string" ? part.type : "unknown";
+  if (rawType === "tool_result" || rawType === "tool-result")
+    return "toolresult";
+  if (rawType === "tool_use" || rawType === "tool-use" || rawType === "tool-invocation") {
+    return "tool";
+  }
+  if (role === "user" && rawType === "tool")
+    return "toolresult";
+  return compactWireLabel(rawType, "unknown");
+}
+function describeFinalWireTail(messages) {
+  return `[${messages.slice(-3).map((message) => {
+    const role = compactWireLabel(message.info.role, "unknown");
+    const kinds = message.parts.map((part) => wirePartKind(part, role)).join("+") || "none";
+    return `${role}:${kinds}`;
+  }).join(", ")}]`;
+}
 function serializedTokens(value) {
   if (value === undefined)
     return 0;
@@ -25926,75 +26665,6 @@ ${hintText}`;
 }
 function clearAutoSearchForSession(_sessionId) {}
 
-// src/hooks/magic-context/sentinel.ts
-var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
-function modelAcceptsEmptyContent(providerID) {
-  return providerID === "anthropic";
-}
-function variantChangeBustsProviderCache(providerID) {
-  if (providerID === undefined)
-    return true;
-  if (providerID === "anthropic")
-    return true;
-  if (providerID === "google-vertex-anthropic")
-    return true;
-  if (providerID.includes("bedrock"))
-    return true;
-  return false;
-}
-function makeSentinel(originalPart) {
-  const sentinel = {
-    type: "text",
-    text: ""
-  };
-  if (isRecord(originalPart)) {
-    if (originalPart.cache_control !== undefined) {
-      sentinel.cache_control = originalPart.cache_control;
-    }
-    if (originalPart.cacheControl !== undefined) {
-      sentinel.cacheControl = originalPart.cacheControl;
-    }
-  }
-  return sentinel;
-}
-function makeWholeMessageSentinel(providerID) {
-  return {
-    type: "text",
-    text: modelAcceptsEmptyContent(providerID) ? "" : WHOLE_MESSAGE_PLACEHOLDER_TEXT
-  };
-}
-function isSentinel(part) {
-  if (!isRecord(part))
-    return false;
-  if (part.type !== "text")
-    return false;
-  if (typeof part.text !== "string")
-    return false;
-  return part.text === "" || part.text === WHOLE_MESSAGE_PLACEHOLDER_TEXT;
-}
-function replaySentinelByMessageIds(messages, ids, providerID) {
-  if (ids.size === 0)
-    return { replayed: 0, missingIds: [] };
-  const seen = new Set;
-  let replayed = 0;
-  for (const msg of messages) {
-    const id = msg.info.id;
-    if (!id || !ids.has(id))
-      continue;
-    seen.add(id);
-    if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
-      continue;
-    msg.parts.length = 0;
-    msg.parts.push(makeWholeMessageSentinel(providerID));
-    replayed++;
-  }
-  const missingIds = [];
-  for (const id of ids)
-    if (!seen.has(id))
-      missingIds.push(id);
-  return { replayed, missingIds };
-}
-
 // src/hooks/magic-context/drop-stale-reduce-calls.ts
 var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
 function isReduceToolPart(part) {
@@ -27039,6 +27709,14 @@ function computeSyntheticCallId(stateJson) {
   const hash = createHash10("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash}`;
 }
+function isSyntheticTodoPart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  if (p.syntheticTodoMarker === true)
+    return true;
+  return p.type === "tool" && p.tool === "todowrite" && typeof p.callID === "string" && p.callID.startsWith(SYNTHETIC_CALL_ID_PREFIX);
+}
 function parseTodoState(stateJson) {
   if (stateJson.length === 0)
     return null;
@@ -27778,6 +28456,74 @@ function injectPersistedTodoAnchor(messages, sessionId, messageId2, part) {
   }
   return injectSyntheticTodoAtHead(messages, sessionId, part);
 }
+function removeSyntheticTodoParts(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message)
+      continue;
+    const retainedParts = message.parts.filter((part) => !isSyntheticTodoPart(part));
+    if (retainedParts.length === message.parts.length)
+      continue;
+    message.parts = retainedParts;
+    if (message.info.id === TODO_HEAD_ANCHOR_ID && retainedParts.length === 0) {
+      messages.splice(index, 1);
+    }
+  }
+}
+async function applyTodoSynthesis(args) {
+  if (!args.fullFeatureMode || args.compactionOff)
+    return 0;
+  const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+  let permissionDenied = cachedToolPermissionDenied(args.sessionId, "todowrite") ?? getPersistedTodoPermissionDenied(args.db, args.sessionId) ?? false;
+  const toolsMapUnavailable = args.todowriteAvailability.frozen && !args.todowriteAvailability.callable;
+  if (args.isCacheBustingPass && args.client && !toolsMapUnavailable) {
+    try {
+      permissionDenied = await todowritePermissionDenied(args.client, args.sessionId, args.activeAgent);
+      setPersistedTodoPermissionDenied(args.db, args.sessionId, permissionDenied);
+    } catch (error) {
+      sessionLog(args.sessionId, "todowrite permission read failed; retaining the last successful verdict:", error);
+    }
+  }
+  const todowriteUnavailable = toolsMapUnavailable || permissionDenied;
+  if (args.isCacheBustingPass && todowriteUnavailable) {
+    removeSyntheticTodoParts(args.messages);
+    clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+    if (persistedAnchor) {
+      sessionLog(args.sessionId, "todowrite synthetic pair cleared on a cache-busting pass because the tool is denied");
+    }
+    return 0;
+  }
+  if (args.isCacheBustingPass) {
+    const part = buildSyntheticTodoPart(args.sessionMeta.lastTodoState);
+    const persistedInjection = part !== null && persistedAnchor && persistedAnchor.callId === part.callID ? injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part) : null;
+    if (part === null) {
+      if (persistedAnchor)
+        clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
+      return 0;
+    }
+    if (persistedAnchor && persistedInjection?.injected) {
+      if (persistedAnchor.stateJson.length === 0) {
+        setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.sessionMeta.lastTodoState);
+      }
+      return persistedInjection.prependedMessageCount;
+    }
+    const existingAssistantId = injectToolPartIntoLatestAssistant(args.messages, part);
+    const injection = existingAssistantId === null ? injectSyntheticTodoAtHead(args.messages, args.sessionId, part) : {
+      injected: true,
+      messageId: existingAssistantId,
+      prependedMessageCount: 0
+    };
+    setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part.callID, injection.messageId, args.sessionMeta.lastTodoState);
+    return injection.prependedMessageCount;
+  }
+  if (persistedAnchor && persistedAnchor.stateJson.length > 0) {
+    const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
+    if (part !== null && part.callID === persistedAnchor.callId) {
+      return injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part).prependedMessageCount;
+    }
+  }
+  return 0;
+}
 function runRustModePostprocess(args) {
   if (!args.fullFeatureMode)
     return;
@@ -27934,18 +28680,19 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
   return { clearedParts, mergedReasoningParts };
 }
 async function runPostTransformPhase(args) {
+  const compactionOff = args.compactionOff === true;
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
   const isExplicitFlush = pendingMaterializationAtPassStart;
   const deferredMaterializationWasPending = deferredMaterializationAtPassStart;
   const alreadyRanThisTurn = args.currentTurnId !== null && args.lastHeuristicsTurnId.get(args.sessionId) === args.currentTurnId;
-  const forceMaterialization = args.fullFeatureMode && args.contextUsage.percentage >= args.forceMaterializationPercentage;
-  const emergencyDropEligible = args.contextUsage.percentage >= args.forceMaterializationPercentage;
+  const forceMaterialization = args.fullFeatureMode && !compactionOff && args.contextUsage.percentage >= args.forceMaterializationPercentage;
+  const emergencyDropEligible = !compactionOff && args.contextUsage.percentage >= args.forceMaterializationPercentage;
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
   const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   const materializationRequested = isExplicitFlush || deferredMaterialize;
-  const m0M1EnabledForFold = args.fullFeatureMode && args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory);
+  const m0M1EnabledForFold = args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory) && (args.fullFeatureMode || compactionOff);
   const m0HardFoldThisPass = m0M1EnabledForFold && args.m0M1 ? mustMaterialize({
     db: args.db,
     sessionId: args.sessionId,
@@ -27955,12 +28702,23 @@ async function runPostTransformPhase(args) {
     hardSignals: args.m0M1.hardSignals
   }).value : false;
   const bypassCompartmentGate = forceMaterialization || m0HardFoldThisPass;
-  const shouldReadPendingOps = materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || m0HardFoldThisPass || compartmentRunning;
+  const shouldReadPendingOps = !compactionOff && (materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || m0HardFoldThisPass || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
-  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || m0HardFoldThisPass) && (!compartmentRunning || bypassCompartmentGate);
-  const shouldRunHeuristics = (!compartmentRunning || bypassCompartmentGate) && (materializationRequested || forceMaterialization || m0HardFoldThisPass || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldApplyPendingOps = !compactionOff && (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || m0HardFoldThisPass) && (!compartmentRunning || bypassCompartmentGate);
+  const shouldRunHeuristics = !compactionOff && (!compartmentRunning || bypassCompartmentGate) && (materializationRequested || forceMaterialization || m0HardFoldThisPass || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = shouldApplyPendingOps || shouldRunHeuristics;
+  if (isCacheBustingPass && args.client && args.ctxReduceAvailability.callable && !hasLoggedCtxReducePermissionDeny(args.sessionId)) {
+    try {
+      const denied = await resolveToolPermissionDenied(args.client, args.sessionId, "ctx_reduce", args.activeAgent);
+      if (denied) {
+        markCtxReducePermissionDenyLogged(args.sessionId);
+        sessionLog(args.sessionId, "ctx_reduce permission is denied by OpenCode; frozen guidance remains until session restart");
+      }
+    } catch (error) {
+      sessionLog(args.sessionId, "ctx_reduce permission read failed (ignored):", error);
+    }
+  }
   const canUseEmptySentinels = modelAcceptsEmptyContent(args.resolvedProviderID);
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
@@ -27972,7 +28730,7 @@ async function runPostTransformPhase(args) {
   }
   if (compartmentRunning && hasPendingUserOps) {
     if (bypassCompartmentGate) {
-      const bypassReason = forceMaterialization ? "emergency >=85%" : "m0 hard fold";
+      const bypassReason = forceMaterialization ? `emergency >=${args.forceMaterializationPercentage}%` : "m0 hard fold";
       sessionLog(args.sessionId, `transform: compartment-gate bypass (${bypassReason}) — applying ${pendingOps.length} pending ops while compartment agent runs (${args.contextUsage.percentage.toFixed(1)}%)`);
     } else {
       sessionLog(args.sessionId, "transform: deferring pending ops — compartment agent in progress");
@@ -28078,7 +28836,7 @@ async function runPostTransformPhase(args) {
     if (args.schedulerDecision === "execute" && !materializationRequested) {
       updateSessionMeta(args.db, args.sessionId, { lastResponseTime: Date.now() });
     }
-    const toolReclaimExecutePass = args.schedulerDecision === "execute";
+    const toolReclaimExecutePass = !compactionOff && args.schedulerDecision === "execute";
     const alreadyMutatingThisPass = pendingOpsDidMutate || heuristicOrReasoningDidMutate;
     let autoReclaimTargetCount = 0;
     let autoReclaimDidMutate = false;
@@ -28162,7 +28920,7 @@ async function runPostTransformPhase(args) {
     sessionLog(args.sessionId, "transform failed applying pending operations:", error);
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error) });
   }
-  if (canUseEmptySentinels) {
+  if (canUseEmptySentinels && !compactionOff) {
     try {
       const t8 = performance.now();
       const frozenStaleReduceIds = getStaleReduceStrippedIds(args.db, args.sessionId);
@@ -28179,7 +28937,7 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "transform failed dropping stale ctx_reduce calls:", error);
     }
   }
-  if (canUseEmptySentinels) {
+  if (canUseEmptySentinels && !compactionOff) {
     try {
       const tImg = performance.now();
       const frozenImageIds = getProcessedImageStrippedIds(args.db, args.sessionId);
@@ -28214,7 +28972,8 @@ async function runPostTransformPhase(args) {
         temporalAwareness: args.m0M1.temporalAwareness,
         isCacheBustingPass,
         hardSignals: args.m0M1.hardSignals,
-        muralEnabled: args.m0M1.muralEnabled
+        muralEnabled: args.m0M1.muralEnabled,
+        compactionOff
       });
       if (result.injected) {
         m0M1InjectedThisPass = true;
@@ -28239,7 +28998,7 @@ async function runPostTransformPhase(args) {
       clearInjectionCache(args.sessionId);
     }
     logTransformTiming(args.sessionId, "pp.injectM0M1", tInjectM0M1);
-  } else if (args.fullFeatureMode && args.pendingCompartmentInjection) {
+  } else if (args.fullFeatureMode && !compactionOff && args.pendingCompartmentInjection) {
     const compartmentResult = renderCompartmentInjection(args.sessionId, args.messages, args.pendingCompartmentInjection);
     if (compartmentResult.injected) {
       prependedMessageCount += compartmentResult.prependedMessageCount;
@@ -28250,7 +29009,7 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  {
+  if (!compactionOff) {
     const tPlaceholder = performance.now();
     const persistedIds = getStrippedPlaceholderIds(args.db, args.sessionId);
     if (persistedIds.size > 0) {
@@ -28283,7 +29042,7 @@ async function runPostTransformPhase(args) {
     logTransformTiming(args.sessionId, "pp.placeholderNeutralize", tPlaceholder);
   }
   const tNudgeBlock = performance.now();
-  if (args.fullFeatureMode) {
+  if (args.fullFeatureMode && !compactionOff) {
     for (const anchor of getNoteNudgeAnchors(args.db, args.sessionId)) {
       appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
     }
@@ -28328,12 +29087,14 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  reconcileMarkerRepresentation(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
-    db: args.db,
-    sessionId: args.sessionId,
-    tagger: args.tagger,
-    ctxReduceAvailability: args.ctxReduceAvailability
-  });
+  if (!compactionOff) {
+    reconcileMarkerRepresentation(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
+      db: args.db,
+      sessionId: args.sessionId,
+      tagger: args.tagger,
+      ctxReduceAvailability: args.ctxReduceAvailability
+    });
+  }
   const deferredHistoryDrainEligible = historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart && !suppressV12HistoryDrain;
   if (deferredHistoryDrainEligible) {
     args.deferredHistoryRefreshSessions.delete(args.sessionId);
@@ -28357,42 +29118,19 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, `note-nudge delivery skipped wire append: ${outcome.kind}`);
     }
   }
-  if (args.fullFeatureMode) {
-    const persistedAnchor = getPersistedTodoSyntheticAnchor(args.db, args.sessionId);
-    const todowriteUnavailable = args.todowriteAvailability.frozen && !args.todowriteAvailability.callable;
-    if (isCacheBustingPass && todowriteUnavailable) {
-      if (persistedAnchor) {
-        clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
-      }
-    } else if (isCacheBustingPass) {
-      const part = buildSyntheticTodoPart(args.sessionMeta.lastTodoState);
-      const persistedInjection = part !== null && persistedAnchor && persistedAnchor.callId === part.callID ? injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part) : null;
-      if (part === null) {
-        if (persistedAnchor) {
-          clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
-        }
-      } else if (persistedAnchor && persistedInjection?.injected) {
-        prependedMessageCount += persistedInjection.prependedMessageCount;
-        if (persistedAnchor.stateJson.length === 0) {
-          setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.sessionMeta.lastTodoState);
-        }
-      } else {
-        const existingAssistantId = injectToolPartIntoLatestAssistant(args.messages, part);
-        const injection = existingAssistantId === null ? injectSyntheticTodoAtHead(args.messages, args.sessionId, part) : {
-          injected: true,
-          messageId: existingAssistantId,
-          prependedMessageCount: 0
-        };
-        prependedMessageCount += injection.prependedMessageCount;
-        setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part.callID, injection.messageId, args.sessionMeta.lastTodoState);
-      }
-    } else if (persistedAnchor && persistedAnchor.stateJson.length > 0) {
-      const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
-      if (part !== null && part.callID === persistedAnchor.callId) {
-        const injection = injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part);
-        prependedMessageCount += injection.prependedMessageCount;
-      }
-    }
+  if (args.fullFeatureMode && !compactionOff) {
+    prependedMessageCount += await applyTodoSynthesis({
+      db: args.db,
+      sessionId: args.sessionId,
+      messages: args.messages,
+      fullFeatureMode: args.fullFeatureMode,
+      compactionOff,
+      isCacheBustingPass,
+      sessionMeta: args.sessionMeta,
+      todowriteAvailability: args.todowriteAvailability,
+      client: args.client,
+      activeAgent: args.activeAgent
+    });
   }
   logTransformTiming(args.sessionId, "pp.noteAndTodoSynthesis", tNoteAndTodo);
   if (args.compartmentInjectionRebuiltFromDb && args.pendingCompartmentInjection) {
@@ -28529,7 +29267,7 @@ class MemoryAuthorityUnavailableError extends Error {
 var RUST_FAILURE_PARK_THRESHOLD = 3;
 var RUST_PROBE_INTERVAL = 5;
 var RUST_SEND_TIMEOUT_MS = 15000;
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object";
 }
 function replaceMessagesInPlace(output, next) {
@@ -28539,9 +29277,9 @@ function replaceMessagesInPlace(output, next) {
   return target;
 }
 function messageInfo2(value) {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return {};
-  return isRecord2(value.info) ? value.info : value;
+  return isRecord3(value.info) ? value.info : value;
 }
 function messageIdOf(message) {
   const id = messageInfo2(message).id;
@@ -28735,7 +29473,7 @@ function isSyntheticUserMessage(message) {
   if (!message || messageInfo2(message).role !== "user" || !Array.isArray(message.parts)) {
     return false;
   }
-  return message.parts.length > 0 && message.parts.every((part) => isRecord2(part) && (part.synthetic === true || part.ignored === true));
+  return message.parts.length > 0 && message.parts.every((part) => isRecord3(part) && (part.synthetic === true || part.ignored === true));
 }
 function observeSyntheticTurn(state, messages) {
   const newest = newestUserMessage(messages);
@@ -28755,16 +29493,16 @@ function observeSyntheticTurn(state, messages) {
 function assertNativeBoundary(output, sessionId, boundaryId) {
   const first = output.find((message) => messageInfo2(message).role !== "system");
   const info = messageInfo2(first);
-  const parts = isRecord2(first) && Array.isArray(first.parts) ? first.parts : [];
-  const synthetic = parts.length > 0 && parts.every((part) => isRecord2(part) && part.synthetic === true);
+  const parts = isRecord3(first) && Array.isArray(first.parts) ? first.parts : [];
+  const synthetic = parts.length > 0 && parts.every((part) => isRecord3(part) && part.synthetic === true);
   if (info.role === "user" && info.sessionID === sessionId && synthetic)
     return;
   throw new Error(`rust transform wire invariant failed: boundary=${boundaryId} expected a synthetic m0 user message scoped to session ${sessionId}`);
 }
 function responseValue(response) {
-  if (isRecord2(response) && isRecord2(response.result))
+  if (isRecord3(response) && isRecord3(response.result))
     return response.result;
-  if (isRecord2(response))
+  if (isRecord3(response))
     return response;
   throw new Error("module transform returned a non-object response");
 }
@@ -28773,7 +29511,7 @@ function noteDeliveryPassIds(response) {
     return [];
   return [
     ...new Set(response.note_deliveries.flatMap((delivery) => {
-      if (!isRecord2(delivery))
+      if (!isRecord3(delivery))
         return [];
       const passId = delivery.transform_pass_id;
       return typeof passId === "string" && passId.length > 0 ? [passId] : [];
@@ -28783,7 +29521,7 @@ function noteDeliveryPassIds(response) {
 function modelFromMessages(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const info = messages[index]?.info;
-    const model = isRecord2(info?.model) ? info.model : undefined;
+    const model = isRecord3(info?.model) ? info.model : undefined;
     if (typeof model?.providerID === "string" && typeof model.modelID === "string") {
       return { providerID: model.providerID, modelID: model.modelID };
     }
@@ -28807,6 +29545,7 @@ function ensureState(states, sessionId) {
       ordinalMemoAnchor: null,
       ordinalMemoStoredCount: null,
       ordinalMemoCanonicalCount: 0,
+      ordinalContinuationBase: null,
       seedPassPending: true,
       failureCount: 0,
       parkCount: 0,
@@ -28861,8 +29600,8 @@ function passUsage(usage, limit) {
   };
 }
 function directiveTextOf(response) {
-  const directives = isRecord2(response.host_directives) ? response.host_directives : undefined;
-  const channel2 = isRecord2(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
+  const directives = isRecord3(response.host_directives) ? response.host_directives : undefined;
+  const channel2 = isRecord3(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
   return typeof channel2?.text === "string" && channel2.text.length > 0 ? channel2.text : undefined;
 }
 function isNeedFullSync(response) {
@@ -28871,7 +29610,7 @@ function isNeedFullSync(response) {
 function canonicalizeForChecksum(value) {
   if (Array.isArray(value))
     return value.map(canonicalizeForChecksum);
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return value;
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalizeForChecksum(value[key])]));
 }
@@ -28887,7 +29626,7 @@ function authoritySeedRows(db, projectPath, domain) {
                                 WHERE sp.session_id = n.session_id AND sp.project_path = ?
                            ))
                         ORDER BY n.id ASC`).all(projectPath, projectPath);
-  const memoryRows = snapshots.filter(isRecord2);
+  const memoryRows = snapshots.filter(isRecord3);
   const mappings = domain === "memories" ? getMemoryVerifications(db, memoryRows.map((row) => Number(row.id))) : new Map;
   return memoryRows.map((snapshot) => {
     const id = Number(snapshot.id);
@@ -28912,11 +29651,36 @@ async function prepareRustMemoryAuthority(args) {
     throw new MemoryAuthorityUnavailableError("the module does not expose authority.status, authority.prepare, and authority.seed");
   }
   const authorityModule = {
-    authorityStatus: (request2) => module.authorityStatus({ ...request2, projectRoot }),
-    authorityPrepare: (request2) => module.authorityPrepare({ ...request2, projectRoot }),
-    authoritySeed: (request2) => module.authoritySeed({ ...request2, projectRoot }),
-    authorityDrain: module.authorityDrain ? (request2) => module.authorityDrain({ ...request2, projectRoot }) : undefined,
-    mirrorPull: module.mirrorPull ? (request2) => module.mirrorPull({ ...request2, projectRoot }) : undefined
+    authorityStatus: (request2) => {
+      const method = module.authorityStatus;
+      if (!method)
+        throw new MemoryAuthorityUnavailableError("authority.status unavailable");
+      return method.call(module, { ...request2, projectRoot });
+    },
+    authorityPrepare: (request2) => {
+      const method = module.authorityPrepare;
+      if (!method)
+        throw new MemoryAuthorityUnavailableError("authority.prepare unavailable");
+      return method.call(module, { ...request2, projectRoot });
+    },
+    authoritySeed: (request2) => {
+      const method = module.authoritySeed;
+      if (!method)
+        throw new MemoryAuthorityUnavailableError("authority.seed unavailable");
+      return method.call(module, { ...request2, projectRoot });
+    },
+    authorityDrain: module.authorityDrain ? (request2) => {
+      const method = module.authorityDrain;
+      if (!method)
+        throw new MemoryAuthorityUnavailableError("authority.drain unavailable");
+      return method.call(module, { ...request2, projectRoot });
+    } : undefined,
+    mirrorPull: module.mirrorPull ? (request2) => {
+      const method = module.mirrorPull;
+      if (!method)
+        throw new MemoryAuthorityUnavailableError("mirror.pull unavailable");
+      return method.call(module, { ...request2, projectRoot });
+    } : undefined
   };
   const contextStoreUuid = ensureContextStoreUuid(db);
   const domains = ["memories", "notes"];
@@ -28942,7 +29706,7 @@ async function prepareRustMemoryAuthority(args) {
         projectPath,
         domain,
         module: authorityModule,
-        checksum: () => checksumSeedRows(db.prepare(`SELECT * FROM ${domain === "memories" ? "memories" : "notes"} WHERE project_path = ? ORDER BY id ASC`).all(projectPath).filter(isRecord2))
+        checksum: () => checksumSeedRows(db.prepare(`SELECT * FROM ${domain === "memories" ? "memories" : "notes"} WHERE project_path = ? ORDER BY id ASC`).all(projectPath).filter(isRecord3))
       });
       if (!("code" in drained))
         break;
@@ -29051,6 +29815,13 @@ function buildTransformBody(args) {
     caveman_enabled: args.passInputs.caveman_enabled === true,
     caveman_min_chars: args.passInputs.caveman_min_chars ?? 500,
     cache_ttl: args.passInputs.cache_ttl,
+    lineage_switched: args.passInputs.lineage_switched === true,
+    descent_edge_id: args.passInputs.descent_edge_id,
+    prior_conversation_key: args.passInputs.prior_conversation_key,
+    prior_epoch: args.passInputs.prior_epoch,
+    new_epoch: args.passInputs.new_epoch,
+    constituents: args.passInputs.constituents,
+    compaction_observed: args.passInputs.compaction_observed === true,
     pass_inputs: args.passInputs,
     declared_trim: args.declaredTrim
   };
@@ -29282,7 +30053,7 @@ function createRustModeTransform(deps, options) {
       decision = typeof response.decision === "string" ? response.decision : typeof response.action === "string" ? response.action : typeof response.status === "string" ? response.status : "unknown";
       servedFrom = typeof response.served_from === "string" ? response.served_from : "unknown";
       materializeReason = typeof response.materialize_reason === "string" && response.materialize_reason.length > 0 ? response.materialize_reason : "none";
-      const timings2 = isRecord2(response.timings) ? response.timings : undefined;
+      const timings2 = isRecord3(response.timings) ? response.timings : undefined;
       const total = timings2?.total;
       moduleElapsedMs = typeof total === "number" && Number.isFinite(total) ? total : 0;
       if (timings2 && moduleElapsedMs >= 1000) {
@@ -29383,10 +30154,10 @@ function createRustModeTransform(deps, options) {
             continue;
           const prior = state.idOrdinalMemo.get(priorId);
           if (prior !== undefined)
-            return prior;
+            return Math.max(prior, state.ordinalContinuationBase ?? 0);
         }
-        return state.ordinalMemoCanonicalCount;
-      })() : undefined;
+        return Math.max(state.ordinalMemoCanonicalCount, state.ordinalContinuationBase ?? 0);
+      })() : state.ordinalContinuationBase ?? undefined;
       const ordinalStartedAt = performance.now();
       let resolved = await resolveOrdinalsForModule({
         sessionId,
@@ -29412,7 +30183,8 @@ function createRustModeTransform(deps, options) {
           memo: state.idOrdinalMemo,
           memoAnchor: state.ordinalMemoAnchor,
           memoStoredCount: state.ordinalMemoStoredCount,
-          memoCanonicalCount: state.ordinalMemoCanonicalCount
+          memoCanonicalCount: state.ordinalMemoCanonicalCount,
+          provisionalBase: state.ordinalContinuationBase ?? undefined
         });
         logStage(sessionId, "ordinalResolve", fullOrdinalStartedAt, timings, "fallback=clean_full");
       }
@@ -29454,10 +30226,11 @@ function createRustModeTransform(deps, options) {
             };
           }
         }
+        const stateSyncCapabilities = options.moduleClient.stateSyncCapabilities;
         const stateSyncResult = await syncModuleState({
           client: {
             call: callModule,
-            stateSyncCapabilities: options.moduleClient.stateSyncCapabilities ? (capabilityArgs) => options.moduleClient.stateSyncCapabilities(capabilityArgs) : undefined
+            stateSyncCapabilities: stateSyncCapabilities ? (capabilityArgs) => stateSyncCapabilities.call(options.moduleClient, capabilityArgs) : undefined
           },
           state,
           pass: syncPass,
@@ -29591,7 +30364,8 @@ function createRustModeTransform(deps, options) {
             memo: state.idOrdinalMemo,
             memoAnchor: state.ordinalMemoAnchor,
             memoStoredCount: state.ordinalMemoStoredCount,
-            memoCanonicalCount: state.ordinalMemoCanonicalCount
+            memoCanonicalCount: state.ordinalMemoCanonicalCount,
+            provisionalBase: state.ordinalContinuationBase ?? undefined
           });
           logStage(sessionId, "ordinalResolve", retryOrdinalStartedAt, timings, "retry=full");
           if (!retryResolved.ok) {
@@ -29741,6 +30515,16 @@ function createRustModeTransform(deps, options) {
           sessionLog(sessionId, "rust note delivery ack failed (will retry):", ackError);
         }
       }
+      const ordinalContinuationBase = response.ordinal_continuation_base;
+      if (typeof ordinalContinuationBase === "number" && Number.isSafeInteger(ordinalContinuationBase) && ordinalContinuationBase > 0) {
+        if (state.ordinalContinuationBase === null) {
+          for (const [messageId2, ordinal] of state.idOrdinalMemo) {
+            state.idOrdinalMemo.set(messageId2, ordinal + ordinalContinuationBase);
+          }
+          state.ordinalMemoCanonicalCount += ordinalContinuationBase;
+        }
+        state.ordinalContinuationBase = ordinalContinuationBase;
+      }
       if (!stateSyncRetryBusy) {
         state.initialized = true;
         state.seedPassPending = false;
@@ -29774,13 +30558,14 @@ function createRustModeTransform(deps, options) {
           sessionLog(sessionId, "rust memory mirror-back failed (ignored):", error);
         }
       }
-      if (options.moduleClient.getCompartmentsAfter) {
+      const getCompartmentsAfter = options.moduleClient.getCompartmentsAfter;
+      if (getCompartmentsAfter) {
         try {
           await mirrorModuleCompartments({
             db: deps.db,
             sessionId,
             reader: {
-              getCompartmentsAfter: (mirroredSessionId, afterSequence) => options.moduleClient.getCompartmentsAfter(mirroredSessionId, afterSequence)
+              getCompartmentsAfter: (mirroredSessionId, afterSequence) => getCompartmentsAfter.call(options.moduleClient, mirroredSessionId, afterSequence)
             }
           });
         } catch (error) {
@@ -29838,7 +30623,7 @@ function createRustModeTransform(deps, options) {
 // src/hooks/magic-context/transform-compartment-phase.ts
 function runCompartmentPhase(args) {
   const historianRunnable = args.historianRunnable !== false;
-  const willReadRawHistory = historianRunnable && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || !args.skipAwaitForThisPass && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
+  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || !args.skipAwaitForThisPass && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
   if (!willReadRawHistory) {
     return runCompartmentPhaseImpl(args);
   }
@@ -29862,6 +30647,21 @@ async function runCompartmentPhaseImpl(args) {
   let justAwaitedPublication = false;
   let rebuiltHistoryThisPass = false;
   const historianRunnable = args.historianRunnable !== false;
+  if (args.compactionOff) {
+    if (args.sessionMeta.compartmentInProgress) {
+      sessionLog(args.sessionId, "transform: compaction off; clearing stale compartmentInProgress flag");
+      updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
+      compartmentInProgress = false;
+    }
+    return {
+      pendingCompartmentInjection,
+      awaitedCompartmentRun: false,
+      compartmentInProgress,
+      published,
+      justAwaitedPublication,
+      rebuiltHistoryThisPass
+    };
+  }
   let rawEligibility = null;
   let lastObservedCompartmentEnd = -1;
   let cachedBoundarySnapshot = null;
@@ -30047,12 +30847,31 @@ function clearMessageTokensCache(sessionId, messageId2) {
     cache.delete(messageId2);
 }
 var recordedSessionProjectIdentity = new BoundedSessionMap(MESSAGE_TOKENS_CACHE_MAX);
+function activeAgentFromMessages(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const info = messages[index]?.info;
+    if (info?.role !== "user")
+      continue;
+    return typeof info.agent === "string" && info.agent.length > 0 ? info.agent : undefined;
+  }
+  return;
+}
 function deriveTaggerLoadFloor(messages, sessionId, db) {
   return deriveTagLoadFloor(db, sessionId, function* () {
     for (const message of messages)
       yield message.info?.id;
   }());
 }
+function computeHardCacheExpired(cacheTtl, lastResponseTime, now, onInvalid) {
+  let ttlMs;
+  try {
+    ttlMs = parseCacheTtl(cacheTtl);
+  } catch (error) {
+    onInvalid?.(error);
+    ttlMs = 5 * 60 * 1000;
+  }
+  return lastResponseTime > 0 && now - lastResponseTime > ttlMs;
+}
 function findLastAssistantModel(messages) {
   for (let i = messages.length - 1;i >= 0; i--) {
     const info = messages[i].info;
@@ -30078,19 +30897,22 @@ var tsAuthorityRecoveryStateByProject = new Map;
 var tsAuthorityMismatchLoggedProjects = new Set;
 var tsAuthorityUnreachableLoggedProjects = new Set;
 function authorityModuleForProject(module, projectRoot) {
-  if (!module.authorityStatus || !module.authorityDrain || !module.mirrorPull) {
+  const authorityStatus = module.authorityStatus;
+  const authorityDrain = module.authorityDrain;
+  const mirrorPull = module.mirrorPull;
+  if (!authorityStatus || !authorityDrain || !mirrorPull) {
     throw new Error("the module does not expose authority.status, authority.drain, and mirror.pull");
   }
   return {
-    authorityStatus: (request2) => module.authorityStatus({ ...request2, projectRoot }),
+    authorityStatus: (request2) => authorityStatus.call(module, { ...request2, projectRoot }),
     authorityPrepare: (request2) => {
       if (!module.authorityPrepare) {
         throw new Error("the module does not expose authority.prepare");
       }
       return module.authorityPrepare({ ...request2, projectRoot });
     },
-    authorityDrain: (request2) => module.authorityDrain({ ...request2, projectRoot }),
-    mirrorPull: (request2) => module.mirrorPull({ ...request2, projectRoot })
+    authorityDrain: (request2) => authorityDrain.call(module, { ...request2, projectRoot }),
+    mirrorPull: (request2) => mirrorPull.call(module, { ...request2, projectRoot })
   };
 }
 async function recoverTsAuthorityProject(args) {
@@ -30142,11 +30964,12 @@ function scheduleTsAuthorityRecovery(args) {
     return;
   if (tsAuthorityRecoveryStateByProject.has(args.projectPath))
     return;
+  const module = args.module;
   if (!tsAuthorityMismatchLoggedProjects.has(args.projectPath)) {
     tsAuthorityMismatchLoggedProjects.add(args.projectPath);
     log(`[magic-context] project ${args.projectPath} is module-authority-managed but transform_mode is TS; draining authority back to TypeScript`);
   }
-  if (!args.module) {
+  if (!module) {
     tsAuthorityRecoveryStateByProject.set(args.projectPath, "complete");
     if (!tsAuthorityUnreachableLoggedProjects.has(args.projectPath)) {
       tsAuthorityUnreachableLoggedProjects.add(args.projectPath);
@@ -30155,7 +30978,7 @@ function scheduleTsAuthorityRecovery(args) {
     return;
   }
   tsAuthorityRecoveryStateByProject.set(args.projectPath, "running");
-  Promise.resolve().then(() => recoverTsAuthorityProject({ ...args, module: args.module })).then((outcome) => {
+  Promise.resolve().then(() => recoverTsAuthorityProject({ ...args, module })).then((outcome) => {
     if (outcome === "completed") {
       tsAuthorityRecoveryStateByProject.set(args.projectPath, "complete");
       log(`[magic-context] authority drain complete for project ${args.projectPath}`);
@@ -30201,6 +31024,7 @@ function createTransform(deps) {
     }
     const tUserMsg = performance.now();
     const currentTurnId = findLastUserMessageId(messages);
+    const activeAgent = activeAgentFromMessages(messages);
     logTransformTiming(sessionId, "findLastUserMessageId", tUserMsg);
     const tMeta = performance.now();
     let sessionMeta;
@@ -30226,6 +31050,47 @@ function createTransform(deps) {
     }
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
+    const compactionOff = deps.compactionOff === true;
+    try {
+      const transition = reconcileCompactionMode({
+        db,
+        sessionId,
+        compactionOff,
+        historianRunnable: deps.historianRunnable !== false,
+        compartmentInProgress: sessionMeta.compartmentInProgress
+      });
+      const hasTransitionEffects = transition.recordToWrite !== null || transition.notice !== null || transition.invalidatedM0Baseline || transition.clearedCompartmentInProgress || transition.historianCatchUpSignaled;
+      if (hasTransitionEffects) {
+        if (transition.invalidatedM0Baseline) {
+          sessionMeta = {
+            ...sessionMeta,
+            cachedM0Bytes: null,
+            cachedM1Bytes: null,
+            cachedM0MuralDataUrl: null,
+            cachedM0MuralHash: null
+          };
+        }
+        if (transition.clearedCompartmentInProgress) {
+          sessionMeta = { ...sessionMeta, compartmentInProgress: false };
+        }
+        if (transition.historianCatchUpSignaled) {
+          sessionMeta = { ...sessionMeta, compartmentInProgress: true };
+        }
+        const notice = transition.notice;
+        let noticeDelivered = notice === null || deps.client === undefined;
+        if (notice && deps.client) {
+          noticeDelivered = await sendIgnoredMessage(deps.client, sessionId, notice, deps.getNotificationParams?.(sessionId) ?? {}) === "sent";
+        }
+        if (noticeDelivered && transition.recordToWrite !== null) {
+          commitCompactionModeRecord(db, sessionId, transition.recordToWrite);
+        } else if (!noticeDelivered) {
+          sessionLog(sessionId, "compaction mode notice was not delivered; durable pending record will retry on the next pass");
+        }
+      }
+    } catch (error) {
+      passOutcome.record("compaction-mode-transition-failure");
+      sessionLog(sessionId, "compaction mode transition failed (retrying next pass):", error);
+    }
     const ctxReduceAvailability = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
     const ctxReduceCallable = ctxReduceAvailability.callable;
     const todowriteAvailability = resolveTodowriteAvailabilityFromMessages(sessionId, messages);
@@ -30253,7 +31118,7 @@ function createTransform(deps) {
     }
     const compartmentDirectory = sessionDirectory;
     const historianRunnable = deps.historianRunnable !== false;
-    const canRunCompartments = fullFeatureMode && historianRunnable && deps.client !== undefined && compartmentDirectory.length > 0;
+    const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && deps.client !== undefined && compartmentDirectory.length > 0;
     const fallbackModelId = deps.getFallbackModelId?.(sessionId);
     const tModelDetect = performance.now();
     const persistedUsageBeforeResets = loadPersistedUsage(db, sessionId);
@@ -30313,7 +31178,7 @@ function createTransform(deps) {
     let emergencyRecoveryArmed = false;
     let emergencyRecoveryOrigin = null;
     let usagePercentageSynthetic = false;
-    if (fullFeatureMode) {
+    if (fullFeatureMode && !compactionOff) {
       try {
         const armModel = deps.liveModelBySession?.get(sessionId);
         const armModelKey = deps.getModelKey?.(sessionId);
@@ -30366,25 +31231,27 @@ function createTransform(deps) {
       sessionID: sessionId
     }) : undefined;
     const currentModelKeyForBoundary = deps.getModelKey?.(sessionId);
+    const thresholdContextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : contextUsageEarly.percentage > 0 ? contextUsageEarly.inputTokens / (contextUsageEarly.percentage / 100) : undefined;
+    const effectiveExecuteThresholdPercentage = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, currentModelKeyForBoundary, 65, {
+      tokensConfig: deps.executeThresholdTokens,
+      contextLimit: thresholdContextLimit,
+      sessionId
+    });
+    const { forceMaterializationPercentage } = escalationBands(effectiveExecuteThresholdPercentage);
     const persistedUsageFreshForBoundary = persistedUsageBeforeResets && Date.now() - persistedUsageBeforeResets.updatedAt <= 10 * 60 * 1000 && (persistedUsageBeforeResets.lastObservedModelKey === null || currentModelKeyForBoundary === undefined || persistedUsageBeforeResets.lastObservedModelKey === currentModelKeyForBoundary) && (resolvedContextLimit === undefined || persistedUsageBeforeResets.lastUsageContextLimit === 0 || persistedUsageBeforeResets.lastUsageContextLimit === resolvedContextLimit) ? persistedUsageBeforeResets.usage : null;
     const boundaryUsageForProtectedTail = persistedUsageFreshForBoundary ?? contextUsageEarly;
     const boundaryUsageSource = persistedUsageFreshForBoundary ? "persisted" : "live";
     const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens, resolvedContextLimit);
-    let emergencyCeilingLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
-    if (emergencyCeilingLimit <= 0 && contextUsageEarly.percentage > 0) {
-      emergencyCeilingLimit = contextUsageEarly.inputTokens / (contextUsageEarly.percentage / 100);
-    }
-    const emergencyCeilingTokens = Number.isFinite(emergencyCeilingLimit) && emergencyCeilingLimit > 0 ? Math.floor(emergencyCeilingLimit * (resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, deps.getModelKey?.(sessionId), 65, {
-      tokensConfig: deps.executeThresholdTokens,
-      contextLimit: emergencyCeilingLimit
-    }) / 100)) : undefined;
-    const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
+    const emergencyCeilingLimit = thresholdContextLimit ?? 0;
+    const emergencyCeilingTokens = Number.isFinite(emergencyCeilingLimit) && emergencyCeilingLimit > 0 ? Math.floor(emergencyCeilingLimit * (effectiveExecuteThresholdPercentage / 100)) : undefined;
+    const schedulerDecisionEarly = compactionOff ? "defer" : resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
     const midTurn = isMidTurn(deps, resolvedSessionId);
     const bypassReason = detectMidTurnBypassReason({
       contextUsage: contextUsageEarly,
       sessionMeta,
       historyRefreshSessions: deps.historyRefreshSessions,
-      sessionId
+      sessionId,
+      effectiveExecuteThresholdPercentage
     });
     const { midTurnAdjustedSchedulerDecision, sideEffect } = applyMidTurnDeferral({
       base: schedulerDecisionEarly,
@@ -30402,12 +31269,13 @@ function createTransform(deps) {
     sessionLog(sessionId, `[boundary-exec] base=${schedulerDecisionEarly} bypass=${bypassReason} midTurn=${midTurn} effective=${midTurnAdjustedSchedulerDecision} sideEffect=${sideEffect}`);
     const historyRefreshExplicitBeforePrepare = deps.historyRefreshSessions.has(sessionId);
     const deferredHistoryWasPendingAtPassStart = deferredHistoryRefreshSessions.has(sessionId);
-    const earlyActiveRunBlocksMaterialization = (getActiveCompartmentRun(sessionId) !== undefined || sessionMeta.compartmentInProgress) && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
+    const earlyActiveRunBlocksMaterialization = (getActiveCompartmentRun(sessionId) !== undefined || sessionMeta.compartmentInProgress) && contextUsageEarly.percentage < forceMaterializationPercentage;
     const canConsumeDeferredEarly = canConsumeDeferredOnThisPass({
       schedulerDecision: midTurnAdjustedSchedulerDecision,
       contextPercentage: contextUsageEarly.percentage,
       justAwaitedPublication: false,
-      activeRunBlocksMaterialization: earlyActiveRunBlocksMaterialization
+      activeRunBlocksMaterialization: earlyActiveRunBlocksMaterialization,
+      forceMaterializationPercentage
     });
     const consumingDeferredEarly = canConsumeDeferredEarly && deferredHistoryWasPendingAtPassStart;
     const isCacheBusting = historyRefreshExplicitBeforePrepare || consumingDeferredEarly;
@@ -30488,7 +31356,7 @@ function createTransform(deps) {
       skipCompartmentAwaitForThisPass = true;
       return true;
     };
-    if (fullFeatureMode && historianFailureState.failureCount > 0 && contextUsageEarly.percentage >= 95 && !recoveryNoHeadEscapeActive) {
+    if (fullFeatureMode && !compactionOff && historianFailureState.failureCount > 0 && contextUsageEarly.percentage >= 95 && !recoveryNoHeadEscapeActive) {
       skipCompartmentAwaitForThisPass = true;
       const emergencyPercentage = contextUsageEarly.percentage.toFixed(1);
       const recoveryStarted = startRecoveryRun();
@@ -30500,7 +31368,7 @@ function createTransform(deps) {
         sessionLog(sessionId, "transform: emergency recovery remains armed — no complete eligible head before protected tail");
       }
       sessionLog(sessionId, `EMERGENCY: historian recovery requested at ${emergencyPercentage}%, failures: ${historianFailureState.failureCount}`);
-    } else if (fullFeatureMode && isFirstTransformPassForSession && historianFailureState.failureCount > 0 && getEligibleHistoryForCompartment() && startRecoveryRun()) {
+    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0 && getEligibleHistoryForCompartment() && startRecoveryRun()) {
       sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
       if (deps.client) {
         sendIgnoredMessage(deps.client, sessionId, `## Historian recovery
@@ -30515,7 +31383,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
     }
     const sessionProjectIdentity = projectIdentity ?? (sessionDirectory ? resolveProjectIdentity(sessionDirectory) : deps.projectPath);
-    const sessionIdentityForBinding = sessionDirectory ? resolveProjectIdentityForSession(sessionDirectory) : undefined;
+    const sessionIdentityForBinding = sessionDirectory ? resolveProjectIdentityForSession(sessionDirectory, deps.allowHomeProject) : undefined;
     if (sessionDirectory) {
       maybeSendProjectIdentityWarning(deps, sessionId, sessionDirectory, notificationParams);
     }
@@ -30532,16 +31400,16 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordSessionProjectIdentity(db, sessionId, sessionIdentityForBinding);
       recordedSessionProjectIdentity.set(sessionId, sessionIdentityForBinding);
     }
-    const taggerFloor = deriveTaggerLoadFloor(messages, sessionId, db);
-    if (taggerFloor === 0 && messages.length > 0) {
+    const taggerFloor = compactionOff ? 0 : deriveTaggerLoadFloor(messages, sessionId, db);
+    if (!compactionOff && taggerFloor === 0 && messages.length > 0) {
       sessionLog(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
     }
     let triggerBoundarySnapshot;
-    if (fullFeatureMode && historianRunnable && !sessionMeta.compartmentInProgress) {
+    if (fullFeatureMode && !compactionOff && historianRunnable && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
       try {
         const inMemoryTail = buildTriggerInMemoryTail(db, sessionId, extractInMemoryMessageViews(messages));
-        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget(boundaryContextLimit, boundaryExecuteThreshold), deps.clearReasoningAge, deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail, taggerFloor);
+        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget(boundaryContextLimit, boundaryExecuteThreshold), deps.clearReasoningAge, deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail, taggerFloor, { providerID: resolvedProviderID });
         if (triggerResult.shouldFire) {
           sessionLog(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -30556,7 +31424,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     }
     let pendingCompartmentInjection = null;
     let rebuiltHistoryFromInitialPrepare = false;
-    if (fullFeatureMode) {
+    if (fullFeatureMode && !compactionOff) {
       const tInj = performance.now();
       pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectIdentity, deps.memoryConfig?.injectionBudgetTokens, deps.experimentalTemporalAwareness);
       logTransformTiming(sessionId, "prepareCompartmentInjection", tInj);
@@ -30570,10 +31438,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let targets = new Map;
     let reasoningByMessage = new Map;
     let messageTagNumbers = new Map;
-    let tagNormalizationTargets = [];
     let batch = null;
     let hasRecentReduceCall = false;
-    if (deps.experimentalTemporalAwareness) {
+    if (deps.experimentalTemporalAwareness && !compactionOff) {
       const tTemporal = performance.now();
       const injected = injectTemporalMarkers(messages);
       if (injected > 0) {
@@ -30582,44 +31449,45 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "injectTemporalMarkers", tTemporal);
     }
     let taggingSucceeded = false;
-    try {
-      const t0 = performance.now();
-      const tInitFromDb = performance.now();
-      deps.tagger.initFromDb(sessionId, db, taggerFloor);
-      logTransformTiming(sessionId, "tag.initFromDb", tInitFromDb);
-      const skipPrefixInjection = !ctxReduceCallable;
-      const result = tagMessages(sessionId, messages, deps.tagger, db, {
-        skipPrefixInjection
-      });
-      targets = result.targets;
-      reasoningByMessage = result.reasoningByMessage;
-      messageTagNumbers = result.messageTagNumbers;
-      tagNormalizationTargets = result.normalizationTargets;
-      batch = result.batch;
-      hasRecentReduceCall = result.hasRecentReduceCall;
-      const hadPriorCommitState = deps.commitSeenLastPass?.has(sessionId) ?? false;
-      const sawCommitLastPass = deps.commitSeenLastPass?.get(sessionId) ?? false;
-      if (fullFeatureMode && hadPriorCommitState && result.hasRecentCommit && !sawCommitLastPass) {
-        onNoteTrigger(db, sessionId, "commit_detected");
-      }
-      deps.commitSeenLastPass?.set(sessionId, result.hasRecentCommit);
-      logTransformTiming(sessionId, "tagMessages", t0);
-      taggingSucceeded = true;
-    } catch (error) {
-      passOutcome.record("tagging-persistence-failure");
-      sessionLog(sessionId, "transform tag persistence failed; continuing without tagging:", error);
+    if (!compactionOff) {
       try {
-        deps.tagger.cleanup(sessionId);
-      } catch (cleanupError) {
-        sessionLog(sessionId, "tagger cleanup after failure threw:", cleanupError);
+        const t0 = performance.now();
+        const tInitFromDb = performance.now();
+        deps.tagger.initFromDb(sessionId, db, taggerFloor);
+        logTransformTiming(sessionId, "tag.initFromDb", tInitFromDb);
+        const skipPrefixInjection = !ctxReduceCallable;
+        const result = tagMessages(sessionId, messages, deps.tagger, db, {
+          skipPrefixInjection
+        });
+        targets = result.targets;
+        reasoningByMessage = result.reasoningByMessage;
+        messageTagNumbers = result.messageTagNumbers;
+        batch = result.batch;
+        hasRecentReduceCall = result.hasRecentReduceCall;
+        const hadPriorCommitState = deps.commitSeenLastPass?.has(sessionId) ?? false;
+        const sawCommitLastPass = deps.commitSeenLastPass?.get(sessionId) ?? false;
+        if (fullFeatureMode && hadPriorCommitState && result.hasRecentCommit && !sawCommitLastPass) {
+          onNoteTrigger(db, sessionId, "commit_detected");
+        }
+        deps.commitSeenLastPass?.set(sessionId, result.hasRecentCommit);
+        logTransformTiming(sessionId, "tagMessages", t0);
+        taggingSucceeded = true;
+      } catch (error) {
+        passOutcome.record("tagging-persistence-failure");
+        sessionLog(sessionId, "transform tag persistence failed; continuing without tagging:", error);
+        try {
+          deps.tagger.cleanup(sessionId);
+        } catch (cleanupError) {
+          sessionLog(sessionId, "tagger cleanup after failure threw:", cleanupError);
+        }
       }
     }
     const t1 = performance.now();
-    const activeTags = getActiveTagsBySession(db, sessionId);
+    const activeTags = compactionOff ? [] : getActiveTagsBySession(db, sessionId);
     logTransformTiming(sessionId, "getActiveTagsBySession", t1, `count=${activeTags.length}`);
     const t1b = performance.now();
     const targetTagNumbers = [...targets.keys()];
-    const targetsSliceTags = getTagsByNumbers(db, sessionId, targetTagNumbers);
+    const targetsSliceTags = compactionOff ? [] : getTagsByNumbers(db, sessionId, targetTagNumbers);
     logTransformTiming(sessionId, "getTagsByNumbers", t1b, `targets=${targetTagNumbers.length} fetched=${targetsSliceTags.length}`);
     let didMutateFromFlushedStatuses = false;
     if (taggingSucceeded) {
@@ -30635,10 +31503,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     }
     const t3 = performance.now();
-    const strippedStructuralNoise = canUseEmptySentinels ? stripStructuralNoise(messages) : 0;
+    const strippedStructuralNoise = canUseEmptySentinels && !compactionOff ? stripStructuralNoise(messages) : 0;
     logTransformTiming(sessionId, "stripStructuralNoise", t3, `strippedParts=${strippedStructuralNoise}`);
     const persistedReasoningWatermark = sessionMeta?.clearedReasoningThroughTag ?? 0;
-    if (persistedReasoningWatermark > 0) {
+    if (persistedReasoningWatermark > 0 && !compactionOff) {
       const tReplay = performance.now();
       const replayed = canUseEmptySentinels ? replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark) : 0;
       const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark);
@@ -30647,7 +31515,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
       logTransformTiming(sessionId, "replayReasoningClearing", tReplay);
     }
-    if (!reducedMode && deps.cavemanTextCompression?.enabled) {
+    if (!reducedMode && !compactionOff && deps.cavemanTextCompression?.enabled) {
       const tCavemanReplay = performance.now();
       const replayedCaveman = replayCavemanCompression(sessionId, db, targets, targetsSliceTags);
       if (replayedCaveman > 0) {
@@ -30656,7 +31524,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "replayCavemanCompression", tCavemanReplay);
     }
     const t4 = performance.now();
-    const strippedClearedReasoning = canUseEmptySentinels ? stripClearedReasoning(messages) : 0;
+    const strippedClearedReasoning = canUseEmptySentinels && !compactionOff ? stripClearedReasoning(messages) : 0;
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
     const watermark = getMaxDroppedTagNumber(db, sessionId);
     const contextUsage = contextUsageEarly;
@@ -30666,6 +31534,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const compartmentPhase = await runCompartmentPhase({
       canRunCompartments,
       fullFeatureMode,
+      compactionOff,
       historianRunnable,
       sessionMeta,
       contextUsage,
@@ -30715,28 +31584,25 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const hardModel = deps.liveModelBySession?.get(sessionId);
     const hardModelKey = hardModel ? `${hardModel.providerID}/${hardModel.modelID}` : "";
     const hardSystemHash = typeof sessionMeta.systemPromptHash === "string" ? sessionMeta.systemPromptHash : "";
-    let hardTtlMs = 5 * 60 * 1000;
-    try {
-      hardTtlMs = parseCacheTtl(sessionMeta.cacheTtl);
-    } catch (error) {
+    const hardCacheExpired = computeHardCacheExpired(sessionMeta.cacheTtl, sessionMeta.lastResponseTime, Date.now(), (error) => {
       passOutcome.record("invalid-cache-ttl-fallback");
       sessionLog(sessionId, "invalid cache_ttl; using the 5m default:", error);
-    }
-    const hardCacheExpired = sessionMeta.lastResponseTime > 0 && Date.now() - sessionMeta.lastResponseTime >= hardTtlMs;
+    });
     const m0HardSignals = {
       systemHash: hardSystemHash,
       modelKey: hardModelKey,
       cacheExpired: hardCacheExpired,
       lastResponseTime: sessionMeta.lastResponseTime
     };
-    const lateActiveRunBlocksMaterialization = getActiveCompartmentRun(sessionId) !== undefined && contextUsageEarly.percentage < FORCE_MATERIALIZE_PERCENTAGE;
+    const lateActiveRunBlocksMaterialization = getActiveCompartmentRun(sessionId) !== undefined && contextUsageEarly.percentage < forceMaterializationPercentage;
     const canConsumeDeferredLate = canConsumeDeferredOnThisPass({
       schedulerDecision: midTurnAdjustedSchedulerDecision,
       contextPercentage: contextUsageEarly.percentage,
       justAwaitedPublication: compartmentPhase.justAwaitedPublication,
-      activeRunBlocksMaterialization: lateActiveRunBlocksMaterialization
+      activeRunBlocksMaterialization: lateActiveRunBlocksMaterialization,
+      forceMaterializationPercentage
     });
-    const wasEmergencyBlock = contextUsageEarly.percentage >= FORCE_MATERIALIZE_PERCENTAGE && compartmentPhase.justAwaitedPublication;
+    const wasEmergencyBlock = contextUsageEarly.percentage >= forceMaterializationPercentage && compartmentPhase.justAwaitedPublication;
     const historyRebuiltThisPass = wasEmergencyBlock ? compartmentPhase.rebuiltHistoryThisPass : rebuiltHistoryFromInitialPrepare || compartmentPhase.rebuiltHistoryThisPass;
     const tPostProcess = performance.now();
     const postTransformResult = await runPostTransformPhase({
@@ -30750,10 +31616,13 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       tagger: deps.tagger,
       ctxReduceAvailability,
       todowriteAvailability,
+      client: deps.client,
+      activeAgent,
       batch,
       contextUsage,
       schedulerDecision,
       fullFeatureMode,
+      compactionOff,
       canRunCompartments,
       awaitedCompartmentRun,
       phaseJustAwaitedPublication: compartmentPhase.justAwaitedPublication,
@@ -30776,7 +31645,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       pendingCompartmentInjection,
       didMutateFromFlushedStatuses,
       watermark,
-      forceMaterializationPercentage: FORCE_MATERIALIZE_PERCENTAGE,
+      forceMaterializationPercentage,
       hasRecentReduceCall,
       projectPath: sessionProjectIdentity,
       sessionDirectory,
@@ -30794,67 +31663,74 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         historyBudgetTokens,
         temporalAwareness: deps.experimentalTemporalAwareness,
         hardSignals: m0HardSignals,
-        muralEnabled: deps.experimentalMuralEnabled
+        muralEnabled: deps.muralEnabled
       }
     });
     passOutcome.markFinalized();
-    const finalWireEstimate = contextUsage.percentage >= 95 ? estimateFinalWireInputTokens({
-      messages,
-      systemPromptTokens: sessionMeta.systemPromptTokens,
-      providerID: modelForBudget?.providerID,
-      modelID: modelForBudget?.modelID,
-      agentName: notificationParams.agent
-    }) : undefined;
-    if (finalWireEstimate) {
-      sessionLog(sessionId, `transform: final-wire telemetry estimate=${finalWireEstimate.tokens} trusted=${finalWireEstimate.trusted} conversation=${finalWireEstimate.messageTokens.conversation} tools=${finalWireEstimate.messageTokens.toolCall} system=${finalWireEstimate.systemTokens} toolDefinitions=${finalWireEstimate.toolDefinitionTokens ?? "unknown"}`);
-    }
-    const currentModelKeyForRecovery = deps.getModelKey?.(sessionId);
-    const overflowStateForFinalWire = getOverflowState(db, sessionId, currentModelKeyForRecovery);
-    const providerProvenLimitTokens = typeof currentModelKeyForRecovery === "string" && currentModelKeyForRecovery.length > 0 && overflowStateForFinalWire.detectedContextLimit > 0 && overflowStateForFinalWire.detectedContextLimitModelKey === currentModelKeyForRecovery ? overflowStateForFinalWire.detectedContextLimit : undefined;
-    const emergencyFailClosed = evaluateEmergencyFailClosed({
-      usagePercentage: contextUsage.percentage,
-      emergencyRecoveryArmed,
-      emergencyRecoveryOrigin,
-      foldMaterializedThisPass: postTransformResult.historianFoldMaterializedThisPass,
-      finalWireEstimate,
-      providerProvenLimitTokens
-    });
-    if (emergencyFailClosed.disarm) {
-      clearEmergencyRecovery(db, sessionId);
-      sessionLog(sessionId, `emergency disarm: trusted final-wire ${emergencyFailClosed.disarm.finalWireTokens} under limit ${emergencyFailClosed.disarm.provenLimitTokens}`);
-    }
-    if (emergencyFailClosed.shouldAbort) {
-      if (!deps.client) {
-        throw new EmergencyFailClosedError("Cannot fail closed: OpenCode client is unavailable");
-      }
-      let notification;
-      try {
-        notification = await sendIgnoredMessage(deps.client, sessionId, "Context full — /ctx-flush or /clear to continue.", notificationParams);
-      } catch (error) {
-        throw new EmergencyFailClosedError("Emergency recovery notification failed", {
-          cause: error
-        });
-      }
-      if (notification !== "sent") {
-        throw new EmergencyFailClosedError(`Emergency recovery notification was ${notification}`);
-      }
-      try {
-        await abortSessionFailClosed(deps.client, sessionId);
-      } catch (error) {
-        sessionLog(sessionId, "transform: emergency fail-closed abort failed; refusing to return a sendable prompt:", getErrorMessage(error));
-        throw new EmergencyFailClosedError("Emergency recovery abort failed", {
-          cause: error
-        });
+    const finalWireTail = describeFinalWireTail(messages);
+    let finalWireEstimate;
+    if (!compactionOff) {
+      finalWireEstimate = contextUsage.percentage >= 95 ? estimateFinalWireInputTokens({
+        messages,
+        systemPromptTokens: sessionMeta.systemPromptTokens,
+        providerID: modelForBudget?.providerID,
+        modelID: modelForBudget?.modelID,
+        agentName: notificationParams.agent
+      }) : undefined;
+      if (finalWireEstimate) {
+        sessionLog(sessionId, `transform: final-wire telemetry estimate=${finalWireEstimate.tokens} trusted=${finalWireEstimate.trusted} conversation=${finalWireEstimate.messageTokens.conversation} tools=${finalWireEstimate.messageTokens.toolCall} system=${finalWireEstimate.systemTokens} toolDefinitions=${finalWireEstimate.toolDefinitionTokens ?? "unknown"} tail=${finalWireTail}`);
+      }
+      const currentModelKeyForRecovery = deps.getModelKey?.(sessionId);
+      const overflowStateForFinalWire = getOverflowState(db, sessionId, currentModelKeyForRecovery);
+      const providerProvenLimitTokens = typeof currentModelKeyForRecovery === "string" && currentModelKeyForRecovery.length > 0 && overflowStateForFinalWire.detectedContextLimit > 0 && overflowStateForFinalWire.detectedContextLimitModelKey === currentModelKeyForRecovery ? overflowStateForFinalWire.detectedContextLimit : undefined;
+      const emergencyFailClosed = evaluateEmergencyFailClosed({
+        usagePercentage: contextUsage.percentage,
+        emergencyRecoveryArmed,
+        emergencyRecoveryOrigin,
+        foldMaterializedThisPass: postTransformResult.historianFoldMaterializedThisPass,
+        finalWireEstimate,
+        providerProvenLimitTokens
+      });
+      if (emergencyFailClosed.disarm) {
+        clearEmergencyRecovery(db, sessionId);
+        sessionLog(sessionId, `emergency disarm: trusted final-wire ${emergencyFailClosed.disarm.finalWireTokens} under limit ${emergencyFailClosed.disarm.provenLimitTokens}`);
       }
-      try {
-        clearEmergencyDropSample(db, sessionId);
-      } catch (error) {
-        throw new EmergencyFailClosedError("Emergency recovery cleanup failed", {
-          cause: error
-        });
+      if (emergencyFailClosed.shouldAbort) {
+        if (!deps.client) {
+          throw new EmergencyFailClosedError("Cannot fail closed: OpenCode client is unavailable");
+        }
+        let notification;
+        try {
+          notification = await sendIgnoredMessage(deps.client, sessionId, "Context full — /ctx-flush or /clear to continue.", notificationParams);
+        } catch (error) {
+          throw new EmergencyFailClosedError("Emergency recovery notification failed", {
+            cause: error
+          });
+        }
+        if (notification !== "sent" && notification !== "queued") {
+          throw new EmergencyFailClosedError(`Emergency recovery notification was ${notification}`);
+        }
+        try {
+          await abortSessionFailClosed(deps.client, sessionId);
+        } catch (error) {
+          sessionLog(sessionId, "transform: emergency fail-closed abort failed; refusing to return a sendable prompt:", getErrorMessage(error));
+          throw new EmergencyFailClosedError("Emergency recovery abort failed", {
+            cause: error
+          });
+        }
+        try {
+          clearEmergencyDropSample(db, sessionId);
+        } catch (error) {
+          throw new EmergencyFailClosedError("Emergency recovery cleanup failed", {
+            cause: error
+          });
+        }
+        sessionLog(sessionId, `EMERGENCY: fail-closed (reason=${emergencyFailClosed.reason}, recoveryOrigin=${emergencyRecoveryOrigin ?? "unknown"}, finalEstimate=${finalWireEstimate?.tokens ?? "unavailable"}, estimateTrusted=${finalWireEstimate?.trusted ?? false}, syntheticUsage=${usagePercentageSynthetic})`);
+        return;
       }
-      sessionLog(sessionId, `EMERGENCY: fail-closed (reason=${emergencyFailClosed.reason}, recoveryOrigin=${emergencyRecoveryOrigin ?? "unknown"}, finalEstimate=${finalWireEstimate?.tokens ?? "unavailable"}, estimateTrusted=${finalWireEstimate?.trusted ?? false}, syntheticUsage=${usagePercentageSynthetic})`);
-      return;
+    }
+    if (!finalWireEstimate) {
+      sessionLog(sessionId, `transform: final-wire telemetry estimate=unavailable trusted=false conversation=unknown tools=unknown system=unknown toolDefinitions=unknown tail=${finalWireTail}`);
     }
     if (passOutcome.captureEligible) {
       const keys = resolveLkgModelKeys(messages);
@@ -30930,7 +31806,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         sessionLog(sessionId, "conversation_tokens UPDATE failed:", error);
       }
     }
-    if (ctxReduceCallable && deps.channel1StateBySession) {
+    if (ctxReduceCallable && !compactionOff && deps.channel1StateBySession) {
       try {
         const resolvedExecuteThresholdPct = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, deps.getModelKey?.(sessionId), 65, {
           tokensConfig: deps.executeThresholdTokens,
@@ -31119,15 +31995,22 @@ function createEventHandler2(deps) {
         const sessionMeta = getOrCreateSessionMeta(deps.db, errInfo.sessionID);
         if (sessionMeta.isSubagent) {
           if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
-            recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit);
+            recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit, undefined, detection.reportedLimitProvenance);
           }
-          sessionLog(errInfo.sessionID, `overflow detected on subagent: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (subagents cannot run historian)`);
+          sessionLog(errInfo.sessionID, `overflow detected on subagent: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (subagents cannot run historian)`);
           return;
         }
         const existing = getOverflowState(deps.db, errInfo.sessionID);
+        if (deps.compactionOff) {
+          if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
+            recordDetectedContextLimit(deps.db, errInfo.sessionID, detection.reportedLimit, undefined, detection.reportedLimitProvenance);
+          }
+          sessionLog(errInfo.sessionID, `overflow detected in compaction-off mode: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only (recovery disarmed; native compaction owns the window)`);
+          return;
+        }
         dropSlot(errInfo.sessionID, "overflow-recovery-arm");
-        recordOverflowDetected(deps.db, errInfo.sessionID, detection.reportedLimit);
-        sessionLog(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
+        recordOverflowDetected(deps.db, errInfo.sessionID, detection.reportedLimit, undefined, "provider_overflow", detection.reportedLimitProvenance);
+        sessionLog(errInfo.sessionID, `overflow detected via session.error: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} (previousRecovery=${existing.needsEmergencyRecovery})`);
         deps.onSessionCacheInvalidated?.(errInfo.sessionID);
       } catch (error) {
         sessionLog(errInfo.sessionID, "event session.error handling failed:", error);
@@ -31169,13 +32052,18 @@ function createEventHandler2(deps) {
             const metaForOverflow = getOrCreateSessionMeta(deps.db, info.sessionID);
             if (metaForOverflow.isSubagent) {
               if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
-                recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey);
+                recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
+              }
+              sessionLog(info.sessionID, `overflow detected on subagent via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
+            } else if (deps.compactionOff) {
+              if (typeof detection.reportedLimit === "number" && detection.reportedLimit > 0) {
+                recordDetectedContextLimit(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, detection.reportedLimitProvenance);
               }
-              sessionLog(info.sessionID, `overflow detected on subagent via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
+              sessionLog(info.sessionID, `overflow detected in compaction-off mode via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"} — recorded limit only`);
             } else {
               dropSlot(info.sessionID, "overflow-recovery-arm");
-              recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey);
-              sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} pattern=${detection.matchedPattern ?? "n/a"}`);
+              recordOverflowDetected(deps.db, info.sessionID, detection.reportedLimit, overflowModelKey, "provider_overflow", detection.reportedLimitProvenance);
+              sessionLog(info.sessionID, `overflow detected via message.updated: reportedLimit=${detection.reportedLimit ?? "unknown"} provenance=${detection.reportedLimitProvenance ?? "n/a"} pattern=${detection.matchedPattern ?? "n/a"}`);
               deps.onSessionCacheInvalidated?.(info.sessionID);
             }
           } catch (error) {
@@ -31274,7 +32162,7 @@ function createEventHandler2(deps) {
       } catch (error) {
         sessionLog(info.sessionID, "event message.updated persistence failed:", error);
       }
-      if ((info.finish === "stop" || info.finish === "tool-calls") && deps.client && deps.channel1StateBySession) {
+      if ((info.finish === "stop" || info.finish === "tool-calls") && deps.client && deps.channel1StateBySession && !deps.compactionOff) {
         deliverChannel2IfPending(deps, info.sessionID);
       }
       return;
@@ -31916,11 +32804,15 @@ function createEventHook(args) {
       args.deferredMaterializationSessions.delete(sessionId);
       args.lastHeuristicsTurnId.delete(sessionId);
       args.commitSeenLastPass?.delete(sessionId);
+      clearIgnoredMessages(sessionId);
       resetNoteNudgeCooldownOnly(sessionId);
       clearAutoSearchForSession(sessionId);
       clearSidebarSnapshotCache(sessionId);
       clearSessionTracking(sessionId);
     }
+    if (input.event.type !== "session.deleted") {
+      await flushIgnoredMessages(sessionId);
+    }
   };
 }
 function createCommandExecuteBeforeHook(commandHandler) {
@@ -31980,6 +32872,7 @@ function createToolExecuteAfterHook(args) {
     if (!typedInput.sessionID || !typedInput.tool) {
       return;
     }
+    await flushIgnoredMessages(typedInput.sessionID);
     if (typedInput.tool === "ctx_reduce") {
       const state = args.channel1StateBySession.get(typedInput.sessionID);
       if (state)
@@ -32000,6 +32893,19 @@ function createToolExecuteAfterHook(args) {
       const todowriteVerdict = resolveTodowriteAvailability(typedInput.sessionID);
       if (todowriteVerdict.frozen && !todowriteVerdict.callable)
         return;
+      const activeAgent = typedInput.agent;
+      if (args.client) {
+        try {
+          if (await todowritePermissionDenied(args.client, typedInput.sessionID, activeAgent)) {
+            return;
+          }
+        } catch (error) {
+          if (cachedToolPermissionDenied(typedInput.sessionID, "todowrite")) {
+            return;
+          }
+          sessionLog(typedInput.sessionID, "todowrite permission read failed during capture (ignored):", error);
+        }
+      }
       const todoArgs = typedInput.args;
       const todos = todoArgs?.todos;
       const sessionMeta = Array.isArray(todos) ? getOrCreateSessionMeta(args.db, typedInput.sessionID) : null;
@@ -32424,14 +33330,24 @@ function createMagicContextHook(deps) {
       const reason = (opened ? getDatabasePersistenceError(opened) : null) ?? "Failed to initialize the persistent SQLite database.";
       log("[magic-context] disabling feature because persistent storage is unavailable:", reason);
       notifyMagicContextDisabled(deps.client, reason);
+      const migration = getMigrationOnOpenRefusal();
+      const blockingProcesses = migration?.serverPids.map((pid) => ({ harness: "OpenCode server", pid })) ?? [];
       const fence = getSchemaFenceRejection();
       recordHookInitFailure({
         type: "storage",
-        reason: fence ? {
+        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: reason }
+        } : {
+          kind: "storage_failure",
+          cause: migration?.unreadableFile ? `migration guard could not read RPC discovery file ${migration.unreadableFile}` : reason
+        }
       });
       return null;
     }
@@ -32447,9 +33363,9 @@ function createMagicContextHook(deps) {
     });
     return null;
   }
-  const projectPath = resolveProjectIdentityForSession(deps.directory);
+  const projectPath = resolveProjectIdentityForSession(deps.directory, deps.config.allow_home_project);
   if (!projectPath) {
-    log("[magic-context] not binding a project identity for the user's home directory");
+    log("[magic-context] not binding a project identity for this directory");
     clearHookInitFailure();
     recordHookInitFailure({ type: "no_project" });
     return null;
@@ -32488,6 +33404,7 @@ function createMagicContextHook(deps) {
   const sessionDirectoryBySession = deps.liveSessionState?.sessionDirectoryBySession ?? new Map;
   const internalChildSessions = deps.liveSessionState?.internalChildSessions ?? new Set;
   const recompProgressBySession = deps.liveSessionState?.recompProgressBySession ?? new Map;
+  const dreamerProgressByProject = deps.liveSessionState?.dreamerProgressByProject ?? new Map;
   const channel1StateBySession = new Map;
   const channel2DirectiveTextBySession = new Map;
   const resolveLiveModel = (sessionId) => {
@@ -32513,6 +33430,7 @@ function createMagicContextHook(deps) {
   const dreamerRunnable = isDreamerRunnable(deps.config);
   const dreamerConfig = dreamerRunnable ? deps.config.dreamer : undefined;
   const historianRunnable = isHistorianRunnable(deps.config);
+  const compactionOff = !isCompactionEnabled(deps.config);
   const buildManagedRecompCtx = (sessionId) => ({
     client: deps.client,
     db,
@@ -32527,6 +33445,7 @@ function createMagicContextHook(deps) {
       deferredMaterializationSessions,
       sessionDirectoryBySession,
       recompProgressBySession,
+      dreamerProgressByProject,
       internalChildSessions
     },
     directory: deps.directory,
@@ -32573,7 +33492,7 @@ function createMagicContextHook(deps) {
       return "Embedding is already running for this session.";
     }
     await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-    const sessionProjectIdentity = resolveProjectIdentityForSession(directory);
+    const sessionProjectIdentity = resolveProjectIdentityForSession(directory, deps.config.allow_home_project);
     if (!sessionProjectIdentity)
       return "No project identity is bound for the home directory.";
     maybeSendProjectIdentitySessionWarning(sessionId, directory);
@@ -32641,7 +33560,7 @@ function createMagicContextHook(deps) {
     if (ctrl)
       ctrl.abort();
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentityForSession(directory);
+    const sessionProjectIdentity = resolveProjectIdentityForSession(directory, deps.config.allow_home_project);
     if (!sessionProjectIdentity)
       return "No project identity is bound for the home directory.";
     maybeSendProjectIdentitySessionWarning(sessionId, directory);
@@ -32650,7 +33569,7 @@ function createMagicContextHook(deps) {
   };
   const getEmbedStatusText = (sessionId) => {
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentityForSession(directory);
+    const sessionProjectIdentity = resolveProjectIdentityForSession(directory, deps.config.allow_home_project);
     if (!sessionProjectIdentity)
       return "No project identity is bound for the home directory.";
     maybeSendProjectIdentitySessionWarning(sessionId, directory);
@@ -32676,7 +33595,7 @@ function createMagicContextHook(deps) {
       try {
         await new Promise((resolve3) => setTimeout(resolve3, 0));
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-        const sessionProjectIdentity = resolveProjectIdentityForSession(directory);
+        const sessionProjectIdentity = resolveProjectIdentityForSession(directory, deps.config.allow_home_project);
         if (!sessionProjectIdentity)
           return;
         maybeSendProjectIdentitySessionWarning(sessionId, directory);
@@ -32909,6 +33828,7 @@ function createMagicContextHook(deps) {
     internalChildSessions,
     client: deps.client,
     directory: deps.directory,
+    allowHomeProject: deps.config.allow_home_project,
     injectDocs: deps.config.dreamer?.inject_docs !== false,
     memoryConfig: deps.config.memory ? {
       enabled: deps.config.memory.enabled,
@@ -32933,9 +33853,10 @@ function createMagicContextHook(deps) {
     },
     projectPath,
     historianRunnable,
+    compactionOff,
     experimentalUserMemories: userMemoryCollectionEnabled(dreamerConfig),
     experimentalTemporalAwareness: deps.config.temporal_awareness === true,
-    experimentalMuralEnabled: deps.config.experimental?.mural?.enabled === true,
+    muralEnabled: deps.config.mural?.enabled === true,
     historianTwoPass: deps.config.historian?.two_pass === true,
     liveModelBySession,
     sessionDirectoryBySession,
@@ -32946,7 +33867,7 @@ function createMagicContextHook(deps) {
       directory: deps.directory,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     } : undefined,
-    cavemanTextCompression: deps.config.caveman_text_compression?.enabled === true ? {
+    cavemanTextCompression: compactionOff ? undefined : deps.config.caveman_text_compression?.enabled === true ? {
       enabled: true,
       minChars: deps.config.caveman_text_compression.min_chars ?? 500
     } : undefined,
@@ -32962,6 +33883,7 @@ function createMagicContextHook(deps) {
     contextUsageMap,
     compactionHandler: deps.compactionHandler,
     config: deps.config,
+    compactionOff,
     tagger: deps.tagger,
     db,
     client: deps.client,
@@ -32982,6 +33904,7 @@ function createMagicContextHook(deps) {
       transform.clearRustSession(sessionId);
       systemPromptHash.clearSession(sessionId);
       lastHeuristicsTurnId.delete(sessionId);
+      clearToolPermissionDenied(sessionId);
       commitSeenLastPass.delete(sessionId);
       variantBySession.delete(sessionId);
       liveModelBySession.delete(sessionId);
@@ -33027,7 +33950,14 @@ function createMagicContextHook(deps) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreaming),
       language: deps.config.language,
       transformMode: deps.config.transform_mode,
-      moduleClient: rustModeModuleClient
+      moduleClient: rustModeModuleClient,
+      onProgress: (progress, completedTask) => {
+        if (progress) {
+          dreamerProgressByProject.set(projectPath, progress);
+        } else if (dreamerProgressByProject.get(projectPath)?.task === completedTask) {
+          dreamerProgressByProject.delete(projectPath);
+        }
+      }
     });
     runDueTasksForProject({
       db,
@@ -33041,6 +33971,7 @@ function createMagicContextHook(deps) {
   const commandHandler = createMagicContextCommandHandler({
     db,
     protectedTags: deps.config.protected_tags,
+    compactionOff,
     toastDurationMs: deps.config.toast_duration_ms,
     executeThresholdPercentage: deps.config.execute_threshold_percentage ?? 65,
     executeThresholdTokens: deps.config.execute_threshold_tokens,
@@ -33053,6 +33984,7 @@ function createMagicContextHook(deps) {
       const model = resolveLiveModel(sessionId);
       return model ? `${model.providerID}/${model.modelID}` : undefined;
     },
+    getDreamerProgress: () => dreamerProgressByProject.get(projectPath) ?? null,
     getContextLimit: (sessionId) => {
       const model = resolveLiveModel(sessionId);
       if (!model)
@@ -33100,10 +34032,17 @@ function createMagicContextHook(deps) {
           }),
           userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreamerConfig),
           language: deps.config.language,
-          experimentalMural: deps.config.experimental?.mural,
+          mural: deps.config.mural,
           memoryInjectionBudgetTokens: deps.config.memory?.injection_budget_tokens,
           transformMode: deps.config.transform_mode,
-          moduleClient: rustModeModuleClient
+          moduleClient: rustModeModuleClient,
+          onProgress: (progress, completedTask) => {
+            if (progress) {
+              dreamerProgressByProject.set(projectPath, progress);
+            } else if (dreamerProgressByProject.get(projectPath)?.task === completedTask) {
+              dreamerProgressByProject.delete(projectPath);
+            }
+          }
         }),
         task
       })
@@ -33184,6 +34123,7 @@ function createMagicContextHook(deps) {
     "tool.execute.after": createToolExecuteAfterHook({
       db,
       channel1StateBySession,
+      client: deps.client,
       transformMode: deps.config.transform_mode,
       todoStateSet: deps.config.transform_mode === "rust" && rustModeModuleClient ? ({ sessionId, stateJson, ownerMessageId }) => rustModeModuleClient.call({
         sessionId,
@@ -33279,15 +34219,30 @@ function createMessagesTransformHandler(args) {
     const sessionId = resolveSessionId2(output);
     const agent = resolveAgentNameFromMessages(output.messages);
     const isInternalChild = typeof sessionId === "string" && sessionId.length > 0 && args.internalChildSessions?.has(sessionId) === true;
+    const compactionOffInputSnapshot = args.compactionOff ? [...output.messages] : null;
+    const restoreCompactionOffInput = () => {
+      if (compactionOffInputSnapshot && output.messages !== compactionOffInputSnapshot) {
+        output.messages.splice(0, output.messages.length, ...compactionOffInputSnapshot);
+      }
+    };
     if (args.failClosed) {
-      await args.failClosed.enforce({
-        blockingEnabled: args.failClosedBlockingEnabled !== false,
-        exempt: shouldBypassFailClosedBlock({
-          agent,
-          isInternalChildSession: isInternalChild
-        }),
-        tryReopen: args.tryReopenStorage
-      });
+      try {
+        await args.failClosed.enforce({
+          blockingEnabled: args.failClosedBlockingEnabled !== false,
+          exempt: shouldBypassFailClosedBlock({
+            agent,
+            isInternalChildSession: isInternalChild
+          }),
+          tryReopen: args.tryReopenStorage
+        });
+      } catch (error) {
+        if (args.compactionOff && isFailClosedBlockingError(error)) {
+          log(`[magic-context] compaction-off: fail-closed inert, passing through: ${error.message}`);
+          restoreCompactionOffInput();
+          return output.messages;
+        }
+        throw error;
+      }
     }
     const magicContext = args.getMagicContext ? args.getMagicContext() : args.magicContext;
     const slotAtEntry = sessionId ? getSlot(sessionId) : undefined;
@@ -33304,9 +34259,15 @@ function createMessagesTransformHandler(args) {
       return output.messages;
     } catch (error) {
       if (error instanceof EmergencyFailClosedError || isFailClosedBlockingError(error)) {
-        throw error;
+        if (!args.compactionOff)
+          throw error;
+        log(`[magic-context] compaction-off: fail-closed inert, passing through: ${error instanceof Error ? error.message : String(error)}`);
+        restoreCompactionOffInput();
+        return output.messages;
       }
-      if (sessionId && slotAtEntry && !entry) {
+      if (args.compactionOff) {
+        restoreCompactionOffInput();
+      } else if (sessionId && slotAtEntry && !entry) {
         dropSlot(sessionId, "lkg_invalidated_reshape");
         sessionLog(sessionId, "lkg_invalidated_reshape");
       } else if (sessionId && entry) {
@@ -33348,6 +34309,7 @@ function createMessagesTransformHandler(args) {
       const isTransient = typeof code === "string" && TRANSIENT_SQLITE_CODES.has(code);
       if (isTransient) {
         log(`[magic-context] transform skipped this pass — ${code} (transient; retrying next pass): ${message}`);
+        restoreCompactionOffInput();
         return output.messages;
       }
       log(`[magic-context] transform FAILED code=${code ?? "none"} name=${name ?? "none"}: ${message}. Continuing with unmodified messages for this pass.`, error);
@@ -33369,6 +34331,7 @@ function createMessagesTransformHandler(args) {
         }
       }
     }
+    restoreCompactionOffInput();
     return output.messages;
   };
 }
@@ -33601,21 +34564,11 @@ async function loadRustSessionStatus(client, sessionId, directory) {
     return;
   }
 }
-function parseTtlString(ttl) {
-  const match = ttl.match(/^(\d+)(s|m|h)$/);
-  if (!match)
+function safeParseTtl(ttl) {
+  try {
+    return parseCacheTtl(ttl);
+  } catch {
     return 5 * 60 * 1000;
-  const val = Number.parseInt(match[1], 10);
-  const unit = match[2];
-  switch (unit) {
-    case "s":
-      return val * 1000;
-    case "m":
-      return val * 60 * 1000;
-    case "h":
-      return val * 3600 * 1000;
-    default:
-      return 5 * 60 * 1000;
   }
 }
 function resolveConfigValue(cfg, key, modelKey, defaultValue) {
@@ -33638,7 +34591,7 @@ function resolveConfigValue(cfg, key, modelKey, defaultValue) {
   }
   return defaultValue;
 }
-function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus) {
+function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus, compactionEnabled = true) {
   try {
     const projectIdentity = resolveProjectIdentity(directory);
     const meta = db.prepare("SELECT * FROM session_meta WHERE session_id = ?").get(sessionId);
@@ -33659,7 +34612,8 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const cacheTtl = meta ? String(meta.cache_ttl ?? "5m") : "5m";
     const memoryBlockCount = meta ? Number(meta.memory_block_count ?? 0) : 0;
     const compartmentRow = db.prepare("SELECT COUNT(*) as count FROM compartments WHERE session_id = ?").get(sessionId);
-    const compartmentCount = typeof moduleStatus?.compartment_count === "number" ? moduleStatus.compartment_count : compartmentRow?.count ?? 0;
+    const archivedCompartmentCount = compartmentRow?.count ?? 0;
+    const compartmentCount = typeof moduleStatus?.compartment_count === "number" ? moduleStatus.compartment_count : archivedCompartmentCount;
     let memoryCount = 0;
     if (projectIdentity) {
       const memRow = db.prepare("SELECT COUNT(*) as count FROM memories WHERE project_path = ? AND status = 'active'").get(projectIdentity);
@@ -33700,6 +34654,13 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const docsTokens = m0Blocks.docsTokens;
     const profileTokens = m0Blocks.profileTokens;
     let lastDreamerRunAt = null;
+    let dreamerBacklog;
+    const dreamerProgress = projectIdentity ? liveSessionState?.dreamerProgressByProject?.get(projectIdentity) ?? null : null;
+    if (projectIdentity) {
+      try {
+        dreamerBacklog = getDreamTaskBacklogs(db, projectIdentity, CANONICAL_DREAM_TASKS);
+      } catch {}
+    }
     if (projectIdentity) {
       try {
         lastDreamerRunAt = getMostRecentTaskRunAt(db, projectIdentity);
@@ -33754,6 +34715,12 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       executeThreshold = thresholdDetail.percentage;
       executeThresholdClamped = thresholdDetail.clamped === true;
     }
+    const nativeContextLimit = activeProviderID && activeModelID ? resolveContextLimit(activeProviderID, activeModelID, {
+      db,
+      sessionID: sessionId,
+      reservation: "none"
+    }) : contextLimit;
+    const nativeContextUsagePercentage = nativeContextLimit > 0 ? effectiveInputTokens / nativeContextLimit * 100 : undefined;
     const calibration = resolveModelCalibration(activeProviderID, activeModelID);
     const calibrated = calibrateBuckets({
       inputTokens: effectiveInputTokens,
@@ -33773,8 +34740,11 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       usagePercentage: effectiveUsagePercentage,
       inputTokens: effectiveInputTokens,
       contextLimit,
+      native_context_usage_percentage: nativeContextUsagePercentage,
+      compaction_enabled: compactionEnabled,
       systemPromptTokens: calibrated.systemTokens,
       compartmentCount,
+      archivedCompartmentCount,
       memoryCount,
       memoryBlockCount,
       pendingOpsCount,
@@ -33783,8 +34753,11 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       sessionNoteCount,
       readySmartNoteCount,
       cacheTtl,
+      lastTransformError: meta?.last_transform_error ? String(meta.last_transform_error) : null,
       lastDreamerRunAt,
       projectIdentity,
+      dreamerBacklog,
+      dreamerProgress,
       compartmentTokens: calibrated.compartmentTokens,
       factTokens: calibrated.factTokens,
       memoryTokens: calibrated.memoryTokens,
@@ -33821,15 +34794,15 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     throw err;
   }
 }
-function buildSidebarSnapshotRpcResponse(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus) {
+function buildSidebarSnapshotRpcResponse(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus, compactionEnabled = true) {
   try {
-    return buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus);
+    return buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus, compactionEnabled);
   } catch {
     return { error: "sidebar snapshot unavailable" };
   }
 }
-function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessionState, injectionBudgetTokens, moduleStatus) {
-  const base = buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus);
+function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessionState, injectionBudgetTokens, moduleStatus, compactionEnabled = true) {
+  const base = buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus, compactionEnabled);
   const detail = {
     ...base,
     tagCounter: 0,
@@ -33846,6 +34819,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     cacheTtlMs: 0,
     cacheRemainingMs: 0,
     cacheExpired: false,
+    cacheNeverExpires: false,
     executeThreshold: 65,
     executeThresholdMode: "percentage",
     protectedTagCount: 20,
@@ -33854,9 +34828,17 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     compressionBudget: null,
     compressionUsage: null,
     toastDurationMs: 5000,
-    mural: undefined
+    mural: undefined,
+    storage_versions: {
+      context_db_schema_version: null,
+      plugin_supported_version: LATEST_SUPPORTED_VERSION
+    }
   };
   try {
+    detail.storage_versions = {
+      context_db_schema_version: getPersistedSchemaVersion(db),
+      plugin_supported_version: LATEST_SUPPORTED_VERSION
+    };
     const muralConfig = config?.experimental?.mural;
     if (muralConfig?.enabled && base.projectIdentity) {
       const row = getMural(db, base.projectIdentity);
@@ -33915,11 +34897,20 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     } else if (base.usagePercentage > 0) {
       detail.contextLimit = Math.round(base.inputTokens / (base.usagePercentage / 100));
     }
-    detail.cacheTtlMs = parseTtlString(detail.cacheTtl);
+    detail.cacheTtlMs = safeParseTtl(detail.cacheTtl);
+    if (detail.cacheTtlMs === Number.POSITIVE_INFINITY) {
+      detail.cacheNeverExpires = true;
+      detail.cacheTtlMs = -1;
+    }
     if (detail.lastResponseTime > 0) {
       const elapsed = Date.now() - detail.lastResponseTime;
-      detail.cacheRemainingMs = Math.max(0, detail.cacheTtlMs - elapsed);
-      detail.cacheExpired = detail.cacheRemainingMs === 0;
+      if (detail.cacheNeverExpires) {
+        detail.cacheRemainingMs = -1;
+        detail.cacheExpired = false;
+      } else {
+        detail.cacheRemainingMs = Math.max(0, detail.cacheTtlMs - elapsed);
+        detail.cacheExpired = detail.cacheRemainingMs === 0;
+      }
     }
     try {
       const histTokens = base.compartmentTokens + base.factTokens;
@@ -33957,6 +34948,7 @@ function buildEmbedDetail(db, sessionId, dir, liveSessionState) {
 }
 function registerRpcHandlers(rpcServer, args) {
   const { directory, config, liveSessionState, rustModeModuleClient } = args;
+  const compactionEnabled = isCompactionEnabled(config);
   const rawConfig = config;
   const getNotificationParams = (sessionId) => getLiveNotificationParams(sessionId, liveSessionState.liveModelBySession, liveSessionState.variantBySession, liveSessionState.agentBySession, config.toast_duration_ms);
   const injectionBudgetTokens = config.memory?.injection_budget_tokens;
@@ -33967,7 +34959,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db || !sessionId)
       return { error: "unavailable" };
     const moduleStatus = config.transform_mode === "rust" ? await loadRustSessionStatus(rustModeModuleClient, sessionId, dir) : undefined;
-    return buildSidebarSnapshotRpcResponse(db, sessionId, dir, liveSessionState, injectionBudgetTokens, rawConfig, moduleStatus);
+    return buildSidebarSnapshotRpcResponse(db, sessionId, dir, liveSessionState, injectionBudgetTokens, rawConfig, moduleStatus, compactionEnabled);
   });
   rpcServer.handle("status-detail", async (params) => {
     const sessionId = String(params.sessionId ?? "");
@@ -33977,7 +34969,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db || !sessionId)
       return { error: "unavailable" };
     const moduleStatus = config.transform_mode === "rust" ? await loadRustSessionStatus(rustModeModuleClient, sessionId, dir) : undefined;
-    return buildStatusDetail(db, sessionId, dir, modelKey, rawConfig, liveSessionState, injectionBudgetTokens, moduleStatus);
+    return buildStatusDetail(db, sessionId, dir, modelKey, rawConfig, liveSessionState, injectionBudgetTokens, moduleStatus, compactionEnabled);
   });
   rpcServer.handle("embed-detail", async (params) => {
     const sessionId = String(params.sessionId ?? "");
@@ -34005,9 +34997,9 @@ function registerRpcHandlers(rpcServer, args) {
     }
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-e9j09sjr.js");
+    const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await import("./derive-budgets-9crp0cvd.js");
     const { resolveFallbackChain: resolveFallbackChain2 } = await import("./resolve-fallbacks-5n5tvge1.js");
-    const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-5nx3qfz8.js");
+    const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-gbp7r23g.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
     return {
       client: args.client,
@@ -34032,8 +35024,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-2yb2hfh2.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-tghq9gnh.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedRecomp2(ctx, sessionId).then((message) => {
@@ -34048,8 +35040,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-2yb2hfh2.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-tghq9gnh.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedUpgrade2(ctx, sessionId).then((message) => {
@@ -34065,7 +35057,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-td6bwtky.js");
+      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-xt41zbw4.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -34169,7 +35161,7 @@ Two recovery modes for finer detail:
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
 // src/tools/ctx-expand/render.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function roleLabel(role) {
@@ -34198,15 +35190,15 @@ function keyArg(input) {
 function asToolPart(part) {
   const type = typeof part.type === "string" ? part.type : "";
   if (type === "tool") {
-    const state = isRecord3(part.state) ? part.state : null;
+    const state = isRecord4(part.state) ? part.state : null;
     const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
-    const metadata = state && isRecord3(state.metadata) ? state.metadata : null;
+    const metadata = state && isRecord4(state.metadata) ? state.metadata : null;
     const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
     return {
       name: typeof part.tool === "string" ? part.tool : "tool",
       callId: typeof part.callID === "string" ? part.callID : "",
       title,
-      input: state && isRecord3(state.input) ? state.input : null,
+      input: state && isRecord4(state.input) ? state.input : null,
       output
     };
   }
@@ -34215,7 +35207,7 @@ function asToolPart(part) {
       name: typeof part.name === "string" ? part.name : "tool",
       callId: typeof part.id === "string" ? part.id : "",
       title: null,
-      input: isRecord3(part.input) ? part.input : null,
+      input: isRecord4(part.input) ? part.input : null,
       output: null
     };
   }
@@ -34244,7 +35236,7 @@ function reasoningOf(part) {
   return null;
 }
 function renderPartPreview(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -34268,7 +35260,7 @@ function renderPartPreview(part) {
   return `    • [${type}]`;
 }
 function renderPartFull(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -35774,6 +36766,8 @@ function createToolRegistry(args) {
   if (pluginConfig.enabled !== true) {
     return {};
   }
+  const compactionOff = !isCompactionEnabled(pluginConfig);
+  setCtxReduceRegisteredGlobally(!compactionOff);
   let db;
   try {
     const opened = openDatabase();
@@ -35791,10 +36785,10 @@ function createToolRegistry(args) {
   ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db).catch((error) => {
     log(`[magic-context] embedding registration skipped: ${getErrorMessage(error)}`);
   });
-  const resolveProjectPath = (directory) => resolveProjectIdentityForSession(directory);
+  const resolveProjectPath = (directory) => resolveProjectIdentityForSession(directory, pluginConfig.allow_home_project);
   const memoryEnabled = pluginConfig.memory?.enabled !== false;
   const allTools = {
-    ...createCtxReduceTools({
+    ...compactionOff ? {} : createCtxReduceTools({
       db,
       protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
       rustToolBackends
@@ -35859,64 +36853,6 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
-
-// src/shared/rpc-utils.ts
-import { createHash as createHash14 } from "node:crypto";
-import { join as join7 } from "node:path";
-function projectHash(directory) {
-  const normalized = directory.replace(/\/+$/, "");
-  return createHash14("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-function rpcPortDir(storageDir, directory) {
-  return join7(storageDir, "rpc", projectHash(directory));
-}
-function rpcPortFilePath(storageDir, directory, pid = process.pid, instanceId) {
-  const suffix = instanceId ? `-${instanceId}` : "";
-  return join7(rpcPortDir(storageDir, directory), `port-${pid}${suffix}.json`);
-}
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function parseRpcPortFile(content, fallbackPid = 0) {
-  const trimmed = content.trim();
-  if (!trimmed)
-    return null;
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      const port2 = Number(parsed.port);
-      const pid = Number(parsed.pid);
-      const startedAt = Number(parsed.started_at);
-      if (!isValidPort(port2) || !Number.isInteger(pid) || pid <= 0)
-        return null;
-      return {
-        port: port2,
-        pid,
-        started_at: Number.isFinite(startedAt) ? startedAt : 0,
-        token: typeof parsed.token === "string" ? parsed.token : undefined,
-        instance_id: typeof parsed.instance_id === "string" ? parsed.instance_id : undefined
-      };
-    } catch {
-      return null;
-    }
-  }
-  const port = Number.parseInt(trimmed, 10);
-  if (!isValidPort(port))
-    return null;
-  return { port, pid: fallbackPid, started_at: 0 };
-}
-function isValidPort(port) {
-  return Number.isInteger(port) && port > 0 && port <= 65535;
-}
-
-// src/shared/rpc-server.ts
 var MAX_BODY_BYTES = 1048576;
 var WS_AUTH_TIMEOUT_MS = 5000;
 var WS_CLOSE_UNAUTHORIZED = 4401;
@@ -35991,10 +36927,15 @@ class MagicContextRpcServer {
     try {
       this.warnIfOtherLiveInstance();
       const dir = dirname5(this.portFilePath);
-      mkdirSync3(dir, { recursive: true, mode: 448 });
-      try {
-        chmodSync(dir, 448);
-      } catch {}
+      const enforcePrivatePermissions = shouldEnforcePrivateStoragePermissions();
+      if (enforcePrivatePermissions) {
+        mkdirSync3(dir, { recursive: true, mode: 448 });
+        try {
+          chmodSync(dir, 448);
+        } catch {}
+      } else {
+        mkdirSync3(dir, { recursive: true });
+      }
       const tmpPath = `${this.portFilePath}.tmp`;
       try {
         rmSync3(tmpPath, { force: true });
@@ -36005,11 +36946,13 @@ class MagicContextRpcServer {
         started_at: this.startedAt,
         token: this.token,
         instance_id: this.instanceId
-      }), { encoding: "utf-8", mode: 384 });
+      }), enforcePrivatePermissions ? { encoding: "utf-8", mode: 384 } : { encoding: "utf-8" });
       renameSync4(tmpPath, this.portFilePath);
-      try {
-        chmodSync(this.portFilePath, 384);
-      } catch {}
+      if (enforcePrivatePermissions) {
+        try {
+          chmodSync(this.portFilePath, 384);
+        } catch {}
+      }
       log(`[rpc] server listening on 127.0.0.1:${this.port}`);
     } catch (err) {
       log(`[rpc] failed to write port file: ${err}`);
@@ -36186,6 +37129,7 @@ var server = async (ctx) => {
       ...pluginConfig.configWarnings ?? []
     ];
   }
+  setStoragePrivatePermissionEnforcement(pluginConfig.storage.enforce_private_permissions);
   setSqlitePragmaConfig({
     cacheSizeMb: pluginConfig.sqlite.cache_size_mb,
     mmapSizeMb: pluginConfig.sqlite.mmap_size_mb
@@ -36209,7 +37153,7 @@ var server = async (ctx) => {
 `);
     setTimeout(async () => {
       try {
-        const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-tghq9gnh.js");
+        const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -36222,7 +37166,9 @@ var server = async (ctx) => {
   }
   let conflictResult = null;
   if (pluginConfig.enabled) {
-    conflictResult = detectConflicts(ctx.directory);
+    conflictResult = detectConflicts(ctx.directory, {
+      compactionEnabled: isCompactionEnabled(pluginConfig)
+    });
     if (conflictResult.hasConflict) {
       pluginConfig.enabled = false;
       log(`[magic-context] disabled due to conflicts: ${conflictResult.reasons.join("; ")}`);
@@ -36332,9 +37278,9 @@ var server = async (ctx) => {
   if (pluginConfig.enabled) {
     const dreamerRunnable = isDreamerRunnable(pluginConfig);
     const classifyModuleClient = createDreamTimerModuleClient(rustModeModuleClient);
-    const timerProjectIdentity = resolveProjectIdentityForSession(ctx.directory);
+    const timerProjectIdentity = resolveProjectIdentityForSession(ctx.directory, pluginConfig.allow_home_project);
     if (!timerProjectIdentity) {
-      log("[magic-context] dream timer skipped: cwd is the user's home directory");
+      log("[magic-context] dream timer skipped: no project identity is bound for this directory");
     } else {
       const timerRegistration = {
         directory: ctx.directory,
@@ -36346,13 +37292,20 @@ var server = async (ctx) => {
         embeddingConfig: pluginConfig.embedding,
         memoryEnabled: pluginConfig.memory?.enabled === true,
         memoryInjectionBudgetTokens: pluginConfig.memory?.injection_budget_tokens,
-        experimentalMural: pluginConfig.experimental?.mural,
+        mural: pluginConfig.mural,
         gitCommitIndexing: pluginConfig.memory.git_commit_indexing?.enabled ? {
           enabled: true,
           since_days: pluginConfig.memory.git_commit_indexing.since_days,
           max_commits: pluginConfig.memory.git_commit_indexing.max_commits
         } : undefined,
         ensureRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
+        onDreamerProgress: (progress, completedTask) => {
+          if (progress) {
+            liveSessionState.dreamerProgressByProject.set(timerProjectIdentity, progress);
+          } else if (liveSessionState.dreamerProgressByProject.get(timerProjectIdentity)?.task === completedTask) {
+            liveSessionState.dreamerProgressByProject.delete(timerProjectIdentity);
+          }
+        },
         moduleClient: classifyModuleClient
       };
       try {
@@ -36377,7 +37330,7 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-n48c783v.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
+      import("./conflict-warning-hook-fvpfvt0w.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
     }
   }
   if (conflictResult?.hasConflict) {
@@ -36398,7 +37351,7 @@ var server = async (ctx) => {
       } = await import("./announcement-gms2nhya.js");
       if (shouldShowAnnouncement2()) {
         setTimeout(() => {
-          import("./conflict-warning-hook-n48c783v.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
+          import("./conflict-warning-hook-fvpfvt0w.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION2, ANNOUNCEMENT_FEATURES2, ANNOUNCEMENT_FOOTER2, markAnnouncementSeen2)).catch(() => {});
         }, 8000);
       }
     } catch {}
@@ -36439,6 +37392,7 @@ var server = async (ctx) => {
       getMagicContext: () => magicContextRuntime.magicContext,
       failClosed,
       failClosedBlockingEnabled,
+      compactionOff: !isCompactionEnabled(pluginConfig),
       internalChildSessions: liveSessionState.internalChildSessions,
       tryReopenStorage
     }),
@@ -36480,7 +37434,7 @@ var server = async (ctx) => {
         }
         const commandConfig = {
           ...config.command ?? {},
-          ...getMagicContextBuiltinCommands(),
+          ...getMagicContextBuiltinCommands(isCompactionEnabled(pluginConfig)),
           ...pluginConfig.command ?? {}
         };
         config.command = commandConfig;