@cortexkit/opencode-magic-context 0.33.0 → 0.34.0

package/dist/index.js

@@ -1,7 +1,12 @@
 import {
+  CANONICAL_DREAM_TASKS,
   buildDreamTaskRuntimeConfigs,
+  compareTaskOrder,
+  isCanonicalDreamTask,
+  leaseKeyFor,
+  leaseKindFor,
   userMemoryCollectionEnabled
-} from "./index-kxz4tn6m.js";
+} from "./index-56yjaeb2.js";
 import {
   AGE_RECLAIM_MIN_TOKENS,
   AdmissionClass,
@@ -17,7 +22,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,
@@ -68,6 +75,7 @@ import {
   clearNoteNudgeTriggerAndCooldown,
   clearNoteNudgeTriggerOnly,
   clearPendingCompactionMarkerStateIf,
+  clearPendingOps,
   clearPersistedReasoningWatermark,
   clearPersistedTodoSyntheticAnchor,
   clearRecompStaging,
@@ -78,6 +86,7 @@ import {
   cosineSimilarity,
   countEmbeddedCommits,
   countPrimerCandidatesForProject,
+  createChildSessionWithFence,
   createPrimer,
   deleteTagsByMessageId,
   deleteUserMemoryCandidates,
@@ -99,6 +108,7 @@ import {
   enqueueShadowEmbeddingItems,
   ensureContextStoreUuid,
   ensureMemoryEmbeddings,
+  escalationBands,
   estimateTrueRawMessageTokens,
   expandWorkspaceIdentitySetWithAliases,
   exports_external,
@@ -117,6 +127,7 @@ import {
   getCandidateToolOwners,
   getChannel2NudgeClaim,
   getChannel2NudgeState,
+  getCompactionModeRecord,
   getCompartmentEvents,
   getCompartments,
   getContextStoreUuid,
@@ -145,6 +156,7 @@ import {
   getMemoryCountsByStatus,
   getMemoryMutationsForRenderByProjects,
   getMemoryVerifications,
+  getMigrationOnOpenRefusal,
   getMirrorCursor,
   getModuleNoteEvaluationBridge,
   getMural,
@@ -161,6 +173,8 @@ import {
   getPersistedCompactionMarkerState,
   getPersistedNoteNudge,
   getPersistedReasoningWatermark,
+  getPersistedSchemaVersion,
+  getPersistedTodoPermissionDenied,
   getPersistedTodoSyntheticAnchor,
   getPrimaryEmbeddingMeasurementCohort,
   getPrimerCandidatesByIds,
@@ -207,6 +221,7 @@ import {
   isDatabasePersisted,
   isEmbeddingEnabled,
   isEmergencyRecoveryArmed,
+  isPidAlive,
   isProviderOverflowReconfirmed,
   lkgContentDigest,
   loadCompartmentChunkEmbeddingsForSearch,
@@ -234,6 +249,7 @@ import {
   openDatabaseAsync,
   parkGitSweepNonIndexable,
   parseCron,
+  parseRpcPortFile,
   peekDeferredExecutePending,
   peekNoteNudgeText,
   peekProjectEmbeddings,
@@ -273,6 +289,7 @@ import {
   releaseWrapupInProgress,
   removeAutoSearchHintDecisionByMessageId,
   removeCompactionMarkerForSession,
+  removeMcOwnedCompactionMarkers,
   removeNoteNudgeAnchorByMessageId,
   removePendingOp,
   removeStrippedPlaceholderId,
@@ -285,6 +302,7 @@ import {
   resetLastNudgeCycleIfTailShrank,
   resetNoteNudgeCooldownOnly,
   resetProtectedTailNoEligibleHead,
+  resolveCompactionModeRecord,
   resolveGitTopLevel,
   resolveOpenCodeProtectedTailBoundary,
   resolveProjectIdentity,
@@ -294,6 +312,8 @@ import {
   resolveWorkspaceIdentitySet,
   resolveWorkspaceShareCategories,
   resolveWrapupProtectedTailBoundary,
+  rpcPortDir,
+  rpcPortFilePath,
   runCompartmentAgent,
   runManagedRecomp,
   runManagedUpgrade,
@@ -305,6 +325,8 @@ import {
   scheduleAfterBootQuiet,
   searchMemoriesFTS,
   searchMemoriesFTSUnion,
+  setChannel2NudgeState,
+  setCompactionModeRecord,
   setDeferredExecutePendingIfAbsent,
   setEmergencyDropSample,
   setKeepSubagents,
@@ -313,7 +335,9 @@ import {
   setMemoryClassification,
   setMuralCue,
   setNoteLastReadAt,
+  setPersistedCompactionMarkerState,
   setPersistedReasoningWatermark,
+  setPersistedTodoPermissionDenied,
   setPersistedTodoSyntheticAnchor,
   setRecompStarting,
   setRecompTerminal,
@@ -345,7 +369,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-h86twgsp.js";
+} from "./index-s0mdn690.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -353,27 +377,24 @@ import {
   isSaneLimit,
   refreshModelLimitsAfterAuthOnce,
   refreshModelLimitsFromApi,
-  resolveHistorianContextLimit
-} from "./index-63dq2g4d.js";
-import {
-  CANONICAL_DREAM_TASKS,
-  compareTaskOrder,
-  isCanonicalDreamTask,
-  leaseKeyFor,
-  leaseKindFor
-} from "./index-anhrfygk.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,
@@ -382,7 +403,6 @@ import {
   cleanUserText,
   clearIndexedMessages,
   clearSession,
-  closeQuietly,
   createToolDropTarget,
   deleteIndexedMessage,
   estimateTokens,
@@ -390,12 +410,10 @@ import {
   extractTexts,
   extractToolCallObservation,
   extractToolCallSummaries,
-  findLastAssistantModelFromOpenCodeDb,
   getIndexedMessageCorpusSize,
   getLastIndexedOrdinal,
   getMessageIndexReconciliationStartOrdinal,
   getMessageIndexSourceIdentity,
-  getMessageTimesFromOpenCodeDb,
   getOrCreateSessionMeta,
   getRawSessionStoredMessageCount,
   hasMeaningfulUserText,
@@ -405,7 +423,6 @@ import {
   isFilePart,
   isMessageIndexReconciledThrough,
   isMessageIndexSourceCurrent,
-  isMidTurn,
   isRawCompactionSummaryInfo,
   isRecord,
   isTextPart,
@@ -413,7 +430,7 @@ import {
   isToolPartWithOutput,
   markSessionCleanupPending,
   normalizeText,
-  openCodeDbExists,
+  partHasCompletedResult,
   prependTag,
   primeInMemoryTailRawMessageCache,
   primeTailRawMessageCache,
@@ -430,9 +447,17 @@ import {
   sweepOrphanedOpenCodeMessageIndexes,
   textMentionsRecentCommit,
   updateSessionMeta,
-  withRawSessionMessageCache,
+  withRawSessionMessageCache
+} from "./index-b563sga5.js";
+import {
+  Database,
+  closeQuietly,
+  findLastAssistantModelFromOpenCodeDb,
+  getMessageTimesFromOpenCodeDb,
+  isMidTurn,
+  openCodeDbExists,
   withReadOnlySessionDb
-} from "./index-bmkea2dq.js";
+} from "./index-fcyvznch.js";
 import {
   cleanupConflictWarnings,
   detectConfigFile,
@@ -440,7 +465,7 @@ import {
   parseJsonc,
   sendConflictWarning,
   stripJsonComments
-} from "./index-k5y60ymm.js";
+} from "./index-dtas91s5.js";
 import {
   ANNOUNCEMENT_FEATURES,
   ANNOUNCEMENT_FOOTER,
@@ -450,6 +475,13 @@ import {
   markAnnouncementSeen,
   shouldShowAnnouncement
 } from "./index-dmr999a2.js";
+import {
+  acknowledgeNotifications,
+  drainNotifications,
+  isTuiConnected,
+  pushNotification,
+  registerNotificationSink
+} from "./index-d62ypazr.js";
 import"./index-73xz0247.js";
 import {
   log,
@@ -464,13 +496,6 @@ import {
 import {
   resolvePromptContext
 } from "./index-szf8w1p5.js";
-import {
-  acknowledgeNotifications,
-  drainNotifications,
-  isTuiConnected,
-  pushNotification,
-  registerNotificationSink
-} from "./index-d62ypazr.js";
 import {
   __commonJS,
   __require,
@@ -8489,6 +8514,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;
 }
@@ -8498,6 +8524,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;
@@ -9327,6 +9356,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).");
@@ -9335,6 +9377,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;
@@ -9552,8 +9599,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",
@@ -9933,6 +9987,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)
@@ -9944,7 +9999,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}`));
@@ -9971,7 +10027,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",
@@ -9979,11 +10037,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",
@@ -9991,7 +10049,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",
@@ -10356,14 +10414,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 (database schema v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
       `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
     ].join(" ");
   }
@@ -10435,7 +10520,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;
@@ -10753,12 +10838,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;
@@ -12850,7 +12935,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() });
@@ -12951,7 +13036,10 @@ 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;
@@ -12986,12 +13074,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
@@ -13170,12 +13258,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;
@@ -13787,12 +13875,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
@@ -14574,7 +14662,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);
   })();
@@ -14793,12 +14881,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
@@ -15579,12 +15667,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
@@ -15929,12 +16017,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
@@ -16546,12 +16634,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
@@ -16998,12 +17086,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
@@ -17690,12 +17778,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;
@@ -17880,12 +17968,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
@@ -19173,11 +19261,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;
@@ -19231,41 +19319,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);
@@ -19320,7 +19412,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 {
@@ -19376,7 +19468,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 {
@@ -19449,6 +19541,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);
   }
@@ -19847,6 +19942,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;
@@ -19854,9 +20018,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")
@@ -19910,7 +20072,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;
@@ -19921,7 +20083,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")
@@ -20021,7 +20183,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 };
@@ -20075,18 +20237,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
       };
     }
@@ -20111,9 +20275,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;
@@ -20228,8 +20392,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)}`,
@@ -20580,6 +20744,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;
@@ -20669,7 +20838,10 @@ Embedding status is unavailable.`;
         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;
@@ -20836,6 +21008,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;
@@ -21390,6 +21768,35 @@ ${body}${hintText}
 }
 
 // src/hooks/magic-context/channel2-delivery.ts
+function subagentRunIsActive(deps, sessionId) {
+  try {
+    const meta = getOrCreateSessionMeta(deps.db, sessionId);
+    if (!meta.isSubagent)
+      return true;
+    return isMidTurn(deps, sessionId);
+  } catch (error) {
+    sessionLog(sessionId, "channel2 subagent run-state check failed; refusing delivery:", error);
+    return false;
+  }
+}
+function clearPendingChannel2Intent(db, sessionId) {
+  try {
+    if (casChannel2NudgeState(db, sessionId, "pending", "")) {
+      sessionLog(sessionId, "channel2 intent cleared because the subagent run is terminal");
+    }
+  } catch (error) {
+    sessionLog(sessionId, "channel2 terminal-run intent clear failed; leaving lease to heal:", error);
+  }
+}
+function releaseClaimWithoutDelivery(db, sessionId, claimToken) {
+  try {
+    if (casChannel2NudgeClaim(db, sessionId, "", claimToken)) {
+      sessionLog(sessionId, "channel2 claim released because the subagent run completed before delivery");
+    }
+  } catch (error) {
+    sessionLog(sessionId, "channel2 terminal-run claim release failed; lease will heal:", error);
+  }
+}
 async function maybeDeliverChannel2(sessionId, deps) {
   let state;
   try {
@@ -21399,6 +21806,10 @@ async function maybeDeliverChannel2(sessionId, deps) {
   }
   if (state !== "pending")
     return false;
+  if (!subagentRunIsActive(deps, sessionId)) {
+    clearPendingChannel2Intent(deps.db, sessionId);
+    return false;
+  }
   if (deps.directiveText === undefined && (deps.reclaimableTokens === undefined || deps.usableTokens === undefined)) {
     return false;
   }
@@ -21419,6 +21830,10 @@ async function maybeDeliverChannel2(sessionId, deps) {
   if (!claimChannel2NudgeState(deps.db, sessionId, claimToken)) {
     return false;
   }
+  if (!subagentRunIsActive(deps, sessionId)) {
+    releaseClaimWithoutDelivery(deps.db, sessionId, claimToken);
+    return false;
+  }
   try {
     const promptContext = await resolvePromptContext(client, sessionId);
     const reminder = deps.directiveText ?? buildChannel2Reminder(deps.reclaimableTokens, deps.oldestReclaimableToolTags);
@@ -21445,6 +21860,10 @@ async function maybeDeliverChannel2(sessionId, deps) {
       sessionLog(sessionId, `channel2 ceiling nudge delivery skipped: claim no longer owned before send (state=${claim.state || "empty"})`);
       return false;
     }
+    if (!subagentRunIsActive(deps, sessionId)) {
+      releaseClaimWithoutDelivery(deps.db, sessionId, claimToken);
+      return false;
+    }
     await session.promptAsync({ path: { id: sessionId }, body });
   } catch (error) {
     try {
@@ -21575,9 +21994,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";
@@ -21604,7 +22023,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
@@ -21948,72 +22367,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
@@ -22364,6 +22868,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;
@@ -25886,64 +26413,6 @@ ${hintText}`;
 }
 function clearAutoSearchForSession(_sessionId) {}
 
-// src/hooks/magic-context/sentinel.ts
-var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
-function modelAcceptsEmptyContent(providerID) {
-  return providerID === "anthropic";
-}
-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) {
@@ -26988,6 +27457,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;
@@ -27475,7 +27952,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           hasResult: false
         };
         entry.occurrences.push({ message, part, kind: toolObservation.kind });
-        if (toolObservation.kind === "result")
+        if (toolObservation.kind === "result" && partHasCompletedResult(part))
           entry.hasResult = true;
         toolCallIndex.set(compositeKey, entry);
         const _tGetTool = performance.now();
@@ -27727,6 +28204,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;
@@ -27883,18 +28428,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,
@@ -27904,12 +28450,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;
@@ -27921,7 +28478,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");
@@ -28027,7 +28584,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;
@@ -28111,7 +28668,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);
@@ -28128,7 +28685,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);
@@ -28163,7 +28720,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;
@@ -28188,7 +28746,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;
@@ -28199,7 +28757,7 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  {
+  if (!compactionOff) {
     const tPlaceholder = performance.now();
     const persistedIds = getStrippedPlaceholderIds(args.db, args.sessionId);
     if (persistedIds.size > 0) {
@@ -28232,7 +28790,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);
     }
@@ -28277,12 +28835,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);
@@ -28306,42 +28866,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) {
@@ -28478,7 +29015,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) {
@@ -28488,9 +29025,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;
@@ -28684,7 +29221,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);
@@ -28704,16 +29241,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");
 }
@@ -28722,7 +29259,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] : [];
@@ -28732,7 +29269,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 };
     }
@@ -28756,6 +29293,7 @@ function ensureState(states, sessionId) {
       ordinalMemoAnchor: null,
       ordinalMemoStoredCount: null,
       ordinalMemoCanonicalCount: 0,
+      ordinalContinuationBase: null,
       seedPassPending: true,
       failureCount: 0,
       parkCount: 0,
@@ -28810,8 +29348,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) {
@@ -28820,7 +29358,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])]));
 }
@@ -28836,7 +29374,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);
@@ -28861,11 +29399,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"];
@@ -28891,7 +29454,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;
@@ -29000,6 +29563,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
   };
@@ -29231,7 +29801,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) {
@@ -29332,10 +29902,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,
@@ -29361,7 +29931,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");
       }
@@ -29403,10 +29974,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,
@@ -29540,7 +30112,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) {
@@ -29690,6 +30263,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;
@@ -29723,13 +30306,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) {
@@ -29787,7 +30371,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);
   }
@@ -29811,6 +30395,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;
@@ -29996,12 +30595,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;
@@ -30027,19 +30645,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) {
@@ -30091,11 +30712,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);
@@ -30104,7 +30726,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}`);
@@ -30150,6 +30772,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;
@@ -30175,6 +30798,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);
@@ -30202,7 +30866,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);
@@ -30262,7 +30926,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);
@@ -30315,25 +30979,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,
@@ -30351,12 +31017,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;
@@ -30437,7 +31104,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();
@@ -30449,7 +31116,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
@@ -30464,7 +31131,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);
     }
