@cortexkit/opencode-magic-context 0.42.5 → 0.42.6

package/dist/v2/server.js

@@ -53526,6 +53526,13 @@ function parseJsonc(content, options = {}) {
   const normalized = stripTrailingCommas(stripJsonComments(content));
   return sanitizeParsedJson(JSON.parse(normalized), options);
 }
+function readJsoncFile(filePath) {
+  try {
+    return parseJsonc(readFileSync(filePath, "utf-8"));
+  } catch (_error) {
+    return null;
+  }
+}
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
@@ -59744,6 +59751,7 @@ var DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE = 65;
 var EXECUTE_THRESHOLD_CAP_MESSAGE = "execute_threshold is capped at 90% for cache safety: output capacity is reserved from the usable context window, and the remaining 10% absorbs mid-turn growth before the absolute 95% emergency wall. Use a value between 20 and 90.";
 var DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
 var DEFAULT_HISTORY_BUDGET_PERCENTAGE = 0.15;
+var PROTECTED_TOKENS_MIN = 4000;
 var DEFAULT_LOCAL_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
 var PiThinkingLevelSchema = _enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]).optional();
 var OmpThinkingLevelSchema = _enum(["off", "minimal", "low", "medium", "high", "xhigh", "max", "inherit", "auto"]).optional();