@@ -30481,16 +31148,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 });
@@ -30505,7 +31172,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);
@@ -30519,10 +31186,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) {
@@ -30531,44 +31197,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) {
@@ -30584,10 +31251,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);
@@ -30596,7 +31263,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) {
@@ -30605,7 +31272,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;
@@ -30615,6 +31282,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const compartmentPhase = await runCompartmentPhase({
       canRunCompartments,
       fullFeatureMode,
+      compactionOff,
       historianRunnable,
       sessionMeta,
       contextUsage,
@@ -30657,31 +31325,32 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const compartmentInProgress = compartmentPhase.compartmentInProgress;
     sessionMeta = { ...sessionMeta, compartmentInProgress };
     logTransformTiming(sessionId, "compartmentPhase", tCompartmentPhase);
+    if (pendingCompartmentInjection?.needsFreshMaterialization) {
+      deps.pendingMaterializationSessions.add(sessionId);
+      deferredMaterializationSessions.add(sessionId);
+    }
     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({
@@ -30695,10 +31364,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,
@@ -30721,7 +31393,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       pendingCompartmentInjection,
       didMutateFromFlushedStatuses,
       watermark,
-      forceMaterializationPercentage: FORCE_MATERIALIZE_PERCENTAGE,
+      forceMaterializationPercentage,
       hasRecentReduceCall,
       projectPath: sessionProjectIdentity,
       sessionDirectory,
@@ -30743,63 +31415,70 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     });
     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);
@@ -30875,7 +31554,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,
@@ -31064,15 +31743,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);
@@ -31114,13 +31800,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) {
@@ -31219,7 +31910,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;
@@ -31794,11 +32485,16 @@ function createChatMessageHook(args) {
       args.agentBySession.set(sessionId, input.agent);
     }
     if (previousVariant !== undefined && input.variant !== undefined && previousVariant !== input.variant) {
-      sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}), triggering flush`);
-      args.historyRefreshSessions.add(sessionId);
-      args.systemPromptRefreshSessions.add(sessionId);
-      args.pendingMaterializationSessions.add(sessionId);
-      args.lastHeuristicsTurnId.delete(sessionId);
+      const providerID = input.model?.providerID ?? args.liveModelBySession.get(sessionId)?.providerID;
+      if (variantChangeBustsProviderCache(providerID)) {
+        sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}), triggering flush`);
+        args.historyRefreshSessions.add(sessionId);
+        args.systemPromptRefreshSessions.add(sessionId);
+        args.pendingMaterializationSessions.add(sessionId);
+        args.lastHeuristicsTurnId.delete(sessionId);
+      } else {
+        sessionLog(sessionId, `variant changed (${previousVariant} -> ${input.variant}) on provider ${providerID} whose cache ignores request params; deferring flush to next natural bust`);
+      }
     }
   };
 }
@@ -31856,11 +32552,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) {
@@ -31920,6 +32620,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)
@@ -31940,6 +32641,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;
@@ -32364,14 +33078,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;
     }
@@ -32387,9 +33111,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;
@@ -32453,6 +33177,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,
@@ -32513,7 +33238,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);
@@ -32581,7 +33306,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);
@@ -32590,7 +33315,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);
@@ -32616,7 +33341,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);
@@ -32849,6 +33574,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,
@@ -32873,6 +33599,7 @@ function createMagicContextHook(deps) {
     },
     projectPath,
     historianRunnable,
+    compactionOff,
     experimentalUserMemories: userMemoryCollectionEnabled(dreamerConfig),
     experimentalTemporalAwareness: deps.config.temporal_awareness === true,
     experimentalMuralEnabled: deps.config.experimental?.mural?.enabled === true,
@@ -32886,7 +33613,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,
@@ -32902,6 +33629,7 @@ function createMagicContextHook(deps) {
     contextUsageMap,
     compactionHandler: deps.compactionHandler,
     config: deps.config,
+    compactionOff,
     tagger: deps.tagger,
     db,
     client: deps.client,
@@ -32922,6 +33650,7 @@ function createMagicContextHook(deps) {
       transform.clearRustSession(sessionId);
       systemPromptHash.clearSession(sessionId);
       lastHeuristicsTurnId.delete(sessionId);
+      clearToolPermissionDenied(sessionId);
       commitSeenLastPass.delete(sessionId);
       variantBySession.delete(sessionId);
       liveModelBySession.delete(sessionId);
@@ -32981,6 +33710,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,
@@ -33124,6 +33854,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,
@@ -33219,15 +33950,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;
@@ -33244,9 +33990,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) {
@@ -33288,6 +34040,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);
@@ -33309,6 +34062,7 @@ function createMessagesTransformHandler(args) {
         }
       }
     }