@@ -60113,8 +60121,8 @@ var MagicContextConfigSchema = object({
   smart_notes: object({
     retina_handoff: boolean2().default(false).describe("When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.")
   }).default({ retina_handoff: false }).describe("Smart-note ownership transition controls."),
-  cache_ttl: union([string2(), object({ default: string2() }).catchall(string2())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "model-id": "10m" }). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
-  prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use bare model IDs, provider/model, or provider/* routing keys. Guidance and tool-description overrides are user-level only. On OpenCode and Pi, per-model routing applies to the guidance block only: tool descriptions are registered once per process, so they follow the default preset (a v1 plugin-surface limitation; per-model tool descriptions are planned for the OpenCode v2 plugin API once the SDK stabilizes)."),
+  cache_ttl: union([string2(), object({ default: string2() }).catchall(string2())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard, then default). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
+  prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use bare model IDs, provider/model, or provider/* routing keys. Guidance and tool-description overrides are user-level only. OpenCode 1.x, Pi, and OMP register tool descriptions once per process (they follow the default preset). OpenCode 2 rewrites the five ctx_* descriptions per request from the draft model."),
   output_reserve: union([
     number2().min(0),
     object({ default: number2().min(0) }).catchall(number2().min(0))
@@ -60130,7 +60138,7 @@ var MagicContextConfigSchema = object({
   execute_threshold_tokens: object({
     default: number2().min(5000).max(2000000).optional()
   }).catchall(number2().min(5000).max(2000000)).optional().describe("Absolute token thresholds per model. When matched, overrides execute_threshold_percentage for that model. Accepts `default` for all models or per-model keys. Values above 90% × context_limit are clamped with a warning log. Min 5_000, max 2_000_000."),
-  protected_tokens: number2().int().min(4000).max(1e6).optional().describe("Positive integer token floor to protect from automatic reclaim (min: 4_000, max: 1_000_000). When omitted, the derived default is clamp(round(0.05 × usableSoft), min(16_000, round(0.08 × usableSoft)), 64_000)."),
+  protected_tokens: number2().int().min(PROTECTED_TOKENS_MIN).max(1e6).optional().describe("Positive integer token floor to protect from automatic reclaim (min: 4_000, max: 1_000_000). When omitted, the derived default is clamp(round(0.05 × usableSoft), min(16_000, round(0.08 × usableSoft)), 64_000)."),
   protected_tags: unknown().optional().describe("Deprecated: number of recent tags to protect. Ignored for behaviour; use protected_tokens instead.").meta({ deprecated: true }),
   clear_reasoning_age: number2().min(10).default(50).describe("Clear reasoning/thinking blocks older than N tags (default: 50)"),
   history_budget_percentage: number2().min(0.05).max(0.5).default(DEFAULT_HISTORY_BUDGET_PERCENTAGE).describe("Fraction of usable context (context_limit × execute_threshold) reserved for the session history block (default: 0.15)"),
@@ -61449,6 +61457,9 @@ function redactConfigValue(value) {
   return typeof value;
 }
 var warnedProtectedTagsDeprecation = false;
+function formatProtectedTokensBelowMinWarning(value) {
+  return `protected_tokens is a token floor (minimum ${PROTECTED_TOKENS_MIN}, default derived from the context window); ${value} looks like the old protected_tags count. Remove the key to use the default, or set a token count such as 16000.`;
+}
 function warnProtectedTagsDeprecationOnce() {
   if (!warnedProtectedTagsDeprecation) {
     warnedProtectedTagsDeprecation = true;
@@ -61539,6 +61550,11 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
     delete patched[key];
     const defaultVal = defaults[key];
     const reason = customMessagesByKey.get(key);
+    const invalidRawValue = rawConfig[key];
+    if (key === "protected_tokens" && typeof invalidRawValue === "number" && invalidRawValue < PROTECTED_TOKENS_MIN) {
+      warnings.push(formatProtectedTokensBelowMinWarning(invalidRawValue));
+      continue;
+    }
     warnings.push(`"${key}": invalid value (${redactConfigValue(rawConfig[key])}), using default ${JSON.stringify(defaultVal)}.${reason ? ` ${reason}` : ""}`);
   }
   const retryMigrated = migrateLegacyAgentEnabledInMemory(migrateDreamerV2(migrateLegacyExperimental(patched, preMigrationWarnings), preMigrationWarnings), preMigrationWarnings);
@@ -61732,6 +61748,10 @@ function loadPluginConfigDetailed(directory) {
     cacheTtlConfigured
   };
 }
+
+// src/v2/server.ts
+init_logger();
+
 // src/features/magic-context/memory/project-identity.ts
 init_logger();
 import { execFileSync } from "node:child_process";
@@ -64109,6 +64129,28 @@ async function pullAndApplyMirrorPageWithStatus(args) {
     limit
   });
   const nextCursor = applyMirrorPage({ db: args.db, page: response.page });
+  if (args.domain === "memories" && args.module.memoryIdentityAck) {
+    const rowsByProject = new Map;
+    for (const feed of response.page.rows) {
+      if (feed.domain !== "memories" || feed.op === "tombstone")
+        continue;
+      const project = rowString(feed.full_row_snapshot, "project_path");
+      if (!project)
+        continue;
+      const identity = mirrorIdentity(args.db, "memories", project, feed.module_row_id);
+      if (!identity)
+        continue;
+      const rows = rowsByProject.get(project) ?? [];
+      rows.push({
+        module_row_id: feed.module_row_id,
+        context_row_id: identity.context_row_id
+      });
+      rowsByProject.set(project, rows);
+    }
+    for (const [project, rows] of rowsByProject) {
+      await args.module.memoryIdentityAck({ project, rows });
+    }
+  }
   return {
     cursor: nextCursor,
     hasMore: response.page.has_more,
@@ -64222,6 +64264,25 @@ function extractTexts(parts) {
   }
   return texts;
 }
+function extractToolResultBodyTokens(parts) {
+  let tokens = 0;
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type !== "tool")
+      continue;
+    const state = p.state;
+    if (!state || typeof state !== "object")
+      continue;
+    const body = state.output ?? state.error;
+    if (body === undefined)
+      continue;
+    const text = typeof body === "string" ? body : JSON.stringify(body);
+    tokens += Math.ceil(text.length / 4);
+  }
+  return tokens;
+}
 function extractToolCallSummaries(parts) {
   const summaries = [];
   for (const part of parts) {
@@ -65409,7 +65470,7 @@ function refreshTailHygieneBaseline(input) {
   for (let index = input.previous.baselineParts.length;index < measured.parts.length; index += 1) {
     const part = measured.parts[index];
     turnDeltaT += part.tokens;
-    if (part.kind !== "toolOutput")
+    if (part.kind !== "toolOutput" || !part.protected)
       turnDeltaU += part.uTokens;
   }
   return {
@@ -66477,15 +66538,16 @@ import { isAbsolute as isAbsolute4, join as join7 } from "node:path";
 var cachedResolution = null;
 var lastReadFailure = null;
 var claimedDiagnostics = new Set;
-function openCodeDataDir() {
-  return join7(process.env.XDG_DATA_HOME ?? join7(homedir8(), ".local", "share"), "opencode");
+function openCodeDataDir(env = process.env, dataHome) {
+  return join7(dataHome ?? env.XDG_DATA_HOME ?? join7(homedir8(), ".local", "share"), "opencode");
 }
-function environmentKey(dataDir) {
+function environmentKey(dataDir, hostGeneration, channel, env) {
   return [
+    hostGeneration,
     dataDir,
-    process.env.OPENCODE_DB ?? "",
-    process.env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
-    process.env.OPENCODE_CHANNEL ?? ""
+    env.OPENCODE_DB ?? "",
+    env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
+    channel ?? env.OPENCODE_CHANNEL ?? ""
   ].join("\x00");
 }
 function channelPath(dataDir, channel) {
@@ -66517,8 +66579,8 @@ function discoverOpenCodeDb(dataDir) {
   const channel = name === "opencode.db" ? null : name.slice("opencode-".length, -".db".length) || null;
   return { path: existing.path, source: "discovered", channel };
 }
-function resolveFresh(dataDir) {
-  const explicit = process.env.OPENCODE_DB;
+function resolveV1Fresh(dataDir, env = process.env) {
+  const explicit = env.OPENCODE_DB;
   if (explicit !== undefined && explicit.length > 0) {
     if (explicit === ":memory:") {
       return { path: explicit, source: "OPENCODE_DB", channel: null };
@@ -66529,24 +66591,47 @@ function resolveFresh(dataDir) {
       channel: null
     };
   }
-  const disableChannelDb = process.env.OPENCODE_DISABLE_CHANNEL_DB;
+  const disableChannelDb = env.OPENCODE_DISABLE_CHANNEL_DB;
   if (disableChannelDb === "1" || disableChannelDb === "true") {
     return { path: join7(dataDir, "opencode.db"), source: "default", channel: null };
   }
-  const channel = process.env.OPENCODE_CHANNEL;
+  const channel = env.OPENCODE_CHANNEL;
   if (channel !== undefined && channel.length > 0) {
     return { path: channelPath(dataDir, channel), source: "channel", channel };
   }
   return discoverOpenCodeDb(dataDir);
 }
-function resolveOpenCodeDbPath() {
-  const dataDir = openCodeDataDir();
-  const key = environmentKey(dataDir);
+function sourceOpenCodeDatabaseFilename(hostGeneration, channel, env = process.env) {
+  if (hostGeneration === "v1") {
+    const explicit = env.OPENCODE_DB;
+    if (explicit !== undefined && explicit.length > 0)
+      return explicit;
+    if (env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
+      return "opencode.db";
+    }
+    return ["latest", "beta", "prod"].includes(channel) ? "opencode.db" : `opencode-${channel}.db`;
+  }
+  return env.OPENCODE_DB ?? (["latest", "dev", "beta", "next", "prod"].includes(channel) || env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true" ? "opencode.db" : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "")}.db`);
+}
+function resolveV2Fresh(dataDir, channel, env) {
+  const filename = sourceOpenCodeDatabaseFilename("v2", channel, env);
+  const explicit = env.OPENCODE_DB !== undefined;
+  return {
+    path: filename === ":memory:" ? filename : join7(dataDir, filename),
+    source: explicit ? "OPENCODE_DB" : env.OPENCODE_CHANNEL ? "channel" : "default",
+    channel: explicit ? null : channel
+  };
+}
+function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
+  const env = options.env ?? process.env;
+  const dataDir = openCodeDataDir(env, options.dataHome);
+  const channel = options.channel ?? env.OPENCODE_CHANNEL;
+  const key = environmentKey(dataDir, hostGeneration, channel, env);
   if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync8(cachedResolution.resolution.path))) {
     if (cachedResolution.existed)
       return cachedResolution.resolution;
   }
-  const resolution = resolveFresh(dataDir);
+  const resolution = hostGeneration === "v2" ? resolveV2Fresh(dataDir, channel ?? "latest", env) : resolveV1Fresh(dataDir, env);
   cachedResolution = {
     key,
     resolution,
@@ -66554,6 +66639,29 @@ function resolveOpenCodeDbPath() {
   };
   return resolution;
 }
+function schemaTableNames(db, schema = "main") {
+  const rows = db.prepare(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message')`).all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function detectOpenCodeStoreGeneration(db, schema = "main") {
+  const tables = schemaTableNames(db, schema);
+  const hasV1Messages = tables.has("message") && tables.has("part");
+  if (hasV1Messages)
+    return "v1";
+  if (tables.has("session_message"))
+    return "v2";
+  if (tables.has("session") || tables.has("project"))
+    return "v1";
+  return "unknown";
+}
+function assertOpenCodeStoreGeneration(db, expected, path, schema = "main") {
+  const actual = detectOpenCodeStoreGeneration(db, schema);
+  if (actual === expected)
+    return;
+  if (actual === "unknown")
+    return;
+  throw new Error(`OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`);
+}
 function openCodeDbPathExists(resolution = resolveOpenCodeDbPath()) {
   return resolution.path !== ":memory:" && existsSync8(resolution.path);
 }
@@ -66611,6 +66719,12 @@ function getReadOnlySessionDb() {
   }
   closeCachedReadOnlyDb();
   const db = new Database(dbPath, { readonly: true });
+  try {
+    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+  } catch (error) {
+    closeQuietly(db);
+    throw error;
+  }
   cachedReadOnlyDb = { path: dbPath, db };
   clearOpenCodeDbReadFailure();
   return db;
@@ -67002,6 +67116,20 @@ function countRawSessionMessageOrdinalsFromDb(db, sessionId) {
                )`).get(sessionId);
   return typeof row?.count === "number" ? row.count : 0;
 }
+function readRawSessionMessageIdOrdinalsFromDb(db, sessionId) {
+  const messageRows = db.prepare("SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
+  const ordinalById = new Map;
+  let ordinal = 0;
+  for (const row of messageRows) {
+    const info = parseJsonRecord(row.data);
+    if (isRawCompactionSummaryInfo(info))
+      continue;
+    ordinal += 1;
+    if (info)
+      ordinalById.set(row.id, ordinal);
+  }
+  return ordinalById;
+}
 function readRawSessionMessageOrdinalPageFromDb(db, sessionId, after, limit) {
   const pageSize = Math.max(1, Math.floor(limit));
   const rows = (after ? db.prepare(`SELECT id, data, time_created
@@ -68260,6 +68388,17 @@ function getRawSessionStoredMessageCount(sessionId) {
     return 0;
   return withReadOnlySessionDb((db) => countStoredRawSessionMessagesFromDb(db, sessionId));
 }
+function readRawSessionMessageIdOrdinals(sessionId) {
+  const provider = sessionProviders.get(sessionId);
+  if (provider?.readMessageIdOrdinals)
+    return provider.readMessageIdOrdinals();
+  if (provider) {
+    return new Map(provider.readMessages().map((message) => [message.id, message.ordinal]));
+  }
+  if (!openCodeDbExists())
+    return new Map;
+  return withReadOnlySessionDb((db) => readRawSessionMessageIdOrdinalsFromDb(db, sessionId));
+}
 function readRawSessionMessagePartsById(sessionId, messageId, onQuery) {
   const provider = sessionProviders.get(sessionId);
   if (provider?.readMessagePartsById)
@@ -68427,6 +68566,14 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
   const totalMessageCount = getCachedAbsoluteMessageCount(sessionId) ?? messages.length;
   const startOrdinal = Math.max(1, offset);
   const completedToolArcs = buildToolArcs(messages).flatMap((arc) => arc.resOrdinal === null ? [] : [{ start: arc.invOrdinal, end: arc.resOrdinal }]);
+  const completedToolComponents = [];
+  for (const arc of completedToolArcs) {
+    const component = completedToolComponents[completedToolComponents.length - 1];
+    if (component && arc.start <= component.end)
+      component.end = Math.max(component.end, arc.end);
+    else
+      completedToolComponents.push({ ...arc });
+  }
   const lines = [];
   const lineMeta = [];
   const flushedToolOnlyBlocks = [];
@@ -68440,6 +68587,25 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
   let pendingNoiseMeta = [];
   let commitClusters = 0;
   let lastFlushedRole = "";
+  let admittedOversizeComponentEnd = null;
+  let currentBlockApproxTokens = 0;
+  let formattedBudgetCrossed = false;
+  let sourceCharacters = 0;
+  const toolResultBoundaries = [];
+  function pinComponentWhenFormattedBudgetCrosses(ordinal, appendedText) {
+    if (admittedOversizeComponentEnd !== null || formattedBudgetCrossed || !currentBlock)
+      return;
+    currentBlockApproxTokens += estimateTokens(appendedText) + (currentBlock.parts.length > 1 ? 1 : 0);
+    if (totalTokens + currentBlockApproxTokens + 64 <= tokenBudget)
+      return;
+    const previewTokens = totalTokens + estimateTokens(formatBlock(currentBlock));
+    if (previewTokens <= tokenBudget)
+      return;
+    formattedBudgetCrossed = true;
+    const component = completedToolComponents.find((candidate) => candidate.start <= ordinal && candidate.end >= ordinal);
+    if (component)
+      admittedOversizeComponentEnd = component.end;
+  }
   function recordFilteredNoise(meta) {
     pendingNoiseMeta.push(meta);
     if (!currentBlock) {
@@ -68466,7 +68632,23 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     highestScannedOrdinal = Math.max(highestScannedOrdinal, lastOrdinal);
     lastMessageId = currentBlock.meta[currentBlock.meta.length - 1]?.messageId ?? "";
     messagesProcessed += currentBlock.meta.length;
+    const lineStart = sourceCharacters + (lines.length > 0 ? 1 : 0);
+    const renderedParts = currentBlock.parts.join(" / ");
+    let partOffset = lineStart + (blockText.length - renderedParts.length);
+    for (let index = 0;index < currentBlock.parts.length; index++) {
+      const part = currentBlock.parts[index] ?? "";
+      const partMeta = currentBlock.partMeta[index];
+      if (partMeta && partMeta.toolResultBodyTokens > 0) {
+        toolResultBoundaries.push({
+          ordinal: partMeta.ordinal,
+          sourceOffset: partOffset,
+          bodyTokens: partMeta.toolResultBodyTokens
+        });
+      }
+      partOffset += part.length + (index + 1 < currentBlock.parts.length ? 3 : 0);
+    }
     lines.push(blockText);
+    sourceCharacters = lineStart + blockText.length;
     lineMeta.push(...currentBlock.meta);
     totalTokens += blockTokens;
     if (currentBlock.isToolOnly) {
@@ -68476,11 +68658,15 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       });
     }
     currentBlock = null;
+    currentBlockApproxTokens = 0;
     return true;
   }
   for (const msg of messages) {
     if (eligibleEndOrdinal !== undefined && msg.ordinal >= eligibleEndOrdinal)
       break;
+    if (admittedOversizeComponentEnd !== null && msg.ordinal > admittedOversizeComponentEnd) {
+      break;
+    }
     if (msg.ordinal < startOrdinal)
       continue;
     const meta = { ordinal: msg.ordinal, messageId: msg.id };
@@ -68494,6 +68680,10 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       if (currentBlock && currentBlock.role === "A") {
         currentBlock.endOrdinal = msg.ordinal;
         currentBlock.parts.push(tcText);
+        currentBlock.partMeta.push({
+          ordinal: msg.ordinal,
+          toolResultBodyTokens: extractToolResultBodyTokens(msg.parts)
+        });
         currentBlock.meta.push(...pendingNoiseMeta, meta);
         pendingNoiseMeta = [];
       } else {
@@ -68504,12 +68694,19 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
           startOrdinal: pendingNoiseMeta[0]?.ordinal ?? msg.ordinal,
           endOrdinal: msg.ordinal,
           parts: [tcText],
+          partMeta: [
+            {
+              ordinal: msg.ordinal,
+              toolResultBodyTokens: extractToolResultBodyTokens(msg.parts)
+            }
+          ],
           meta: [...pendingNoiseMeta, meta],
           commitHashes: [],
           isToolOnly: true
         };
         pendingNoiseMeta = [];
       }
+      pinComponentWhenFormattedBudgetCrosses(msg.ordinal, tcText);
       continue;
     }
     const role = compactRole(msg.role);
@@ -68526,11 +68723,16 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     if (currentBlock && currentBlock.role === role) {
       currentBlock.endOrdinal = msg.ordinal;
       currentBlock.parts.push(text);
+      currentBlock.partMeta.push({
+        ordinal: msg.ordinal,
+        toolResultBodyTokens: extractToolResultBodyTokens(msg.parts)
+      });
       currentBlock.meta.push(...pendingNoiseMeta, meta);
       currentBlock.commitHashes = mergeCommitHashes(currentBlock.commitHashes, compacted.commitHashes);
       if (msgHasNarrative)
         currentBlock.isToolOnly = false;
       pendingNoiseMeta = [];
+      pinComponentWhenFormattedBudgetCrosses(msg.ordinal, text);
       continue;
     }
     if (!flushCurrentBlock())
@@ -68540,11 +68742,18 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       startOrdinal: pendingNoiseMeta[0]?.ordinal ?? msg.ordinal,
       endOrdinal: msg.ordinal,
       parts: [text],
+      partMeta: [
+        {
+          ordinal: msg.ordinal,
+          toolResultBodyTokens: extractToolResultBodyTokens(msg.parts)
+        }
+      ],
       meta: [...pendingNoiseMeta, meta],
       commitHashes: [...compacted.commitHashes],
       isToolOnly: !msgHasNarrative
     };
     pendingNoiseMeta = [];
+    pinComponentWhenFormattedBudgetCrosses(msg.ordinal, text);
   }
   if (flushCurrentBlock() && pendingNoiseMeta.length > 0) {
     highestScannedOrdinal = Math.max(highestScannedOrdinal, pendingNoiseMeta[pendingNoiseMeta.length - 1]?.ordinal ?? highestScannedOrdinal);
@@ -68575,7 +68784,8 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     ...messagesProcessed === 0 && text.length === 0 ? { filteredNoiseLines: pendingNoiseMeta } : {},
     commitClusterCount: commitClusters,
     toolOnlyRanges,
-    completedToolArcs
+    completedToolArcs,
+    toolResultBoundaries
   };
 }
 function readRawSessionSeedTail(sessionId, boundaryId, onQuery) {
@@ -69537,6 +69747,114 @@ function isSqliteLockError(error) {
 function tableExists2(db, name) {
   return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
 }
+function tableHasHarnessColumn(db, name) {
+  if (!tableExists2(db, name))
+    return false;
+  return db.prepare(`PRAGMA table_info(${name})`).all().some((column) => column.name === "harness");
+}
+var V85_OPENCODE2_RELABEL_TABLES = [
+  "tags",
+  "pending_ops",
+  "source_contents",
+  "compartments",
+  "compartment_chunk_embeddings",
+  "session_projects",
+  "compartment_events",
+  "compression_depth",
+  "session_facts",
+  "primer_candidates",
+  "notes",
+  "message_history_index",
+  "message_history_source",
+  "pending_session_cleanup",
+  "message_history_orphan_sweep",
+  "session_meta",
+  "subagent_invocations",
+  "historian_runs",
+  "transform_decisions",
+  "recomp_compartments",
+  "recomp_facts"
+];
+var V85_OPTIONAL_OPENCODE2_RELABEL_TABLES = ["session_project_backfill_state"];
+function deleteLosingOpenCode2Twin(db, table, joinColumns, newerPredicate) {
+  if (!tableHasHarnessColumn(db, table))
+    return;
+  const naturalJoin = joinColumns.map((column) => `oc.${column} = o2.${column}`).join(" AND ");
+  const o2On = naturalJoin ? `${naturalJoin} AND oc.harness = 'opencode'` : `oc.harness = 'opencode'`;
+  const ocOn = naturalJoin ? `${naturalJoin} AND o2.harness = 'opencode2'` : `o2.harness = 'opencode2'`;
+  db.exec(`
+        DELETE FROM ${table}
+        WHERE rowid IN (
+            SELECT o2.rowid
+            FROM ${table} AS o2
+            JOIN ${table} AS oc
+              ON ${o2On}
+            WHERE o2.harness = 'opencode2'
+              AND NOT (${newerPredicate})
+        );
+        DELETE FROM ${table}
+        WHERE rowid IN (
+            SELECT oc.rowid
+            FROM ${table} AS oc
+            JOIN ${table} AS o2
+              ON ${ocOn}
+            WHERE oc.harness = 'opencode'
+              AND (${newerPredicate})
+        );
+    `);
+}
+function relabelOpenCode2HarnessRows(db) {
+  deleteLosingOpenCode2Twin(db, "session_projects", ["session_id"], "o2.updated_at > oc.updated_at");
+  deleteLosingOpenCode2Twin(db, "primer_candidates", ["project_path", "session_id", "source_start_message_id", "source_end_message_id"], "o2.created_at > oc.created_at");
+  deleteLosingOpenCode2Twin(db, "transform_decisions", ["session_id", "message_id"], "o2.ts_ms > oc.ts_ms");
+  deleteLosingOpenCode2Twin(db, "message_history_orphan_sweep", [], "COALESCE(o2.last_swept_at, -1) > COALESCE(oc.last_swept_at, -1)");
+  if (tableHasHarnessColumn(db, "session_project_backfill_state")) {
+    db.exec(`
+            DELETE FROM session_project_backfill_state
+            WHERE harness = 'opencode2'
+              AND EXISTS (
+                  SELECT 1 FROM session_project_backfill_state WHERE harness = 'opencode'
+              )
+              AND NOT (
+                  (status = 'completed'
+                    AND (SELECT status FROM session_project_backfill_state WHERE harness = 'opencode')
+                        != 'completed')
+                  OR (
+                      status = (SELECT status FROM session_project_backfill_state WHERE harness = 'opencode')
+                      AND COALESCE(started_at, -1) > COALESCE(
+                          (SELECT started_at FROM session_project_backfill_state WHERE harness = 'opencode'),
+                          -1
+                      )
+                  )
+              );
+            DELETE FROM session_project_backfill_state
+            WHERE harness = 'opencode'
+              AND EXISTS (
+                  SELECT 1 FROM session_project_backfill_state WHERE harness = 'opencode2'
+              )
+              AND (
+                  ((SELECT status FROM session_project_backfill_state WHERE harness = 'opencode2') = 'completed'
+                    AND status != 'completed')
+                  OR (
+                      status = (SELECT status FROM session_project_backfill_state WHERE harness = 'opencode2')
+                      AND COALESCE(
+                          (SELECT started_at FROM session_project_backfill_state WHERE harness = 'opencode2'),
+                          -1
+                      ) > COALESCE(started_at, -1)
+                  )
+              );
+        `);
+  }
+  const tables = new Set([
+    ...V85_OPENCODE2_RELABEL_TABLES,
+    ...V85_OPTIONAL_OPENCODE2_RELABEL_TABLES
+  ]);
+  for (const table of tables) {
+    if (!tableHasHarnessColumn(db, table))
+      continue;
+    db.exec(`UPDATE ${table} SET harness = 'opencode' WHERE harness = 'opencode2'`);
+  }
+}
 function healMismatchedTierClose(db, table, hasLegacy) {
   if (!tableExists2(db, table))
     return;
@@ -71699,6 +72017,13 @@ var MIGRATIONS = [
       ensureColumn(db, "session_meta", "protected_tokens_effective", "INTEGER");
       ensureColumn(db, "session_meta", "protected_tokens_pre_snapshot", "TEXT");
     }
+  },
+  {
+    version: 85,
+    description: "relabel OpenCode 1.x mis-tagged opencode2 session rows",
+    up(db) {
+      relabelOpenCode2HarnessRows(db);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -72855,6 +73180,7 @@ function runToolOwnerBackfill(db) {
   const escapedDbPath = opencodeDbPath.replaceAll("'", "''");
   db.exec(`ATTACH '${escapedDbPath}' AS oc_backfill`);
   try {
+    assertOpenCodeStoreGeneration(db, "v1", opencodeDbPath, "oc_backfill");
     backfillToolOwnersInChunks(db, result);
   } finally {
     try {
@@ -73070,7 +73396,7 @@ var lastMigrationOnOpenRefusal = null;
 function getSchemaFenceRejection() {
   return lastSchemaFenceRejection;
 }
-var LATEST_SUPPORTED_VERSION = 84;
+var LATEST_SUPPORTED_VERSION = 85;
 var BOOT_SQLITE_BUSY_TIMEOUT_MS = 5000;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 var defaultStoragePermissionFs = { chmodSync: chmodSync2, mkdirSync: mkdirSync4 };
@@ -73524,7 +73850,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       tag_id INTEGER,
       session_id TEXT,
       content TEXT,
-      created_at INTEGER,
+      created_at INTEGER, -- epoch ms; Date.now() on source writes, preserved on session clones
       harness TEXT NOT NULL DEFAULT 'opencode',
       PRIMARY KEY(session_id, tag_id)
     );
@@ -73548,7 +73874,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       p1_embedding BLOB,
       p1_embedding_model_id TEXT,
       legacy INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       harness TEXT NOT NULL DEFAULT 'opencode',
       UNIQUE(session_id, sequence)
     );
@@ -73567,7 +73893,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       model_id TEXT NOT NULL,
       dims INTEGER NOT NULL,
       vector BLOB NOT NULL,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       UNIQUE(compartment_id, model_id, window_index)
     );
     CREATE INDEX IF NOT EXISTS idx_cce_session ON compartment_chunk_embeddings(session_id);
@@ -73590,7 +73916,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       kind TEXT NOT NULL,
       at_compartment INTEGER,
       fields_json TEXT NOT NULL DEFAULT '{}',
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       harness TEXT NOT NULL DEFAULT 'opencode'
     );
     CREATE INDEX IF NOT EXISTS idx_compartment_events_session
@@ -73619,7 +73945,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       session_id TEXT NOT NULL,
       category TEXT NOT NULL,
       content TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       updated_at INTEGER NOT NULL,
       harness TEXT NOT NULL DEFAULT 'opencode'
     );
@@ -73638,7 +73964,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       source_message_time INTEGER NOT NULL,
       question_embedding BLOB,
       question_embedding_model_id TEXT,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       UNIQUE(project_path, harness, session_id, source_start_message_id, source_end_message_id)
     );
     CREATE INDEX IF NOT EXISTS idx_primer_candidates_project_time
@@ -73661,7 +73987,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       answer_refreshed_at INTEGER,
       source_candidate_ids TEXT NOT NULL DEFAULT '[]',
       source_candidate_provenance TEXT,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       updated_at INTEGER NOT NULL
     );
     CREATE INDEX IF NOT EXISTS idx_primers_project_status_observed
@@ -73774,7 +74100,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       job_id TEXT,
       cursor TEXT,
       status TEXT NOT NULL DEFAULT 'pending',
-      created_at INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL DEFAULT 0, -- epoch ms (Date.now())
       updated_at INTEGER NOT NULL DEFAULT 0,
       UNIQUE(session_id, request_key)
     );
@@ -73815,7 +74141,7 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       shadow_epoch INTEGER NOT NULL DEFAULT 0,
       corpus_hash TEXT NOT NULL DEFAULT '',
       coverage_json TEXT NOT NULL DEFAULT '{}',
-      created_at INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL DEFAULT 0, -- epoch ms (Date.now())
       UNIQUE(dedup_key, cohort_key)
     );
     CREATE INDEX IF NOT EXISTS idx_embedding_measurement_session
@@ -74238,7 +74564,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       importance_avg REAL,
       discarded_last INTEGER NOT NULL DEFAULT 0,
       legacy INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL
+      created_at INTEGER NOT NULL -- epoch ms (Date.now())
     );
     CREATE INDEX IF NOT EXISTS idx_historian_runs_session
       ON historian_runs(session_id, created_at DESC);
@@ -74291,7 +74617,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       importance INTEGER NOT NULL DEFAULT 50,
       episode_type TEXT,
       pass_number INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       harness TEXT NOT NULL DEFAULT 'opencode',
       UNIQUE(session_id, sequence)
     );
@@ -74302,7 +74628,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       category TEXT NOT NULL,
       content TEXT NOT NULL,
       pass_number INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL, -- epoch ms (Date.now())
       harness TEXT NOT NULL DEFAULT 'opencode'
     );
 
@@ -81305,6 +81631,7 @@ async function injectWasmOrt() {
   try {
     const { module: ortWeb, entryPath } = await importWasmOrtForRuntime();
     if (ortWeb.env?.wasm) {
+      ortWeb.env.wasm.numThreads = 1;
       ortWeb.env.wasm.wasmPaths = `${pathToFileURL2(dirname7(entryPath)).href}/`;
     }
     globalThis[Symbol.for("onnxruntime")] = ortWeb;
@@ -88642,6 +88969,19 @@ function normalizeSDKResponse(response, fallback, options) {
   return fallback;
 }
 // src/shared/prompt-surface-runtime.ts
+import { existsSync as existsSync12, readFileSync as readFileSync11, statSync as statSync10 } from "node:fs";
+import { dirname as dirname8, isAbsolute as isAbsolute5, resolve as resolve5 } from "node:path";
+
+// src/tools/light-descriptions.ts
+var CTX_REDUCE_LIGHT_DESCRIPTION = `Marking QUEUES content for release. It stays fully visible to you until it is actually released, which may be the next turn or many turns later. Newest tags stay protected until they age out. Release leaves a placeholder; recover only by rerunning the source or recovery tool. Mark only finished material. Mark analyzed, redundant, saved, or confirmatory outputs; keep user messages, unresolved errors, unextracted evidence, and exact wording. NEVER blanket-mark a large range: review every tag first.`;
+var CTX_EXPAND_LIGHT_DESCRIPTION = `For ctx_expand users, recover compacted conversation by passing a session-history heading's inclusive start/end ordinals. Results are raw [N] U:/A: transcript capped near 15K tokens; oversized ranges return the head and a continuation. Use verbose=true to list each message ordinal, part previews, and tool-output sizes; use message=N for one complete stored message and its tool exchanges. NEVER expand ranges after the last compartment because that live tail is already visible.`;
+var CTX_NOTE_LIGHT_DESCRIPTION = `For ctx_note: write saves, read lists, update changes one note (note_ids=[N]), dismiss retires 1–50 (note_ids); surface_condition makes a smart note. Smart-note conditions must be externally verifiable via GitHub, disk, git, or web—not this conversation or future actions.`;
+var CTX_MEMORY_LIGHT_DESCRIPTION = `For ctx_memory users, write one standalone durable fact with category and content; update one ID, archive one or more IDs, merge two or more IDs, or get one to twenty numeric IDs. get reads memories in every status; list remains dreamer-only, so primary agents must NEVER assume bulk-list access.`;
+var CTX_SEARCH_LIGHT_DESCRIPTION = `For ctx_search users, retrieve only hidden recall: memories not in <project-memory>, compacted messages outside the live tail, commits, and notes; phrase query as a question carrying exact terms. Omit sources for broad search; select memory, message, git_commit, or note, or pass memory IDs directly. Hits expand through ctx_expand.`;
+
+// src/shared/prompt-surface-runtime.ts
+var GUIDANCE_MARKER = "## Magic Context";
+var GUIDANCE_MARKER_LINE = /^## Magic Context[\t ]*\r?$/gm;
 var ACTIVE_TOOL_IDS = [
   "ctx_reduce",
   "ctx_expand",
@@ -88649,7 +88989,99 @@ var ACTIVE_TOOL_IDS = [
   "ctx_memory",
   "ctx_search"
 ];
+var LIGHT_TOOL_DESCRIPTIONS = {
+  ctx_reduce: CTX_REDUCE_LIGHT_DESCRIPTION,
+  ctx_expand: CTX_EXPAND_LIGHT_DESCRIPTION,
+  ctx_note: CTX_NOTE_LIGHT_DESCRIPTION,
+  ctx_memory: CTX_MEMORY_LIGHT_DESCRIPTION,
+  ctx_search: CTX_SEARCH_LIGHT_DESCRIPTION
+};
 var PROMPT_SURFACE_TOOL_ID_SET = new Set(ACTIVE_TOOL_IDS);
+function resolveUserConfigDirectory(options) {
+  if (options.userConfigDirectory)
+    return resolve5(options.userConfigDirectory);
+  const sharedBase = cortexKitUserConfigBasePath();
+  const shared = detectConfigFile(sharedBase);
+  if (shared.format !== "none")
+    return dirname8(shared.path);
+  if (options.harness) {
+    const legacy = resolveLegacyConfigSourcesForHarness(options.directory ?? process.cwd(), options.harness === "omp" ? "pi" : options.harness === "opencode2" ? "opencode" : options.harness).user.find((source) => existsSync12(source.path));
+    if (legacy)
+      return dirname8(legacy.path);
+  }
+  return dirname8(sharedBase);
+}
+function markerCount(content) {
+  return content.match(GUIDANCE_MARKER_LINE)?.length ?? 0;
+}
+function createPromptSurfaceRuntime(options) {
+  const userConfigDirectory = resolveUserConfigDirectory(options);
+  const warned = new Set;
+  const warnOnce = (key, message) => {
+    if (warned.has(key))
+      return;
+    warned.add(key);
+    options.warn(message);
+  };
+  const readGuidanceOverride = (configuredPath) => {
+    if (!configuredPath)
+      return;
+    const path = isAbsolute5(configuredPath) ? configuredPath : resolve5(userConfigDirectory, configuredPath);
+    let content;
+    try {
+      if (!statSync10(path).isFile()) {
+        warnOnce(`guidance-not-file:${path}`, `prompt_surface.guidance_override_path (${path}) is not a file; using built-in guidance.`);
+        return;
+      }
+      content = readFileSync11(path, "utf8");
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warnOnce(`guidance-unreadable:${path}:${reason}`, `prompt_surface.guidance_override_path (${path}) could not be read (${reason}); using built-in guidance.`);
+      return;
+    }
+    if (content.trim().length === 0) {
+      warnOnce(`guidance-empty:${path}`, `prompt_surface.guidance_override_path (${path}) is empty; using built-in guidance.`);
+      return;
+    }
+    const markers = markerCount(content);
+    if (markers !== 1) {
+      warnOnce(`guidance-marker-count:${path}:${markers}`, `prompt_surface.guidance_override_path (${path}) must contain exactly one ${JSON.stringify(GUIDANCE_MARKER)} section marker; found ${markers}. Using built-in guidance.`);
+      return;
+    }
+    return content;
+  };
+  return {
+    resolveRegistration(config, modelKey) {
+      const { preset } = resolvePromptSurface(config, modelKey);
+      const overrides = config?.tool_descriptions ?? {};
+      for (const [toolId, description] of Object.entries(overrides)) {
+        if (!PROMPT_SURFACE_TOOL_ID_SET.has(toolId)) {
+          warnOnce(`unknown-tool:${toolId}`, `prompt_surface.tool_descriptions.${toolId} is not a known ctx_* tool ID; the override was ignored.`);
+        } else if (description.trim().length === 0) {
+          warnOnce(`empty-tool:${toolId}`, `prompt_surface.tool_descriptions.${toolId} is empty; the override was ignored.`);
+        }
+      }
+      return {
+        preset,
+        descriptionFor(toolId, fullDescription) {
+          if (!PROMPT_SURFACE_TOOL_ID_SET.has(toolId))
+            return fullDescription;
+          const override = overrides[toolId];
+          if (override !== undefined && override.trim().length > 0)
+            return override;
+          return preset === "light" ? LIGHT_TOOL_DESCRIPTIONS[toolId] : fullDescription;
+        }
+      };
+    },
+    resolveGuidance(config, modelKey) {
+      const { preset } = resolvePromptSurface(config, modelKey);
+      return {
+        preset,
+        primaryOverride: readGuidanceOverride(config?.guidance_override_path)
+      };
+    }
+  };
+}
 var guidanceEpochCacheByRuntime = new WeakMap;
 function createPromptSurfaceGuidanceEpochCache(runtime) {
   const shared = guidanceEpochCacheByRuntime.get(runtime);
@@ -88972,7 +89404,7 @@ init_logger();
 // src/features/magic-context/compaction-marker.ts
 init_logger();
 import { createHash as createHash16 } from "node:crypto";
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
@@ -89044,10 +89476,16 @@ function getWritableOpenCodeDb() {
       closeQuietly(cachedWriteDb.db);
     } catch {}
   }
-  if (!existsSync12(dbPath)) {
+  if (!existsSync13(dbPath)) {
     throw new Error(`OpenCode database not found at ${dbPath} (source=${resolution.source}; is OpenCode installed?)`);
   }
   const db = new Database(dbPath);
+  try {
+    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+  } catch (error) {
+    closeQuietly(db);
+    throw error;
+  }
   db.exec("PRAGMA busy_timeout=5000");
   db.exec("PRAGMA journal_mode=WAL");
   cachedWriteDb = { path: dbPath, db };
@@ -94704,17 +95142,65 @@ function persistFilteredNoise(db, sessionId, chunk, eligibleEnd) {
 }
 
 // src/hooks/magic-context/producer-window-guard.ts
-var PRODUCER_WINDOW_REFUSAL_MARGIN = 0.15;
+var PRODUCER_WINDOW_REFUSAL_MARGIN = 0.03;
+var HISTORIAN_TRUNCATION_MARKER = "[… tokens truncated by Magic Context to fit the historian window …]";
+function producerInputTokenLimit(contextLimitTokens, maxOutputTokens) {
+  if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0 || !Number.isFinite(maxOutputTokens) || maxOutputTokens < 0) {
+    return;
+  }
+  const usableInputTokens = Math.max(0, Math.floor(contextLimitTokens - maxOutputTokens));
+  return Math.max(0, Math.floor(usableInputTokens * (1 - PRODUCER_WINDOW_REFUSAL_MARGIN)));
+}
 function producerWindowFailureReason(input) {
   const { producerSourceTokens, contextLimitTokens, maxOutputTokens } = input;
-  if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0 || !Number.isFinite(producerSourceTokens) || producerSourceTokens <= 0 || !Number.isFinite(maxOutputTokens) || maxOutputTokens < 0) {
+  const producerInputLimitTokens = producerInputTokenLimit(contextLimitTokens, maxOutputTokens);
+  if (producerInputLimitTokens === undefined || typeof contextLimitTokens !== "number" || !Number.isFinite(producerSourceTokens) || producerSourceTokens <= 0) {
     return null;
   }
   const usableInputTokens = Math.max(0, Math.floor(contextLimitTokens - maxOutputTokens));
-  const refusalThreshold = usableInputTokens * (1 + PRODUCER_WINDOW_REFUSAL_MARGIN);
-  if (producerSourceTokens < refusalThreshold)
+  if (producerSourceTokens <= producerInputLimitTokens)
     return null;
-  return `producer_source_exceeds_window producer_source_tokens=${Math.round(producerSourceTokens)} usable_input_tokens=${usableInputTokens} context_limit_tokens=${Math.round(contextLimitTokens)} max_output_tokens=${Math.round(maxOutputTokens)} refusal_margin=${PRODUCER_WINDOW_REFUSAL_MARGIN}`;
+  return `producer_source_exceeds_window producer_source_tokens=${Math.round(producerSourceTokens)} usable_input_tokens=${usableInputTokens} producer_input_limit_tokens=${producerInputLimitTokens} context_limit_tokens=${Math.round(contextLimitTokens)} max_output_tokens=${Math.round(maxOutputTokens)} estimator_margin=${PRODUCER_WINDOW_REFUSAL_MARGIN}`;
+}
+function splitMarkerPair() {
+  return `
+${HISTORIAN_TRUNCATION_MARKER}
+${HISTORIAN_TRUNCATION_MARKER}
+`;
+}
+function fitAtomicHistorianSourceToProducerWindow(args) {
+  const producerInputLimitTokens = producerInputTokenLimit(args.contextLimitTokens, args.maxOutputTokens);
+  const originalTokens = estimateTokens(args.text);
+  if (producerInputLimitTokens === undefined || originalTokens < producerInputLimitTokens || producerInputLimitTokens <= 0) {
+    return { text: args.text, producerInputLimitTokens, removedTokens: 0 };
+  }
+  const boundary = [...args.resultBoundaries ?? []].filter((candidate) => Number.isFinite(candidate.sourceOffset) && candidate.sourceOffset > 0 && candidate.sourceOffset < args.text.length).sort((a, b) => b.bodyTokens - a.bodyTokens || a.ordinal - b.ordinal)[0];
+  const splitOffset = boundary?.sourceOffset ?? Math.floor(args.text.length / 2);
+  const left = args.text.slice(0, splitOffset);
+  const right = args.text.slice(splitOffset);
+  const markers = splitMarkerPair();
+  const target = producerInputLimitTokens;
+  let lo = 0;
+  let hi = 1;
+  let best = markers;
+  for (let iteration = 0;iteration < 48; iteration++) {
+    const scale = (lo + hi) / 2;
+    const leftLength = Math.floor(left.length * scale);
+    const rightLength = Math.floor(right.length * scale);
+    const candidate = left.slice(0, leftLength) + markers + right.slice(right.length - rightLength);
+    if (estimateTokens(candidate) <= target) {
+      best = candidate;
+      lo = scale;
+    } else {
+      hi = scale;
+    }
+  }
+  return {
+    text: best,
+    producerInputLimitTokens,
+    ...boundary ? { splitBoundaryOrdinal: boundary.ordinal } : {},
+    removedTokens: Math.max(0, originalTokens - estimateTokens(best))
+  };
 }
 
 // src/hooks/magic-context/protected-tail-boundary.ts
@@ -97075,6 +97561,25 @@ function shouldSuppressHistorianAlert(sessionId) {
   lastHistorianAlertBySession.set(sessionId, Date.now());
   return false;
 }
+function findDanglingPublicationBoundary(sessionId, compartments, resolveOrdinal = readRawSessionMessageOrdinalById) {
+  for (const compartment of compartments) {
+    if (resolveOrdinal(sessionId, compartment.startMessageId) === null) {
+      return {
+        sequence: compartment.sequence,
+        side: "start",
+        messageId: compartment.startMessageId
+      };
+    }
+    if (resolveOrdinal(sessionId, compartment.endMessageId) === null) {
+      return {
+        sequence: compartment.sequence,
+        side: "end",
+        messageId: compartment.endMessageId
+      };
+    }
+  }
+  return null;
+}
 async function runCompartmentAgent(deps) {
   const {
     client,
@@ -97278,11 +97783,20 @@ async function runCompartmentAgent(deps) {
       rollbackDrainReservation();
       return;
     }
-    const chunkText = chunk.oversizeAtomicUnit ? chunk.text : truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
+    const fittedAtomicSource = chunk.oversizeAtomicUnit ? fitAtomicHistorianSourceToProducerWindow({
+      text: chunk.text,
+      resultBoundaries: chunk.toolResultBoundaries,
+      contextLimitTokens: deps.historianContextLimit,
+      maxOutputTokens: deps.historianMaxOutputTokens ?? 32000
+    }) : null;
+    const chunkText = chunk.oversizeAtomicUnit ? fittedAtomicSource?.text ?? chunk.text : truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
     const producerSourceTokens = estimateTokens(chunkText);
     if (boundarySnapshot.oversizeAtomicUnit || chunk.oversizeAtomicUnit) {
       sessionLog(sessionId, `historian oversize admission: range=${chunk.startIndex}-${chunk.endIndex} rawComponentTokens=${boundarySnapshot.diagnostics?.head.completedFence.tokenMass ?? "unknown"} perRunCap=${perRunCap} producerSourceTokens=${producerSourceTokens} historianChunkTokens=${historianChunkTokens}; ${describeBoundaryDiagnostics(boundarySnapshot)}`);
     }
+    if (fittedAtomicSource && fittedAtomicSource.removedTokens > 0) {
+      sessionLog(sessionId, `historian pathological component split: range=${chunk.startIndex}-${chunk.endIndex} resultBoundary=${fittedAtomicSource.splitBoundaryOrdinal ?? "midpoint"} removedTokens=${fittedAtomicSource.removedTokens} producerSourceTokens=${producerSourceTokens} producerInputLimitTokens=${fittedAtomicSource.producerInputLimitTokens ?? "unknown"}`);
+    }
     const producerWindowFailure = producerWindowFailureReason({
       producerSourceTokens,
       contextLimitTokens: deps.historianContextLimit,
@@ -97413,6 +97927,16 @@ ${chunkText}`,
       return;
     }
     const compartmentTagKeys = await getRawSessionTagKeysThrough(sessionId, lastCompartmentEnd, { db });
+    const danglingBoundary = findDanglingPublicationBoundary(sessionId, newCompartments);
+    if (danglingBoundary) {
+      const reason = `compartment boundary disappeared before publication (sequence=${danglingBoundary.sequence} side=${danglingBoundary.side} missing_id=${danglingBoundary.messageId})`;
+      telemetry.failureReason = `publish-boundary: ${reason}`;
+      sessionLog(sessionId, `historian publish refused: sequence=${danglingBoundary.sequence} side=${danglingBoundary.side} missing_id=${danglingBoundary.messageId}; raw snapshot changed during the historian run`);
+      const failCount = incrementHistorianFailure(db, sessionId, reason);
+      await notifyHistorianIssue(buildHistorianFailureNotice(failCount, reason));
+      rollbackDrainReservation();
+      return;
+    }
     let published = false;
     const transactionStartedAt = performance.now();
     db.exec("BEGIN IMMEDIATE");
@@ -98319,7 +98843,7 @@ function canConsumeDeferredOnThisPass(args) {
   return args.schedulerDecision === "execute" || args.contextPercentage >= (args.forceMaterializationPercentage ?? escalationBands(65).forceMaterializationPercentage);
 }
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.agentDrop;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory;
 }
 
 // src/hooks/magic-context/caveman-cleanup.ts
@@ -98441,7 +98965,7 @@ function replayCavemanCompression(sessionId, db, targets, tags) {
 }
 
 // src/hooks/magic-context/compaction-off-transition.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 init_logger();
 var loggedUnverifiedMarkerCleanupRetry = false;
 var COMPACTION_OFF_FLIP_NOTICE = [
@@ -98477,7 +99001,7 @@ function clearCachedM0Baseline(db, sessionId) {
   return (result.changes ?? 0) > 0;
 }
 function cleanupOffMarkers(sessionId) {
-  if (!existsSync13(getOpenCodeDbPath())) {
+  if (!existsSync14(getOpenCodeDbPath())) {
     return { verified: true, removedLineages: 0, removedRows: 0, retainedLineages: 0 };
   }
   return removeMcOwnedCompactionMarkers(sessionId, MARKER_SUMMARY_TEXT);
@@ -99440,7 +99964,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash19, randomUUID as randomUUID4 } from "node:crypto";
 init_logger();
 
 // src/hooks/magic-context/module-state-sync.ts
@@ -99681,11 +100205,35 @@ function toFlatModuleWireBody(payload) {
 function moduleWireBodyBytes(payload) {
   return Buffer.byteLength(JSON.stringify(toFlatModuleWireBody(payload)));
 }
-function buildPagedModuleTransformPayloads(body, pageMaxBytes = MODULE_PAGE_MAX_BYTES) {
+function buildPagedModuleTransformPayloads(body, pageMaxBytes = MODULE_PAGE_MAX_BYTES, forcePageEnvelope = false) {
   const serializedBody = JSON.stringify(body);
   const unpagedBytes = Buffer.byteLength(serializedBody);
-  if (unpagedBytes <= pageMaxBytes)
-    return [{ page: body, bytes: unpagedBytes }];
+  if (unpagedBytes <= pageMaxBytes) {
+    if (!forcePageEnvelope)
+      return [{ page: body, bytes: unpagedBytes }];
+    const pageContent = Object.fromEntries([
+      "input",
+      "messages",
+      "native_messages",
+      "ts_output",
+      "ts_ck_messages",
+      "normalizations",
+      "tool_input_key_orders"
+    ].filter((field) => {
+      const value = body[field];
+      return Array.isArray(value) || value !== null && typeof value === "object" && field === "tool_input_key_orders";
+    }).map((field) => [field, body[field]]));
+    const page = {
+      transform_page_id: crypto2.createHash("sha256").update(serializedBody).digest("hex"),
+      transform_generation: body.shadow_generation ?? 0,
+      transform_page_index: 0,
+      transform_page_total: 1,
+      transform_page_complete: true,
+      transform_page_digest: transformPageDigest(pageContent),
+      ...body
+    };
+    return [{ page, bytes: Buffer.byteLength(JSON.stringify(page)) }];
+  }
   const arrayFields = [
     "input",
     "messages",
@@ -100329,36 +100877,43 @@ function canonicalOrdinalForMessageId(args) {
   args.state.idOrdinalMemo.set(args.messageId, canonical);
   return canonical;
 }
-function serializeCompartment(args) {
+var boundaryDiagnosticObserverForTest = null;
+function logBoundaryDiagnostic(sessionId, message) {
+  sessionLog(sessionId, message);
+  boundaryDiagnosticObserverForTest?.(message);
+}
+function readCompartmentBoundaryResolution(args) {
   const startRaw = args.readRawById(args.compartment.startMessageId);
   const endRaw = args.readRawById(args.compartment.endMessageId);
-  const startOrdinal = canonicalOrdinalForMessageId({
-    sessionId: args.sessionId,
-    raw: startRaw,
-    messageId: args.compartment.startMessageId,
-    generation: args.state.moduleGeneration,
-    state: args.state
-  });
-  const endOrdinal = canonicalOrdinalForMessageId({
-    sessionId: args.sessionId,
-    raw: endRaw,
-    messageId: args.compartment.endMessageId,
-    generation: args.state.moduleGeneration,
-    state: args.state
-  });
-  if (startOrdinal === "mismatch" || endOrdinal === "mismatch")
-    return "mismatch";
-  if (startOrdinal === null || endOrdinal === null)
-    return null;
-  const startCreatedAt = startRaw?.createdAt;
-  const endCreatedAt = endRaw?.createdAt;
+  return {
+    startRaw,
+    endRaw,
+    startOrdinal: canonicalOrdinalForMessageId({
+      sessionId: args.sessionId,
+      raw: startRaw,
+      messageId: args.compartment.startMessageId,
+      generation: args.state.moduleGeneration,
+      state: args.state
+    }),
+    endOrdinal: canonicalOrdinalForMessageId({
+      sessionId: args.sessionId,
+      raw: endRaw,
+      messageId: args.compartment.endMessageId,
+      generation: args.state.moduleGeneration,
+      state: args.state
+    })
+  };
+}
+function serializeCompartment(args) {
+  const startCreatedAt = args.startRaw?.createdAt;
+  const endCreatedAt = args.endRaw?.createdAt;
   const dateRange = typeof startCreatedAt === "number" && typeof endCreatedAt === "number" ? { start_date: formatDate(startCreatedAt), end_date: formatDate(endCreatedAt) } : {};
   return {
     sequence: args.compartment.sequence,
-    start_message: startOrdinal,
-    end_message: endOrdinal,
-    start_message_id: flatBlockIdForRawMessage(args.compartment.startMessageId, startRaw, "start"),
-    end_message_id: flatBlockIdForRawMessage(args.compartment.endMessageId, endRaw, "end"),
+    start_message: args.startOrdinal,
+    end_message: args.endOrdinal,
+    start_message_id: flatBlockIdForRawMessage(args.compartment.startMessageId, args.startRaw, "start"),
+    end_message_id: flatBlockIdForRawMessage(args.compartment.endMessageId, args.endRaw, "end"),
     ...dateRange,
     title: args.compartment.title,
     content: args.compartment.content,
@@ -100372,6 +100927,15 @@ function serializeCompartment(args) {
     created_at: args.compartment.createdAt
   };
 }
+function adjacentCompartmentBoundaryId(args) {
+  const previous = args.direction === "previous";
+  const row = args.db.prepare(`SELECT ${previous ? "end_message_id" : "start_message_id"} AS message_id
+               FROM compartments
+              WHERE session_id = ? AND sequence ${previous ? "<" : ">"} ?
+              ORDER BY sequence ${previous ? "DESC" : "ASC"}
+              LIMIT 1`).get(args.sessionId, args.sequence);
+  return typeof row?.message_id === "string" && row.message_id.length > 0 ? row.message_id : null;
+}
 function seedBoundaryFromSerializedCompartments(compartments) {
   const serialized = compartments.filter(isRecord3).filter((compartment) => typeof compartment.sequence === "number" && typeof compartment.end_message_id === "string");
   serialized.sort((left, right) => left.sequence - right.sequence);
@@ -100844,21 +101408,102 @@ async function buildModuleStateSyncPayload(args) {
   const compartments = [];
   let serializedCount = 0;
   const compartmentsToSerialize = compartmentsChanged ? args.force ? inventory ? readCompartmentsAfterSequence(args.pass.db, args.pass.sessionId, inventory.maxCompartmentSequence) : getCompartments(args.pass.db, args.pass.sessionId) : readCompartmentsAfterSequence(args.pass.db, args.pass.sessionId, acked.compartment_sequence) : [];
-  for (const compartment of compartmentsToSerialize) {
-    args.options?.beforeSerializeCompartment?.();
-    if (args.options?.shouldAbortSeed?.())
-      return "seed_budget";
-    const serialized = serializeCompartment({
+  const boundaryResolutions = new Map;
+  const resolveBoundary = (compartment) => {
+    const cached = boundaryResolutions.get(compartment.sequence);
+    if (cached)
+      return cached;
+    const resolved = readCompartmentBoundaryResolution({
       compartment,
       sessionId: args.pass.sessionId,
       readRawById,
       state: args.state
     });
-    if (serialized === "mismatch")
+    boundaryResolutions.set(compartment.sequence, resolved);
+    return resolved;
+  };
+  const canonicalOrdinalForAdjacentId = (messageId) => {
+    if (!messageId)
+      return null;
+    const raw = readRawById(messageId);
+    return canonicalOrdinalForMessageId({
+      sessionId: args.pass.sessionId,
+      raw,
+      messageId,
+      generation: args.state.moduleGeneration,
+      state: args.state
+    });
+  };
+  let firstRawOrdinal;
+  for (const [index, compartment] of compartmentsToSerialize.entries()) {
+    args.options?.beforeSerializeCompartment?.();
+    if (args.options?.shouldAbortSeed?.())
+      return "seed_budget";
+    const boundary = resolveBoundary(compartment);
+    if (boundary.startOrdinal === "mismatch" || boundary.endOrdinal === "mismatch") {
       return "mismatch";
-    if (serialized === null)
-      return "unresolved";
-    compartments.push(serialized);
+    }
+    const startMissing = boundary.startOrdinal === null;
+    const endMissing = boundary.endOrdinal === null;
+    if (startMissing && endMissing) {
+      logBoundaryDiagnostic(args.pass.sessionId, `state-sync compartment skipped session=${args.pass.sessionId} sequence=${compartment.sequence} missing_start_id=${compartment.startMessageId} missing_end_id=${compartment.endMessageId} method=both_boundaries_dangling`);
+      continue;
+    }
+    let startOrdinal = boundary.startOrdinal;
+    if (startOrdinal === null) {
+      const previous = compartmentsToSerialize[index - 1];
+      const previousBoundaryId = previous ? previous.endMessageId : adjacentCompartmentBoundaryId({
+        db: args.pass.db,
+        sessionId: args.pass.sessionId,
+        sequence: compartment.sequence,
+        direction: "previous"
+      });
+      const previousEnd = previous ? resolveBoundary(previous).endOrdinal : canonicalOrdinalForAdjacentId(previousBoundaryId);
+      if (previousEnd === "mismatch")
+        return "mismatch";
+      if (typeof previousEnd === "number") {
+        startOrdinal = previousEnd + 1;
+        logBoundaryDiagnostic(args.pass.sessionId, `state-sync boundary repaired session=${args.pass.sessionId} sequence=${compartment.sequence} side=start missing_id=${compartment.startMessageId} resolved_ordinal=${startOrdinal} method=previous_compartment_end_plus_one`);
+      } else if (previousBoundaryId === null) {
+        if (firstRawOrdinal === undefined) {
+          const ordinals = [
+            ...readRawSessionMessageIdOrdinals(args.pass.sessionId).values()
+          ].filter((ordinal) => ordinal >= 1).sort((left, right) => left - right);
+          firstRawOrdinal = ordinals[0] ?? null;
+        }
+        startOrdinal = firstRawOrdinal;
+        if (startOrdinal !== null) {
+          logBoundaryDiagnostic(args.pass.sessionId, `state-sync boundary repaired session=${args.pass.sessionId} sequence=${compartment.sequence} side=start missing_id=${compartment.startMessageId} resolved_ordinal=${startOrdinal} method=raw_store_first_ordinal`);
+        }
+      }
+    }
+    let endOrdinal = boundary.endOrdinal;
+    if (endOrdinal === null) {
+      const next = compartmentsToSerialize[index + 1];
+      const nextStart = next ? resolveBoundary(next).startOrdinal : canonicalOrdinalForAdjacentId(adjacentCompartmentBoundaryId({
+        db: args.pass.db,
+        sessionId: args.pass.sessionId,
+        sequence: compartment.sequence,
+        direction: "next"
+      }));
+      if (nextStart === "mismatch")
+        return "mismatch";
+      if (typeof nextStart === "number") {
+        endOrdinal = nextStart - 1;
+        logBoundaryDiagnostic(args.pass.sessionId, `state-sync boundary repaired session=${args.pass.sessionId} sequence=${compartment.sequence} side=end missing_id=${compartment.endMessageId} resolved_ordinal=${endOrdinal} method=next_compartment_start_minus_one`);
+      }
+    }
+    if (startOrdinal === null || endOrdinal === null || startOrdinal > endOrdinal) {
+      logBoundaryDiagnostic(args.pass.sessionId, `state-sync compartment skipped session=${args.pass.sessionId} sequence=${compartment.sequence} missing_start_id=${startMissing ? compartment.startMessageId : "none"} missing_end_id=${endMissing ? compartment.endMessageId : "none"} method=${startOrdinal !== null && endOrdinal !== null ? "invalid_repaired_range" : "no_adjacent_canonical_boundary"}`);
+      continue;
+    }
+    compartments.push(serializeCompartment({
+      compartment,
+      startRaw: boundary.startRaw,
+      endRaw: boundary.endRaw,
+      startOrdinal,
+      endOrdinal
+    }));
     serializedCount += 1;
     const yieldEvery = Math.max(1, args.options?.yieldEveryCompartments ?? 10);
     if (serializedCount % yieldEvery === 0) {
@@ -103763,7 +104408,8 @@ async function runPostTransformPhase(args) {
   const firstRenderBust = m0M1EnabledForFold && !completeCachedPrefixAvailable;
   let foldExecutedThisPass = false;
   let publishedM1RefreshedThisPass = false;
-  const softRefreshOpportunity = args.schedulerDecision === "execute";
+  let prefixPreflightFailed = false;
+  const softRefreshOpportunity = args.schedulerDecision === "execute" || deferredMaterialize;
   let m0RematerializedThisPass = false;
   const m0CoverageBeforeFold = args.sessionMeta.cachedM0Bytes === null ? -1 : args.sessionMeta.cachedM0MaxCompartmentSeq;
   let m0MaterializeReason = null;
@@ -103790,6 +104436,7 @@ async function runPostTransformPhase(args) {
         compactionOff
       });
       preparedPrefix = foldResult;
+      prefixPreflightFailed = foldResult.materializationContentionRetryExhausted === true;
       foldExecutedThisPass = foldExecutesThisPass(foldDueDecision.value || softRefreshOpportunity, foldResult.m0RematerializedThisPass);
       publishedM1RefreshedThisPass = !foldResult.materializationContentionRetryExhausted && previousM1 !== args.sessionMeta.cachedM1Bytes?.toString("utf8");
       m0RematerializedThisPass = foldResult.m0RematerializedThisPass;
@@ -103811,29 +104458,29 @@ async function runPostTransformPhase(args) {
       }
     } catch (error) {
       preparedPrefix = cachedPrefixBeforePreflight;
+      prefixPreflightFailed = true;
       args.passOutcome?.record("m0-m1-fold-preexecution-degradation");
       sessionLog(args.sessionId, "transform: m[0] HARD fold pre-execution failed:", getErrorMessage(error));
     }
     sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${foldDueDecision.reason ?? "unknown"} executed=${foldExecutedThisPass}`);
   }
-  const publishedWorkDrainAllowed = args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || emergencyDropEligible || foldExecutedThisPass || firstRenderBust;
-  const shouldReadPendingOps = !compactionOff && (materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
+  const shouldReadPendingOps = !compactionOff && (materializationRequested || publishedM1RefreshedThisPass || args.schedulerDecision === "execute" || forceMaterialization || foldExecutedThisPass || firstRenderBust || compartmentRunning);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
   const formatPendingOpsDepth = () => {
     const depth = getPendingOpsCount(args.db, args.sessionId);
     return depth === null ? "not loaded (deferred pass)" : String(depth);
   };
-  const shouldApplyPendingOps = !compactionOff && (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || foldExecutedThisPass || firstRenderBust) && publishedWorkDrainAllowed;
   const rideSignals = {
     hardFold: foldExecutedThisPass || firstRenderBust,
-    force: forceMaterialization || emergencyDropEligible,
-    explicitFlush: isExplicitFlush,
-    publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart),
-    agentDrop: false
-  };
-  let shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldExecutedThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
-  let isCacheBustingPass = !compactionOff && hasReclaimRide(rideSignals);
+    force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
+    explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
+    publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
+  };
+  const publishedWorkDrainAllowed = !compactionOff && hasReclaimRide(rideSignals);
+  const shouldApplyPendingOps = publishedWorkDrainAllowed;
+  const shouldRunHeuristics = !compactionOff && hasReclaimRide(rideSignals) && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldExecutedThisPass || firstRenderBust || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const isCacheBustingPass = publishedWorkDrainAllowed;
   if (isCacheBustingPass && args.client && args.ctxReduceAvailability.callable && !hasLoggedCtxReducePermissionDeny(args.sessionId)) {
     try {
       const denied = await resolveToolPermissionDenied(args.client, args.sessionId, "ctx_reduce", args.activeAgent);
@@ -103859,13 +104506,8 @@ async function runPostTransformPhase(args) {
   if (!shouldApplyPendingOps && args.schedulerDeferReason !== undefined && args.schedulerDeferReason !== null) {
     sessionLog(args.sessionId, `pending ops WILL NOT APPLY — reason=${args.schedulerDeferReason} pendingOps=${formatPendingOpsDepth()} context=${args.contextUsage.percentage.toFixed(1)}%`);
   }
-  if (compartmentRunning && hasPendingUserOps) {
-    if (publishedWorkDrainAllowed) {
-      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");
-    }
+  if (hasPendingUserOps && !shouldApplyPendingOps) {
+    sessionLog(args.sessionId, `pending ops held — reason=no originating cache-bust opportunity; scheduler=${args.schedulerDecision}, historianRunning=${compartmentRunning}`);
   }
   let explicitMaterializedSuccessfully = false;
   let deferredMaterializedSuccessfully = false;
@@ -103897,9 +104539,6 @@ async function runPostTransformPhase(args) {
       const tApply = performance.now();
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.contextUsage.percentage >= 95 ? newestCtxReduceTagNumbers(getTagsBySession(args.db, args.sessionId)) : args.protectedTagIds, undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
       if (pendingOpsDidMutate) {
-        rideSignals.agentDrop = true;
-        isCacheBustingPass = hasReclaimRide(rideSignals);
-        shouldRunHeuristics = isCacheBustingPass;
         droppedCount += pendingOps.length;
         for (const pendingOp of pendingOps) {
           const message = args.targets.get(pendingOp.tagId)?.message;
@@ -104661,6 +105300,8 @@ var RUST_PARK_RETRY_INTERVAL = 5;
 var RUST_EMERGENCY_WALL_PCT = 95;
 var RUST_PARK_PROBE_PRESSURE_BYPASS_PCT = 90;
 var RUST_SEND_TIMEOUT_MS = 15000;
+var RUST_SILENT_RESEND_AFTER_MS = 1e4;
+var RUST_HEALTH_PROBE_TIMEOUT_MS = 2000;
 var RUST_LKG_FROZEN_HEALTHY_PASS_LIMIT = 8;
 var RUST_LKG_FROZEN_RAW_TAIL_GROWTH_LIMIT = 16;
 function activeAgentFromMessages(messages) {
@@ -105570,6 +106211,64 @@ function createRustModeTransform(deps, options) {
       clearTimeout(timer);
     }
   };
+  const callTransformWithSilentResend = async (args, attemptTimeoutMs) => {
+    const startedAtMs = Date.now();
+    const deadlineMs = startedAtMs + attemptTimeoutMs;
+    const silentAfterMs = options.silentResendAfterMsForTests ?? RUST_SILENT_RESEND_AFTER_MS;
+    const probeTimeoutMs = options.healthProbeTimeoutMsForTests ?? RUST_HEALTH_PROBE_TIMEOUT_MS;
+    const originalAttemptId = randomUUID4();
+    const originalBody = isRecord6(args.body) ? { ...args.body, attempt_id: originalAttemptId } : args.body;
+    const original = callModule({ ...args, body: originalBody }, attemptTimeoutMs);
+    if (attemptTimeoutMs <= silentAfterMs)
+      return original;
+    let silentTimer;
+    const first = await Promise.race([
+      original.then((response) => ({ kind: "response", response }), (error) => ({ kind: "error", error })),
+      new Promise((resolve) => {
+        silentTimer = setTimeout(() => resolve({ kind: "silent" }), silentAfterMs);
+      })
+    ]);
+    if (first.kind !== "silent")
+      clearTimeout(silentTimer);
+    if (first.kind === "response")
+      return first.response;
+    if (first.kind === "error")
+      throw first.error;
+    const probeBudgetMs = Math.min(probeTimeoutMs, Math.max(0, deadlineMs - Date.now()));
+    if (probeBudgetMs <= 0)
+      return original;
+    try {
+      await callModule({
+        sessionId: args.sessionId,
+        projectRoot: args.projectRoot,
+        method: "session.status",
+        body: {
+          method: "session.status",
+          v: 1,
+          session_id: args.sessionId
+        },
+        bypassSessionLane: true
+      }, probeBudgetMs);
+    } catch {
+      return original;
+    }
+    const remainingMs = Math.max(0, deadlineMs - Date.now());
+    if (remainingMs <= 0)
+      return original;
+    const resendAttemptId = randomUUID4();
+    sessionLog(args.sessionId, `rust silent resend original_attempt=${originalAttemptId} resend_attempt=${resendAttemptId} silent_gap_ms=${Date.now() - startedAtMs}`);
+    const resendBody = isRecord6(args.body) ? {
+      ...args.body,
+      attempt_id: resendAttemptId,
+      original_attempt_id: originalAttemptId,
+      resend: true
+    } : args.body;
+    return callModule({
+      ...args,
+      body: resendBody,
+      bypassSessionLane: true
+    }, remainingMs);
+  };
   const markFailure = (sessionId, state, error) => {
     state.consecutiveFailures = isNonRetryableStateSyncFailure(error) ? Math.max(RUST_FAILURE_PARK_THRESHOLD, state.consecutiveFailures + 1) : state.consecutiveFailures + 1;
     state.failureCount += 1;
@@ -105786,6 +106485,8 @@ function createRustModeTransform(deps, options) {
     } catch {}
     let appliedAt;
     let emergencyFailClosed = false;
+    let providerProvenEmergency = false;
+    let recoveryProjectRoot = options.projectRoot ?? deps.directory ?? "";
     const passUsageSnapshot = loadContextUsage(deps.contextUsageMap, deps.db, sessionId);
     requestInputTokens = Math.max(0, Math.floor(passUsageSnapshot.inputTokens));
     let preflightError;
@@ -105819,11 +106520,15 @@ function createRustModeTransform(deps, options) {
     }
     const transformGeometry = transformGeometryForWire(resolvedWindowGeometry);
     const hasTrustedEmergencyWall = transformGeometry ? transformGeometry.usable_hard > 0 : resolvedContextLimit !== undefined && resolvedContextLimit > 0;
-    emergencyFailClosed = isProviderOverflowFailClosedProven(sessionId) || hardWallUsagePercentage(passUsageSnapshot, transformGeometry) >= RUST_EMERGENCY_WALL_PCT && hasTrustedEmergencyWall;
+    const hardWallPercentage = hardWallUsagePercentage(passUsageSnapshot, transformGeometry);
+    const providerOverflowProven = isProviderOverflowFailClosedProven(sessionId);
+    emergencyFailClosed = providerOverflowProven || hardWallPercentage >= RUST_EMERGENCY_WALL_PCT && hasTrustedEmergencyWall;
     if (overflowState) {
       const detectedLimitMatchesModel = overflowState.detectedContextLimitModelKey === null || canonicalModelIdentity(overflowState.detectedContextLimitModelKey) === canonicalModelIdentity(modelKey ?? "");
       const hasProviderProof = overflowState.detectedContextLimit > 0 && detectedLimitMatchesModel || isProviderOverflowReconfirmed(sessionId);
-      emergencyFailClosed ||= overflowState.needsEmergencyRecovery && overflowState.emergencyRecoveryOrigin === "provider_overflow" && hasProviderProof;
+      const persistedProviderEmergency = overflowState.needsEmergencyRecovery && overflowState.emergencyRecoveryOrigin === "provider_overflow" && hasProviderProof;
+      emergencyFailClosed ||= persistedProviderEmergency;
+      providerProvenEmergency = hardWallPercentage >= RUST_EMERGENCY_WALL_PCT && (providerOverflowProven || persistedProviderEmergency);
     }
     const serveRawFallback = (cause) => {
       const contextLimit = transformGeometry?.usable_hard ?? resolvedContextLimit ?? (overflowState && overflowState.detectedContextLimit > 0 ? overflowState.detectedContextLimit : undefined);
@@ -106126,6 +106831,7 @@ function createRustModeTransform(deps, options) {
         nowMs: Date.now()
       };
       const projectRoot = options.projectRoot ?? directory;
+      recoveryProjectRoot = projectRoot;
       const authoritySeqAdoption = { used: false };
       const memorySyncRequested = options.memorySyncRequestedSessions?.delete(sessionId) === true;
       const currentStateSyncInputSignature = stateSyncInputSignature({
@@ -106320,7 +107026,7 @@ function createRustModeTransform(deps, options) {
       logStage(sessionId, "wireBuild", wireBuildStartedAt, timings, wireDelta ? `mode=tail_delta input=${encodedInput.length}` : "mode=full");
       const sendTransformSeries = async (payload, detail = "") => {
         const pagingStartedAt = performance.now();
-        const pages = buildPagedModuleTransformPayloads(payload, options.modulePageMaxBytes);
+        const pages = buildPagedModuleTransformPayloads(payload, options.modulePageMaxBytes, true);
         timings.paging += performance.now() - pagingStartedAt;
         const seedMessageCount = Array.isArray(payload.input) ? payload.input.length : Array.isArray(payload.messages) ? payload.messages.length : 0;
         const paged = pages.some((entry) => typeof entry.page.transform_page_id === "string");
@@ -106331,7 +107037,7 @@ function createRustModeTransform(deps, options) {
           try {
             const attemptClass = paged ? index === pages.length - 1 ? "transform_series_execute" : "transform_page_upload" : undefined;
             const attemptTimeoutMs = options.moduleTimeoutMs ?? (attemptClass === "transform_series_execute" ? transformColdStartExecuteTimeoutMs(seedMessageCount) : attemptClass === "transform_page_upload" ? TRANSFORM_PAGE_UPLOAD_TIMEOUT_MS : timeoutMs);
-            moduleResponse = await callModule({
+            const callArgs = {
               sessionId,
               projectRoot,
               method: "transform",
@@ -106342,7 +107048,8 @@ function createRustModeTransform(deps, options) {
               },
               generationSensitive: paged && index > 0,
               attemptClass
-            }, attemptTimeoutMs);
+            };
+            moduleResponse = page.transform_page_complete ? await callTransformWithSilentResend(callArgs, attemptTimeoutMs) : await callModule(callArgs, attemptTimeoutMs);
           } catch (error) {
             if (paged && isTransformPageAttemptMismatch(error)) {
               return {
@@ -106868,6 +107575,21 @@ function createRustModeTransform(deps, options) {
         sessionLog(sessionId, "mc_rust_emergency_refusal before_lkg");
         markFailure(sessionId, state, error);
         finishPass(false, false);
+        const refusedUser = newestUserMessage(messages);
+        const refusedUserMessageId = refusedUser ? messageIdOf(refusedUser) : null;
+        if (refusedUserMessageId) {
+          try {
+            options.onEngineReconnectRefusal?.({
+              sessionId,
+              projectRoot: recoveryProjectRoot,
+              refusedUserMessageId,
+              providerProvenEmergency,
+              compactionOff: deps.compactionOff === true
+            });
+          } catch (recoveryError) {
+            sessionLog(sessionId, "rust refusal recovery failed to arm:", recoveryError);
+          }
+        }
         throw new EmergencyFailClosedError(ENGINE_RECONNECTING_USER_MESSAGE, {
           cause: error
         });
@@ -107356,6 +108078,7 @@ function createTransform(deps) {
     projectRoot: deps.rustModeProjectRoot,
     notifyParked: deps.onRustModeParked,
     onProjectPrepared: deps.onRustModeProjectPrepared,
+    onEngineReconnectRefusal: deps.onRustEngineReconnectRefusal,
     memorySyncRequestedSessions: deps.rustMemorySyncRequestedSessions,
     allowAuthorityProtocolBypassForTests: deps.rustModeAllowAuthorityProtocolBypassForTests
   }) : undefined;
@@ -108437,6 +109160,264 @@ async function maybeSendUpgradeReminder(deps, sessionId) {
   }
 }
 
+// src/shared/conflict-detector.ts
+import { homedir as homedir10 } from "node:os";
+import { join as join12 } from "node:path";
+init_logger();
+
+// src/shared/opencode-config-dir.ts
+import { homedir as homedir9 } from "node:os";
+import { join as join11, resolve as resolve6 } from "node:path";
+function getCliConfigDir() {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envConfigDir) {
+    return resolve6(envConfigDir);
+  }
+  if (process.platform === "win32") {
+    return join11(homedir9(), ".config", "opencode");
+  }
+  return join11(process.env.XDG_CONFIG_HOME || join11(homedir9(), ".config"), "opencode");
+}
+function getOpenCodeConfigDir(_options) {
+  return getCliConfigDir();
+}
+function getOpenCodeConfigPaths(options) {
+  const configDir = getOpenCodeConfigDir(options);
+  return {
+    configDir,
+    configJson: join11(configDir, "opencode.json"),
+    configJsonc: join11(configDir, "opencode.jsonc"),
+    packageJson: join11(configDir, "package.json"),
+    omoConfig: join11(configDir, "magic-context.jsonc")
+  };
+}
+
+// src/shared/conflict-detector.ts
+function detectConflicts(directory, options) {
+  const compactionEnabled = options?.compactionEnabled ?? true;
+  const hostGeneration = options?.hostGeneration ?? "v1";
+  const conflicts = {
+    compactionAuto: false,
+    compactionPrune: false,
+    dcpPlugin: false,
+    omoPreemptiveCompaction: false,
+    omoContextWindowMonitor: false,
+    omoAnthropicRecovery: false
+  };
+  const reasons = [];
+  let compactionResult = options?.resolvedCompaction ?? checkCompaction(directory, hostGeneration);
+  if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+    compactionResult = { auto: false, prune: false };
+  }
+  if (hostGeneration === "v1" && compactionEnabled && compactionResult.auto) {
+    conflicts.compactionAuto = true;
+    reasons.push(options?.resolvedCompaction ? "OpenCode auto-compaction is enabled (compaction.auto=true) (resolved config)" : "OpenCode auto-compaction is enabled (compaction.auto=true)");
+  }
+  if (hostGeneration === "v1" && compactionEnabled && compactionResult.prune) {
+    conflicts.compactionPrune = true;
+    reasons.push(options?.resolvedCompaction ? "OpenCode prune is enabled (compaction.prune=true) (resolved config)" : "OpenCode prune is enabled (compaction.prune=true)");
+  }
+  const dcpFound = checkDcpPlugin(directory);
+  if (dcpFound) {
+    conflicts.dcpPlugin = true;
+    reasons.push("opencode-dcp plugin is installed — it conflicts with Magic Context's context management");
+  }
+  const omoResult = checkOmoHooks(directory);
+  if (omoResult.preemptiveCompaction) {
+    conflicts.omoPreemptiveCompaction = true;
+    reasons.push("oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian");
+  }
+  if (omoResult.contextWindowMonitor) {
+    conflicts.omoContextWindowMonitor = true;
+    reasons.push("oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges");
+  }
+  if (omoResult.anthropicRecovery) {
+    conflicts.omoAnthropicRecovery = true;
+    reasons.push("oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian");
+  }
+  return {
+    hasConflict: reasons.length > 0,
+    reasons,
+    conflicts,
+    nativeCompaction: {
+      auto: compactionResult.auto,
+      prune: hostGeneration === "v1" ? compactionResult.prune : false
+    }
+  };
+}
+function checkCompaction(directory, hostGeneration) {
+  if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+    return { auto: false, prune: false };
+  }
+  const projectResult = readProjectCompaction(directory, hostGeneration);
+  if (projectResult.resolved)
+    return projectResult;
+  const userResult = readUserCompaction(hostGeneration);
+  if (userResult.resolved)
+    return userResult;
+  return { auto: true, prune: false };
+}
+function readProjectCompaction(directory, hostGeneration) {
+  const dotOcJsonc = join12(directory, ".opencode", "opencode.jsonc");
+  const dotOcJson = join12(directory, ".opencode", "opencode.json");
+  const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
+  if (dotOcConfig?.compaction) {
+    const c = dotOcConfig.compaction;
+    if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
+      return resolvedCompactionBlock(c, hostGeneration);
+    }
+  }
+  const rootJsonc = join12(directory, "opencode.jsonc");
+  const rootJson = join12(directory, "opencode.json");
+  const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
+  if (rootConfig?.compaction) {
+    const c = rootConfig.compaction;
+    if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
+      return resolvedCompactionBlock(c, hostGeneration);
+    }
+  }
+  return { auto: false, prune: false, resolved: false };
+}
+function readUserCompaction(hostGeneration) {
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    const config = readJsoncFile(paths.configJsonc) ?? readJsoncFile(paths.configJson);
+    if (config?.compaction) {
+      const c = config.compaction;
+      if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
+        return resolvedCompactionBlock(c, hostGeneration);
+      }
+    }
+  } catch {}
+  return { auto: false, prune: false, resolved: false };
+}
+function resolvedCompactionBlock(block, hostGeneration) {
+  if (hostGeneration === "v2") {
+    return {
+      auto: block.auto !== false,
+      prune: false,
+      resolved: true,
+      ...typeof block.keep?.tokens === "number" ? { keepTokens: block.keep.tokens } : {},
+      ...typeof block.buffer === "number" ? { buffer: block.buffer } : {}
+    };
+  }
+  return { auto: block.auto === true, prune: block.prune === true, resolved: true };
+}
+var DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
+function checkDcpPlugin(directory) {
+  const plugins = collectPluginEntries(directory);
+  return plugins.some((p) => matchesPackageName(p, DCP_PACKAGE_NAMES));
+}
+function matchesPackageName(entry, canonicalNames) {
+  if (entry.startsWith("file:") || entry.startsWith("http:") || entry.startsWith("https:") || entry.startsWith("/") || entry.startsWith("./") || entry.startsWith("../")) {
+    return false;
+  }
+  const lastAt = entry.lastIndexOf("@");
+  const nameOnly = lastAt > 0 ? entry.slice(0, lastAt) : entry;
+  return canonicalNames.has(nameOnly);
+}
+function extractPluginName(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string")
+    return entry[0];
+  return null;
+}
+function collectPluginEntries(directory) {
+  const plugins = [];
+  const pushFrom = (entries) => {
+    if (!entries)
+      return;
+    for (const entry of entries) {
+      const name = extractPluginName(entry);
+      if (name)
+        plugins.push(name);
+    }
+  };
+  for (const configPath of [
+    join12(directory, ".opencode", "opencode.jsonc"),
+    join12(directory, ".opencode", "opencode.json"),
+    join12(directory, "opencode.jsonc"),
+    join12(directory, "opencode.json")
+  ]) {
+    const config = readJsoncFile(configPath);
+    pushFrom(config?.plugin);
+  }
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    for (const configPath of [paths.configJsonc, paths.configJson]) {
+      const config = readJsoncFile(configPath);
+      pushFrom(config?.plugin);
+    }
+  } catch {}
+  return plugins;
+}
+var OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
+function checkOmoHooks(directory) {
+  const result = {
+    preemptiveCompaction: false,
+    contextWindowMonitor: false,
+    anthropicRecovery: false
+  };
+  const plugins = collectPluginEntries(directory);
+  const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
+  if (!hasOmo)
+    return result;
+  const disabledHooks = readOmoDisabledHooks(directory);
+  result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
+  result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
+  result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
+  return result;
+}
+function readOmoDisabledHooks(directory) {
+  const disabled = new Set;
+  const configNames = [
+    "oh-my-opencode.jsonc",
+    "oh-my-opencode.json",
+    "oh-my-openagent.jsonc",
+    "oh-my-openagent.json"
+  ];
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    for (const name of configNames) {
+      const configPath = join12(paths.configDir, name);
+      const config = readJsoncFile(configPath);
+      if (config?.disabled_hooks) {
+        for (const hook of config.disabled_hooks) {
+          disabled.add(hook);
+        }
+      }
+    }
+  } catch {}
+  for (const name of configNames) {
+    const config = readJsoncFile(join12(directory, name));
+    if (config?.disabled_hooks) {
+      for (const hook of config.disabled_hooks) {
+        disabled.add(hook);
+      }
+    }
+  }
+  const homeDir = process.env.HOME || homedir10();
+  const omoHomeDir = join12(homeDir, ".omo");
+  for (const name of ["omo.jsonc", "omo.json"]) {
+    const config = readJsoncFile(join12(omoHomeDir, name));
+    if (config?.["[opencode]"]?.disabled_hooks) {
+      for (const hook of config["[opencode]"].disabled_hooks) {
+        disabled.add(hook);
+      }
+    }
+  }
+  for (const name of ["omo.jsonc", "omo.json"]) {
+    const config = readJsoncFile(join12(directory, ".omo", name));
+    if (config?.["[opencode]"]?.disabled_hooks) {
+      for (const hook of config["[opencode]"].disabled_hooks) {
+        disabled.add(hook);
+      }
+    }
+  }
+  return disabled;
+}
+
 // src/v2/hooks/context.ts
 init_data_path();
 
@@ -108808,7 +109789,240 @@ ${data.output?.output ?? ""}`
   return [...content.length ? [make("assistant", content)] : [], ...results];
 }
 
+// src/v2/hooks/hidden-child.ts
+var HIDDEN_HISTORIAN_AGENT = "historian";
+var HIDDEN_DREAMER_AGENT = "dreamer-classifier";
+async function registerHiddenChildAgents(agent) {
+  await agent.transform((editor) => {
+    for (const id of [HIDDEN_HISTORIAN_AGENT, HIDDEN_DREAMER_AGENT]) {
+      editor.update(id, (config) => {
+        config.system = "Magic Context hidden completion carrier.";
+        config.description = "Internal Magic Context hidden completion carrier.";
+        config.mode = "primary";
+        config.hidden = true;
+        config.request.settings = {};
+        config.request.headers = {};
+        config.request.body = {};
+        config.permissions = [{ action: "*", resource: "*", effect: "deny" }];
+      });
+    }
+  });
+}
+function newestUserText(draft) {
+  const message = draft.messages.at(-1);
+  if (!message || message.role !== undefined && message.role !== "user")
+    return;
+  const content = message.content;
+  if (typeof content === "string" && content.length > 0)
+    return content;
+  const parts = Array.isArray(content) ? content : Array.isArray(message.parts) ? message.parts : [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object")
+      continue;
+    const record = part;
+    if (typeof record.text !== "string" || record.text.length === 0)
+      continue;
+    if (record.type === undefined || record.type === "text" || record.type === "input_text") {
+      return record.text;
+    }
+  }
+  return;
+}
+function calibratedParts(attempt) {
+  const parts = attempt.request.body.parts;
+  if (!Array.isArray(parts) || parts.length === 0 || parts.some((part) => !part || typeof part !== "object" || part.type !== "text" || typeof part.text !== "string")) {
+    throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Hidden completion accepts text-only calibrated prompts", true);
+  }
+  return parts.map((part) => ({ type: "text", text: part.text }));
+}
+
+class HiddenChildHook {
+  childIDs = new Set;
+  attempts = new Map;
+  registerChild(sessionID) {
+    this.childIDs.add(sessionID);
+  }
+  registerAttempt(marker, attempt) {
+    this.registerChild(attempt.childSessionId);
+    this.attempts.set(marker, attempt);
+  }
+  releaseAttempt(marker) {
+    this.attempts.delete(marker);
+  }
+  owns(sessionID) {
+    return this.childIDs.has(sessionID);
+  }
+  apply(draft) {
+    if (!this.owns(draft.sessionID))
+      return false;
+    const raw = newestUserText(draft);
+    const stripped = raw === undefined ? undefined : stripWellFormedLeadingTagPrefix(raw);
+    const attempt = (raw !== undefined ? this.attempts.get(raw) : undefined) ?? (stripped && stripped !== raw ? this.attempts.get(stripped) : undefined);
+    if (!attempt || attempt.childSessionId !== draft.sessionID) {
+      throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Refusing an unregistered prompt on a Magic Context hidden-run session", true);
+    }
+    if (attempt.request.signal?.aborted) {
+      throw new Error("Hidden completion prompt aborted");
+    }
+    const system = typeof attempt.request.body.system === "string" ? attempt.request.body.system : attempt.identity.system;
+    const temperature = attempt.request.body.temperature;
+    draft.system = [{ type: "text", text: system }];
+    draft.messages = [{ role: "user", content: calibratedParts(attempt) }];
+    draft.options = {
+      maxOutputTokens: 32768,
+      maxTokens: 32768,
+      ...typeof temperature === "number" && Number.isFinite(temperature) ? { temperature } : {}
+    };
+    draft.tools = {};
+    attempt.shaped = true;
+    return true;
+  }
+}
+
 // src/v2/hidden-completion.ts
+var META_PREFIX = "opencode2_hidden_children:";
+var POLL_INTERVAL_MS = 200;
+function hiddenChildrenMetaKey(projectIdentity) {
+  return `${META_PREFIX}${projectIdentity}`;
+}
+function emptyMeta() {
+  return { version: 1, active: {}, retired_children: [] };
+}
+function isModel(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const model = value;
+  return typeof model.providerID === "string" && typeof model.modelID === "string";
+}
+function isRole(value) {
+  return value === "historian" || value === "dreamer";
+}
+function isPersistedChild(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const child = value;
+  return typeof child.id === "string" && isRole(child.role) && typeof child.generation === "string" && typeof child.title === "string" && isModel(child.model) && typeof child.created_at === "number" && typeof child.title_reasserted === "boolean";
+}
+function parseMeta(value) {
+  if (value === null)
+    return emptyMeta();
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error("Invalid OpenCode 2 hidden-child metadata JSON", { cause: error });
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Invalid OpenCode 2 hidden-child metadata");
+  }
+  const candidate = parsed;
+  if (candidate.version !== 1 || !candidate.active || !candidate.retired_children) {
+    throw new Error("Unsupported OpenCode 2 hidden-child metadata version");
+  }
+  const active = {};
+  for (const role of ["historian", "dreamer"]) {
+    const child = candidate.active[role];
+    if (child !== undefined) {
+      if (!isPersistedChild(child) || child.role !== role) {
+        throw new Error(`Invalid OpenCode 2 ${role} child metadata`);
+      }
+      active[role] = child;
+    }
+  }
+  const retired = candidate.retired_children;
+  if (!Array.isArray(retired) || retired.some((child) => !isPersistedChild(child) || typeof child.retired_at !== "number" || typeof child.reason !== "string")) {
+    throw new Error("Invalid OpenCode 2 retired-child metadata");
+  }
+  return { version: 1, active, retired_children: retired };
+}
+
+class HiddenChildStateStore {
+  db;
+  key;
+  constructor(db, projectIdentity) {
+    this.db = db;
+    this.key = hiddenChildrenMetaKey(projectIdentity);
+  }
+  read() {
+    const row = this.db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(this.key);
+    return parseMeta(row?.value ?? null);
+  }
+  mutate(change) {
+    return this.db.transaction(() => {
+      const state = this.read();
+      const result = change(state);
+      this.db.prepare(`INSERT INTO schema_migrations_meta (key, value) VALUES (?, ?)
+                     ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(this.key, JSON.stringify(state));
+      return result;
+    })();
+  }
+  put(child) {
+    this.mutate((state) => {
+      state.active[child.role] = child;
+    });
+  }
+  updateModel(child, model) {
+    return this.mutate((state) => {
+      const active = state.active[child.role];
+      if (!active || active.id !== child.id)
+        return { ...child, model };
+      active.model = model;
+      return { ...active };
+    });
+  }
+  markTitleReasserted(child) {
+    return this.mutate((state) => {
+      const active = state.active[child.role];
+      if (!active || active.id !== child.id)
+        return { ...child, title_reasserted: true };
+      active.title_reasserted = true;
+      return { ...active };
+    });
+  }
+  retire(child, reason) {
+    this.mutate((state) => {
+      const active = state.active[child.role];
+      if (!active || active.id !== child.id)
+        return;
+      state.retired_children.push({
+        ...active,
+        retired_at: Date.now(),
+        reason
+      });
+      delete state.active[child.role];
+    });
+  }
+}
+function modelKey(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return modelKey(left) === modelKey(right) && left.variant === right.variant;
+}
+function configuredHead(identity) {
+  const candidates = [identity.model, ...identity.configuredModels ?? []];
+  for (const candidate of candidates) {
+    const entry = toModelEntry(candidate);
+    const parsed = entry ? parseProviderModel(entry.model) : null;
+    if (parsed)
+      return { ...parsed, ...entry?.qualifier ? { variant: entry.qualifier } : {} };
+  }
+  return;
+}
+function roleFor(identity) {
+  return identity.kind === "dreamer-task" ? "dreamer" : "historian";
+}
+function roleTitle(role) {
+  return role === "historian" ? "Magic Context historian" : "Magic Context dreamer";
+}
+function roleAgent(role) {
+  return role === "historian" ? HIDDEN_HISTORIAN_AGENT : HIDDEN_DREAMER_AGENT;
+}
+function promptText(request) {
+  const parts = request.body.parts;
+  return Array.isArray(parts) ? parts.flatMap((part) => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []).join(`
+`) : "";
+}
 function meter(system, prompt, text) {
   return {
     input: estimateTokens(system) + estimateTokens(prompt),
@@ -108817,115 +110031,294 @@ function meter(system, prompt, text) {
     cacheWrite: 0
   };
 }
-async function createV2HiddenCompletionExecutor(host, currentModel) {
+function successfulReusableAssistant(row) {
+  return row !== undefined && typeof row.data.finish === "string" && row.data.error === undefined && row.data.tokens !== undefined;
+}
+function assistantText(row) {
+  const text = (row.data.content ?? []).flatMap((part) => part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("");
+  return text.length > 0 ? text : null;
+}
+function errorText(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function requestModel(request, current) {
+  const requested = request.body.model;
+  if (requested && typeof requested.providerID === "string" && typeof requested.modelID === "string") {
+    return {
+      providerID: requested.providerID,
+      modelID: requested.modelID,
+      ...typeof request.body.variant === "string" ? { variant: request.body.variant } : {}
+    };
+  }
+  return current;
+}
+function withReader(openReader, read) {
+  const reader = openReader();
+  try {
+    return read(reader);
+  } finally {
+    reader.close?.();
+  }
+}
+async function sleepUntilPoll(signal, deadline) {
+  if (signal?.aborted)
+    throw new Error("Hidden completion prompt aborted");
+  const delay = Math.min(POLL_INTERVAL_MS, Math.max(0, deadline - Date.now()));
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new Error("Hidden completion prompt aborted"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted)
+      abort();
+    else
+      setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+      }, delay);
+  });
+}
+async function awaitAssistantRow(openReader, childID, afterSeq, deadline, signal) {
+  for (;; ) {
+    const row = withReader(openReader, (reader) => reader.latestAssistant(childID));
+    if (row && row.seq > afterSeq) {
+      if (row.data.error !== undefined) {
+        throw new Error(`Hidden completion provider error: ${errorText(row.data.error)}`);
+      }
+      if (typeof row.data.finish === "string")
+        return row;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("Hidden completion timed out waiting for a persisted assistant row");
+    }
+    await sleepUntilPoll(signal, deadline);
+  }
+}
+async function createV2HiddenCompletionExecutor(host, options) {
   const runs = new WeakMap;
-  const pending = new Map;
-  const modelKey = (model) => `${model.providerID}/${model.modelID}`;
-  const requireModel = async (sessionID) => {
-    const model = sessionID ? await currentModel(sessionID) : null;
-    if (!model)
-      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion requires an existing session with a resolved current model", true);
-    return model;
-  };
-  const refuseModel = (requested, actual, terminal = false) => {
-    throw new HiddenCompletionRefusal("hidden_model_unsupported", `Hidden completion model ${requested} is unavailable on opencode2; use the session model ${actual} in historian.model or dreaming task model configuration, or unset the configured model`, terminal);
-  };
-  await host.hook("generate", async (draft) => {
-    const last = draft.messages.at(-1);
-    if (last?.role !== "user" || last.content.length !== 1)
-      return;
-    const part = last.content[0];
-    if (part?.type !== "text" || typeof part.text !== "string")
-      return;
-    const attempt = pending.get(part.text);
-    if (!attempt || draft.sessionID !== attempt.run.identity.parentSessionId)
-      return;
-    const actual = `${draft.model.providerID}/${draft.model.id}`;
-    if (modelKey(attempt.model) !== actual)
-      refuseModel(modelKey(attempt.model), actual);
-    if (attempt.request.signal?.aborted)
-      throw new Error("Hidden completion prompt aborted");
-    const body = attempt.request.body;
-    if (typeof body.variant === "string" && body.variant !== draft.model.variant) {
-      refuseModel(`${actual} (${body.variant})`, `${actual} (${draft.model.variant ?? "default variant"})`);
+  const store = new HiddenChildStateStore(options.db, options.projectIdentity);
+  const generation = options.generation ?? "opencode2";
+  const roleTails = new Map;
+  const persisted = store.read();
+  for (const child of [...Object.values(persisted.active), ...persisted.retired_children]) {
+    if (child)
+      options.hook.registerChild(child.id);
+  }
+  const acquireRole = async (role) => {
+    const previous = roleTails.get(role) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = previous.then(() => gate);
+    roleTails.set(role, tail);
+    await previous;
+    return () => {
+      release();
+      if (roleTails.get(role) === tail)
+        roleTails.delete(role);
+    };
+  };
+  const resolveHead = async (identity) => {
+    const configured = configuredHead(identity);
+    if (configured)
+      return configured;
+    if (!identity.parentSessionId) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion requires a configured model or an existing parent session model", true);
     }
-    const parts = body.parts;
-    if (!Array.isArray(parts) || parts.some((item) => item.type !== "text" || typeof item.text !== "string")) {
-      throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Hidden completion accepts text-only calibrated prompts", true);
+    const parent = await host.get({ sessionID: identity.parentSessionId });
+    if (!parent.model) {
+      throw new HiddenCompletionRefusal("hidden_model_unsupported", "Hidden completion could not resolve the parent session model", true);
     }
-    draft.system = [
-      {
-        type: "text",
-        text: typeof body.system === "string" ? body.system : attempt.run.identity.system
+    return {
+      providerID: parent.model.providerID,
+      modelID: parent.model.id,
+      ...parent.model.variant ? { variant: parent.model.variant } : {}
+    };
+  };
+  const switchChildModel = async (run, requested) => {
+    if (sameModel(run.child.model, requested))
+      return;
+    await host.switchModel({
+      sessionID: run.child.id,
+      model: {
+        providerID: requested.providerID,
+        id: requested.modelID,
+        ...requested.variant ? { variant: requested.variant } : {}
       }
-    ];
-    draft.messages = [
-      { role: "user", content: parts.map((item) => ({ type: "text", text: item.text })) }
-    ];
-    draft.tools = {};
-    if (attempt.run.identity.maxOutputTokens !== undefined)
-      draft.options.maxOutputTokens = attempt.run.identity.maxOutputTokens;
-    attempt.shaped = true;
-  });
+    });
+    run.child = store.updateModel(run.child, requested);
+  };
+  const retire = (run, reason) => {
+    if (run.retired)
+      return;
+    store.retire(run.child, reason);
+    run.retired = true;
+  };
+  const interruptAndRetire = async (run, reason) => {
+    try {
+      await host.interrupt({ sessionID: run.child.id });
+    } finally {
+      retire(run, reason);
+    }
+  };
   return {
     capabilities: { tools: false, harness: "opencode2" },
     async open(identity) {
-      const model = await requireModel(identity.parentSessionId);
-      const configured = (identity.configuredModels ?? (identity.model ? [identity.model] : [])).map(toModelEntry).filter((entry) => entry !== undefined);
-      if (configured.length && !configured.some((entry) => entry.model === modelKey(model))) {
-        refuseModel(configured.map((entry) => entry.model).join(", "), modelKey(model), true);
-      }
-      const handle = { id: `mc:hidden:${crypto.randomUUID()}` };
-      runs.set(handle, { identity });
-      return handle;
+      const role = roleFor(identity);
+      const releaseRole = await acquireRole(role);
+      let openedChild;
+      try {
+        await options.ensureAgent?.();
+        const head = await resolveHead(identity);
+        let active = store.read().active[role];
+        if (active && active.generation !== generation) {
+          store.retire(active, "host-generation-changed");
+          active = undefined;
+        }
+        if (active) {
+          const activeID = active.id;
+          const latest = withReader(options.openReader, (reader) => reader.latestAssistant(activeID));
+          if (!successfulReusableAssistant(latest)) {
+            store.retire(active, "newest-assistant-not-reusable");
+            active = undefined;
+          }
+        }
+        if (!active) {
+          const title = roleTitle(role);
+          const created = await host.create({
+            title,
+            agent: roleAgent(role),
+            model: {
+              providerID: head.providerID,
+              id: head.modelID,
+              ...head.variant ? { variant: head.variant } : {}
+            },
+            location: { directory: identity.directory },
+            metadata: { magic_context: "hidden-run", role }
+          });
+          if (!created.id)
+            throw new Error("OpenCode 2 did not return a child session id");
+          active = {
+            id: created.id,
+            role,
+            generation,
+            title,
+            model: head,
+            created_at: Date.now(),
+            title_reasserted: false
+          };
+          store.put(active);
+          options.hook.registerChild(active.id);
+        }
+        openedChild = active;
+        const handle = { id: active.id, childSessionId: active.id };
+        const run = {
+          identity,
+          role,
+          child: active,
+          releaseRole,
+          failed: false,
+          retired: false
+        };
+        runs.set(handle, run);
+        await switchChildModel(run, head);
+        return handle;
+      } catch (error) {
+        if (openedChild)
+          store.retire(openedChild, "hidden-run-open-failed");
+        releaseRole();
+        throw error;
+      }
     },
     async attempt(handle, request) {
       const run = runs.get(handle);
       if (!run)
         throw new Error("Unknown hidden completion run");
-      const sessionID = run.identity.parentSessionId;
-      const actual = await requireModel(sessionID);
-      if (sessionID === undefined)
-        throw new Error("Hidden completion session id missing");
-      const requested = request.body.model ?? actual;
-      if (modelKey(requested) !== modelKey(actual))
-        refuseModel(modelKey(requested), modelKey(actual));
-      if (request.signal?.aborted)
+      if (request.signal?.aborted) {
+        await interruptAndRetire(run, "aborted-before-prompt");
         throw new Error("Hidden completion prompt aborted");
-      const marker = `${handle.id}:${crypto.randomUUID()}`;
-      const state = { run, request, model: actual, shaped: false };
-      pending.set(marker, state);
+      }
+      const requested = requestModel(request, run.child.model);
+      await switchChildModel(run, requested);
+      const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
+      const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
+      const attempt = {
+        childSessionId: run.child.id,
+        identity: run.identity,
+        request,
+        shaped: false
+      };
+      options.hook.registerAttempt(marker, attempt);
+      const deadline = Date.now() + run.identity.timeoutMs;
+      let abortReject;
+      const aborted = new Promise((_resolve, reject) => {
+        abortReject = reject;
+      });
+      const onAbort = () => {
+        interruptAndRetire(run, "prompt-aborted").finally(() => abortReject(new Error("Hidden completion prompt aborted")));
+      };
+      const deadlineTimer = setTimeout(() => {
+        interruptAndRetire(run, "prompt-timeout").finally(() => abortReject(new Error("Hidden completion prompt timed out")));
+      }, Math.max(0, deadline - Date.now()));
+      request.signal?.addEventListener("abort", onAbort, { once: true });
       try {
-        const generation = host.generate({ sessionID, prompt: marker }, { signal: request.signal });
-        const result = await new Promise((resolve, reject) => {
-          const abort = () => reject(new Error("Hidden completion prompt aborted"));
-          request.signal?.addEventListener("abort", abort, { once: true });
-          generation.then(resolve, reject).finally(() => {
-            request.signal?.removeEventListener("abort", abort);
-            pending.delete(marker);
-          });
-          if (request.signal?.aborted)
-            abort();
-        });
-        if (!state.shaped)
-          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden generate hook", true);
-        const prompt = request.body.parts.map((part) => part.text).join(`
-`);
+        await Promise.race([
+          host.prompt({ sessionID: run.child.id, text: marker }),
+          aborted
+        ]);
+        await Promise.race([host.wait({ sessionID: run.child.id }), aborted]);
+        clearTimeout(deadlineTimer);
+        const row = await Promise.race([
+          awaitAssistantRow(options.openReader, run.child.id, baseline, deadline, request.signal),
+          aborted
+        ]);
+        if (!attempt.shaped) {
+          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden child context hook", true);
+        }
+        if (!run.child.title_reasserted) {
+          await host.update({ sessionID: run.child.id, title: run.child.title });
+          run.child = store.markTitleReasserted(run.child);
+        }
+        const text = assistantText(row);
         const system = typeof request.body.system === "string" ? request.body.system : run.identity.system;
-        const usage = meter(system, prompt, result.text);
-        usage.input += run.usage?.input ?? 0;
-        usage.output += run.usage?.output ?? 0;
-        run.usage = usage;
+        const tokens = row.data.tokens;
         run.completion = {
-          text: result.text,
-          usage,
-          lengthCapped: false,
-          providerId: actual.providerID,
-          modelId: actual.modelID
+          text,
+          reasoning: null,
+          usage: tokens ? {
+            input: tokens.input,
+            output: tokens.output,
+            cacheRead: tokens.cache.read,
+            cacheWrite: tokens.cache.write
+          } : meter(system, promptText(request), text ?? ""),
+          lengthCapped: ["length", "max_tokens"].includes(row.data.finish ?? ""),
+          providerId: row.data.model?.providerID ?? requested.providerID,
+          modelId: row.data.model?.id ?? requested.modelID
         };
+      } catch (error) {
+        run.failed = true;
+        if (request.signal?.aborted && !run.retired) {
+          await interruptAndRetire(run, "prompt-aborted");
+        } else if (error instanceof Error && error.message.includes("timed out") && !run.retired) {
+          await interruptAndRetire(run, "prompt-timeout");
+        }
+        throw error;
       } finally {
-        if (!request.signal?.aborted)
-          pending.delete(marker);
+        clearTimeout(deadlineTimer);
+        request.signal?.removeEventListener("abort", onAbort);
+        options.hook.releaseAttempt(marker);
       }
     },
     async collect(handle) {
@@ -108934,18 +110327,27 @@ async function createV2HiddenCompletionExecutor(host, currentModel) {
         throw new Error("Hidden completion has no settled output");
       return completion;
     },
-    async close() {}
+    async close(handle, settlement) {
+      if (!handle)
+        return;
+      const run = runs.get(handle);
+      if (!run)
+        return;
+      try {
+        if (!run.completion && (run.failed || !settlement.promptSettled)) {
+          retire(run, "hidden-run-failed");
+        }
+      } finally {
+        runs.delete(handle);
+        run.releaseRole();
+      }
+    }
   };
 }
 
 // src/v2/store-reader.ts
-import { join as join11 } from "node:path";
-function sourceDatabaseFilename(channel, env = process.env) {
-  return env.OPENCODE_DB ?? (["latest", "dev", "beta", "next", "prod"].includes(channel) || env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true" ? "opencode.db" : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "")}.db`);
-}
 function gaDatabasePath(dataHome, channel = "latest", env = process.env) {
-  const filename = sourceDatabaseFilename(channel, env);
-  return filename === ":memory:" ? filename : join11(dataHome, "opencode", filename);
+  return resolveOpenCodeDbPath("v2", { dataHome, channel, env }).path;
 }
 function decode2(row) {
   const data = JSON.parse(row.data);
@@ -108962,6 +110364,12 @@ class V2StoreReader {
   db;
   constructor(path) {
     this.db = new Database(path, { readonly: true, fileMustExist: true });
+    try {
+      assertOpenCodeStoreGeneration(this.db, "v2", path);
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
   }
   close() {
     this.db.close();
@@ -108987,6 +110395,16 @@ class V2StoreReader {
   idleRows(sessionID, after = -1) {
     return this.all(sessionID, after, "idle");
   }
+  latestSequence(sessionID) {
+    const row = this.db.prepare("SELECT MAX(seq) AS seq FROM session_message WHERE session_id = ?").get(sessionID);
+    return typeof row?.seq === "number" ? row.seq : -1;
+  }
+  latestAssistant(sessionID) {
+    const row = this.db.prepare(`SELECT id, session_id, type, seq, data FROM session_message
+            WHERE session_id = ? AND type = 'assistant'
+            ORDER BY seq DESC LIMIT 1`).get(sessionID);
+    return row ? decode2(row) : undefined;
+  }
   window(sessionID) {
     return this.db.transaction(() => {
       const cut = this.latestCompaction(sessionID);
@@ -109062,7 +110480,7 @@ function buildDreamTaskRuntimeConfigs(dreamer, harness, language, muralModel) {
 
 // src/features/magic-context/dreamer/task-executor.ts
 import { createHash as createHash27 } from "node:crypto";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -112099,7 +113517,7 @@ function deterministicJitterMs(intervalMs, noteId, hash) {
 }
 
 // src/features/magic-context/smart-notes/wake-plane.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 init_data_path();
 var WAKE_PLANE_CAPABILITY = "wake.create";
 var WAKE_PLANE_STATUS_TTL_MS = 5 * 60 * 1000;
@@ -112109,7 +113527,7 @@ var inFlightProbe = null;
 var catalogProbe = probeWakePlaneCatalog;
 var now = () => Date.now();
 function connectionFile() {
-  return join12(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join13(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 async function probeWakePlaneCatalog() {
   const file = connectionFile();
@@ -112759,8 +114177,8 @@ async function archiveExpiredMemories(args) {
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 init_logger();
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/features/magic-context/dreamer/protected-regions.ts
 var PROTECTED_START_TOKEN = "mc:protected START";
@@ -112861,10 +114279,10 @@ var MAINTAIN_DOCS_SNAPSHOT_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function snapshotMaintainDocsFiles(docsDir) {
   const snapshot = new Map;
   for (const name of MAINTAIN_DOCS_SNAPSHOT_FILES) {
-    const path = join13(docsDir, name);
+    const path = join14(docsDir, name);
     try {
-      if (existsSync14(path)) {
-        snapshot.set(name, readFileSync11(path, "utf8"));
+      if (existsSync15(path)) {
+        snapshot.set(name, readFileSync12(path, "utf8"));
       }
     } catch {}
   }
@@ -112872,9 +114290,9 @@ function snapshotMaintainDocsFiles(docsDir) {
 }
 function enforceMaintainDocsProtectedRegions(args) {
   for (const [fileName, original] of args.snapshot) {
-    const path = join13(args.docsDir, fileName);
+    const path = join14(args.docsDir, fileName);
     try {
-      const current = readFileSync11(path, "utf8");
+      const current = readFileSync12(path, "utf8");
       const { text, violated } = enforceProtectedRegions(original, current);
       if (!violated) {
         continue;
@@ -112892,7 +114310,7 @@ import { createHash as createHash25 } from "node:crypto";
 init_logger();
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync15, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync16, statSync as statSync11 } from "node:fs";
 import path8 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -112930,7 +114348,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync15(abs) && statSync10(abs).isFile())
+      if (existsSync16(abs) && statSync11(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -115562,8 +116980,8 @@ async function runAgenticTask(config, ctx, helpers) {
   const lastRunAt = getTaskScheduleState(db, projectIdentity, config.task)?.lastRunAt ?? null;
   const maintainDocsSnapshot = task === "maintain-docs" ? snapshotMaintainDocsFiles(docsDir) : undefined;
   const existingDocs = task === "maintain-docs" ? {
-    architecture: existsSync16(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync16(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync17(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync17(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const abortController = new AbortController;
   let leaseLost = false;
@@ -115790,11 +117208,11 @@ function planDueTasks(db, projectIdentity, tasks, now) {
   }
   return due;
 }
-function advanceAfterRun(db, projectIdentity, due, finishedAt, status, error, schedulePatch) {
+function advanceAfterRun(db, projectIdentity, due, finishedAt, status, error, schedulePatch, startedAt) {
   writeTaskScheduleState(db, {
     projectPath: projectIdentity,
     task: due.config.task,
-    lastRunAt: status === "completed" ? finishedAt : readLastRunAt(db, projectIdentity, due.config.task),
+    lastRunAt: status === "completed" ? startedAt ?? finishedAt : readLastRunAt(db, projectIdentity, due.config.task),
     nextDueAt: nextDueAtMs(due.config.schedule, finishedAt, due.scheduledAt),
     schedule: due.config.schedule,
     lastStatus: status,
@@ -115878,6 +117296,7 @@ async function runDomainGroup(deps, group, cb) {
         }
       }
       let outcome;
+      const startedAt = Date.now();
       try {
         outcome = await executor(due.config, {
           db,
@@ -115891,7 +117310,7 @@ async function runDomainGroup(deps, group, cb) {
       }
       const finishedAt = Date.now();
       if (outcome.status === "completed") {
-        advanceAfterRun(db, projectIdentity, due, finishedAt, "completed", null, outcome.schedulePatch);
+        advanceAfterRun(db, projectIdentity, due, finishedAt, "completed", null, outcome.schedulePatch, startedAt);
         cb?.onRan?.(due.config.task, outcome.detail, outcome.backlog);
       } else if (outcome.transient) {
         recordTransientFailure(db, projectIdentity, due, finishedAt, outcome.error ?? null);
@@ -116136,7 +117555,7 @@ function rawMessages(rows, history = rows) {
   const ordinals = new Map(history.filter(isRawRow).map((row, index) => [row.id, index + 1]));
   return rows.filter(isRawRow).map((row) => ({
     id: row.id,
-    ordinal: ordinals.get(row.id),
+    ordinal: ordinals.get(row.id) ?? 0,
     role: row.type === "assistant" ? "assistant" : "user",
     createdAt: row.data.time?.created,
     parts: row.type === "assistant" ? (row.data.content ?? []).map((part) => {
@@ -116170,20 +117589,96 @@ function createHostSeams(context, read, liveModels) {
     hostRefuse: (_client, sessionID) => interruptBeforeProvider(context.session, sessionID)
   };
 }
+function toolResultText(result) {
+  const content = result?.content ?? result?.output;
+  if (typeof content === "string")
+    return content;
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    const record = content;
+    if (typeof record.text === "string")
+      return record.text;
+    if (typeof record.value === "string")
+      return record.value;
+    return "";
+  }
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => {
+    if (typeof part === "string")
+      return part;
+    if (!part || typeof part !== "object")
+      return "";
+    const record = part;
+    if (typeof record.text === "string")
+      return record.text;
+    if (typeof record.value === "string")
+      return record.value;
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function catalogModels(listed) {
+  const rows = Array.isArray(listed) ? listed : listed && typeof listed === "object" && Array.isArray(listed.data) ? listed.data : [];
+  return rows.flatMap((row) => {
+    if (!row || typeof row !== "object")
+      return [];
+    const model = row;
+    if (typeof model.id !== "string" || typeof model.providerID !== "string")
+      return [];
+    const contextLimit = model.limit?.context;
+    if (typeof contextLimit !== "number" || !Number.isFinite(contextLimit))
+      return [];
+    return [{ id: model.id, providerID: model.providerID, limit: { context: contextLimit } }];
+  });
+}
+function applyV2PromptSurfaceTools(draft, runtime, config) {
+  if (!draft.tools)
+    return;
+  const modelKey = `${draft.model.providerID}/${draft.model.id}`;
+  const registration = runtime.resolveRegistration(config, modelKey);
+  for (const id of ACTIVE_TOOL_IDS) {
+    const tool = draft.tools[id];
+    if (!tool)
+      continue;
+    tool.description = registration.descriptionFor(id, tool.description);
+  }
+}
 async function registerContext(context) {
   const directory = context.location.directory;
   const config = loadPluginConfigDetailed(directory).config;
   if (!config.enabled || !isCompactionEnabled(config))
     return;
+  const conflicts = detectConflicts(directory, {
+    compactionEnabled: true,
+    hostGeneration: "v2"
+  });
+  if (conflicts.hasConflict) {
+    console.warn(`[magic-context] v2 setup disabled by conflicting context hooks: ${conflicts.reasons.join("; ")}`);
+    return;
+  }
   const folds = new FoldOwner(context.storage);
   const limits = new Map;
   const queriedModels = new Set;
   const liveModels = new Map;
-  const hostGenerate = context.session.generate?.bind(context.session);
-  const hiddenCompletionExecutor = hostGenerate ? await createV2HiddenCompletionExecutor({
-    hook: (name, callback) => context.session.hook(name, callback),
-    generate: (input, options) => hostGenerate(input, options)
-  }, (sessionID) => liveModels.get(sessionID) ?? null) : undefined;
+  const promptSurfaceRuntime = createPromptSurfaceRuntime({
+    harness: "opencode2",
+    directory,
+    warn: (message) => console.warn(`[magic-context] config warning: ${message}`)
+  });
+  let db;
+  try {
+    db = openDatabase() ?? undefined;
+  } catch {}
+  const hiddenChildHook = new HiddenChildHook;
+  await registerHiddenChildAgents(context.agent);
+  let hiddenAgentsReady;
+  const hiddenCompletionExecutor = db && isDatabasePersisted(db) ? await createV2HiddenCompletionExecutor(context.session, {
+    db,
+    projectIdentity: resolveProjectIdentity(directory) ?? directory,
+    hook: hiddenChildHook,
+    ensureAgent: () => hiddenAgentsReady ??= context.agent.reload(),
+    openReader: () => new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"))
+  }) : undefined;
   const dreamTrigger = hiddenCompletionExecutor && config.dreamer && !config.dreamer.disable ? startDreamTrigger(context, {
     config: config.dreamer,
     executor: hiddenCompletionExecutor,
@@ -116204,16 +117699,17 @@ async function registerContext(context) {
   let toolDuties;
   await context.tool.hook("execute.before", (draft) => assertExecutableToolInput(draft.input));
   await context.tool.hook("execute.after", async (draft) => {
-    if (!db || draft.status !== "completed")
+    if (!db)
+      return;
+    if (draft.status && draft.status !== "completed")
       return;
     try {
       toolDuties ??= createToolExecuteAfterHook({ db, channel1StateBySession: channel1 });
-      const content = draft.result?.content;
-      const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((part) => part.type === "text").map((part) => part.text).join(`
-`) : "";
+      const text = toolResultText(draft.result);
       const output = { output: text };
       await toolDuties({ ...draft, args: draft.input }, output);
       if (draft.result && output.output !== text) {
+        const content = draft.result.content;
         if (typeof content === "string")
           draft.result.content = output.output;
         else if (Array.isArray(content) && output.output.startsWith(text))
@@ -116238,7 +117734,6 @@ async function registerContext(context) {
     getCount: (sessionID) => read(sessionID).length
   });
   let transform;
-  let db;
   const refuseIfUnsafe = async (draft) => {
     let unsafe = false;
     try {
@@ -116252,10 +117747,8 @@ async function registerContext(context) {
         const tokens = latest?.data.tokens;
         const modelKey = `${draft.model.providerID}/${draft.model.id}`;
         if (!queriedModels.has(modelKey)) {
-          const catalog = await context.catalog.model.list({
-            location: context.location
-          });
-          for (const model of catalog.data)
+          const catalog = await Promise.resolve(context.model.list());
+          for (const model of catalogModels(catalog))
             limits.set(`${model.providerID}/${model.id}`, model.limit.context);
           queriedModels.add(modelKey);
         }
@@ -116275,7 +117768,8 @@ async function registerContext(context) {
       } finally {
         reader.close();
       }
-    } catch {
+    } catch (error) {
+      console.warn("[magic-context] v2 refuseIfUnsafe", error);
       unsafe = true;
     }
     if (unsafe)
@@ -116328,6 +117822,26 @@ async function registerContext(context) {
     }
   });
   await context.session.hook("context", async (draft) => {
+    if (hiddenChildHook.apply(draft))
+      return;
+    liveModels.set(draft.sessionID, {
+      providerID: draft.model.providerID,
+      modelID: draft.model.id
+    });
+    variants.set(draft.sessionID, draft.model.variant);
+    agents.set(draft.sessionID, draft.agent);
+    applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
+    if (context.tool.transform) {
+      const modelKey = `${draft.model.providerID}/${draft.model.id}`;
+      const registration = promptSurfaceRuntime.resolveRegistration(config.prompt_surface, modelKey);
+      await context.tool.transform((editor) => {
+        for (const id of ACTIVE_TOOL_IDS) {
+          editor.update(id, (tool) => {
+            tool.description = registration.descriptionFor(id, tool.description);
+          });
+        }
+      });
+    }
     let postFold = false;
     try {
       if (await refuseIfUnsafe(draft))
@@ -116444,6 +117958,9 @@ async function registerContext(context) {
       const mapped = adaptPayload(draft, admitted);
       await transform({}, mapped);
       mapped.commit();
+      if (db) {
+        await deliverPendingChannel2(context, db, draft.sessionID, channel1.get(draft.sessionID));
+      }
       if (checkpoint && submitted !== undefined) {
         const head = draft.messages.find((message) => message.id === HEAD_IDS[0]);
         const baseline = head?.content.find((part) => part.type === "text")?.text;
@@ -116483,8 +118000,8 @@ ${baseline}
 }
 
 // src/v2/hooks/update-check.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
+import { dirname as dirname9, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/hooks/auto-update-checker/checker.ts
@@ -116492,26 +118009,26 @@ init_logger();
 var import_comment_json = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir9, platform } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir11, platform } from "node:os";
+import { join as join15 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join14(process.env.LOCALAPPDATA ?? homedir9(), "opencode");
+    return join15(process.env.LOCALAPPDATA ?? homedir11(), "opencode");
   }
-  return join14(homedir9(), ".cache", "opencode");
+  return join15(homedir11(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join14(process.env.APPDATA ?? join14(homedir9(), "AppData", "Roaming"), "opencode");
+    return join15(process.env.APPDATA ?? join15(homedir11(), "AppData", "Roaming"), "opencode");
   }
-  return join14(process.env.XDG_CONFIG_HOME ?? join14(homedir9(), ".config"), "opencode");
+  return join15(process.env.XDG_CONFIG_HOME ?? join15(homedir11(), ".config"), "opencode");
 }
-var CACHE_DIR = join14(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join14(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join14(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join15(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join15(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join15(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/semver.ts
 function isValidSemver(version) {
@@ -116573,18 +118090,18 @@ async function getLatestVersion(channel = "latest", options = {}) {
 // src/v2/hooks/update-check.ts
 init_rpc_notifications();
 function packageInfo() {
-  let directory = dirname8(fileURLToPath2(import.meta.url));
+  let directory = dirname9(fileURLToPath2(import.meta.url));
   for (;; ) {
     try {
-      const pkg = JSON.parse(readFileSync12(join15(directory, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync13(join16(directory, "package.json"), "utf8"));
       if (pkg.name === "@cortexkit/opencode-magic-context" && typeof pkg.version === "string") {
         return {
           version: pkg.version,
-          development: existsSync17(join15(directory, "src/v2/server.ts"))
+          development: existsSync18(join16(directory, "src/v2/server.ts"))
         };
       }
     } catch {}
-    const parent = dirname8(directory);
+    const parent = dirname9(directory);
     if (parent === directory)
       throw new Error("Magic Context package manifest is unavailable");
     directory = parent;
@@ -116627,7 +118144,17 @@ function startUpdateChecks(context, check = (signal) => {
 }
 
 // src/v2/server.ts
+function isOpenCode2HostContext(context) {
+  if (typeof context !== "object" || context === null)
+    return false;
+  const session = context.session;
+  return typeof session === "object" && session !== null && typeof session.hook === "function";
+}
 async function setup(context) {
+  if (!isOpenCode2HostContext(context)) {
+    log("v2 setup() called on a host without session.hook; v1 server lane owns this host, v2 lane inert");
+    return async () => {};
+  }
   setHarness("opencode2");
   const duties = await registerContext(context);
   const checks = loadPluginConfigDetailed(context.location.directory).config.auto_update === false ? undefined : startUpdateChecks(context);
@@ -116643,5 +118170,6 @@ var server_default = {
 };
 export {
   server_default as default,
+  isOpenCode2HostContext,
   setup
 };