+    restoreCompactionOffInput();
     return output.messages;
   };
 }
@@ -33541,21 +34295,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) {
@@ -33578,7 +34322,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);
@@ -33599,7 +34343,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);
@@ -33694,6 +34439,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,
@@ -33713,8 +34464,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,
@@ -33723,6 +34477,7 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       sessionNoteCount,
       readySmartNoteCount,
       cacheTtl,
+      lastTransformError: meta?.last_transform_error ? String(meta.last_transform_error) : null,
       lastDreamerRunAt,
       projectIdentity,
       compartmentTokens: calibrated.compartmentTokens,
@@ -33761,15 +34516,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,
@@ -33786,6 +34541,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     cacheTtlMs: 0,
     cacheRemainingMs: 0,
     cacheExpired: false,
+    cacheNeverExpires: false,
     executeThreshold: 65,
     executeThresholdMode: "percentage",
     protectedTagCount: 20,
@@ -33794,9 +34550,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);
@@ -33855,11 +34619,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;
@@ -33897,6 +34670,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;
@@ -33907,7 +34681,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 ?? "");
@@ -33917,7 +34691,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 ?? "");
@@ -33945,9 +34719,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-dn9k9szr.js");
+    const { userMemoryCollectionEnabled: userMemoryCollectionEnabled2 } = await import("./task-config-5nx3qfz8.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
     return {
       client: args.client,
@@ -33972,8 +34746,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-yh7pepvx.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-tghq9gnh.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-8e82vmvb.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) => {
@@ -33988,8 +34762,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-yh7pepvx.js");
-    const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-tghq9gnh.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-8e82vmvb.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) => {
@@ -34005,7 +34779,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-1phy0b1z.js");
+      const { updateSessionMeta: updateSessionMeta2 } = await import("./storage-meta-session-xt41zbw4.js");
       updateSessionMeta2(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -34109,7 +34883,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) {
@@ -34138,15 +34912,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
     };
   }
@@ -34155,7 +34929,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
     };
   }
@@ -34184,7 +34958,7 @@ function reasoningOf(part) {
   return null;
 }
 function renderPartPreview(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -34208,7 +34982,7 @@ function renderPartPreview(part) {
   return `    • [${type}]`;
 }
 function renderPartFull(part) {
-  if (!isRecord3(part))
+  if (!isRecord4(part))
     return null;
   const text = textOf(part);
   if (text !== null) {
@@ -35714,6 +36488,8 @@ function createToolRegistry(args) {
   if (pluginConfig.enabled !== true) {
     return {};
   }
+  const compactionOff = !isCompactionEnabled(pluginConfig);
+  setCtxReduceRegisteredGlobally(!compactionOff);
   let db;
   try {
     const opened = openDatabase();
@@ -35731,10 +36507,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
@@ -35799,64 +36575,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;
@@ -35931,10 +36649,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 });
@@ -35945,11 +36668,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}`);
@@ -36126,6 +36851,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
@@ -36149,7 +36875,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;
@@ -36162,7 +36888,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("; ")}`);
@@ -36272,9 +37000,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,
@@ -36317,7 +37045,7 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-bwa99a04.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) {
@@ -36338,7 +37066,7 @@ var server = async (ctx) => {
       } = await import("./announcement-gms2nhya.js");
       if (shouldShowAnnouncement2()) {
         setTimeout(() => {
-          import("./conflict-warning-hook-bwa99a04.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 {}
@@ -36379,6 +37107,7 @@ var server = async (ctx) => {
       getMagicContext: () => magicContextRuntime.magicContext,
       failClosed,
       failClosedBlockingEnabled,
+      compactionOff: !isCompactionEnabled(pluginConfig),
       internalChildSessions: liveSessionState.internalChildSessions,
       tryReopenStorage
     }),
@@ -36420,7 +37149,7 @@ var server = async (ctx) => {
         }
         const commandConfig = {
           ...config.command ?? {},
-          ...getMagicContextBuiltinCommands(),
+          ...getMagicContextBuiltinCommands(isCompactionEnabled(pluginConfig)),
           ...pluginConfig.command ?? {}
         };
         config.command = commandConfig;