@cortexkit/opencode-magic-context 0.42.4 → 0.42.6

package/dist/index.js

@@ -32,6 +32,7 @@ import {
   resolveModelConfigOrDefault,
   DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   DEFAULT_HISTORIAN_TIMEOUT_MS,
+  PROTECTED_TOKENS_MIN,
   DEFAULT_LOCAL_EMBEDDING_MODEL,
   PER_HARNESS_MIGRATION_INVENTORY,
   PER_HARNESS_MODEL_KEYS,
@@ -72,7 +73,10 @@ import {
   prepareAuthority,
   drainAuthority,
   getMemoryMirrorStatus,
+  moduleMemoryIdentityForHostId,
+  hostMemoryIdentityForModuleId,
   applyMirroredNoteCompileFields,
+  applyTargetedMemoryMirrorRow,
   drainMirrorPages,
   pullMemoryMirrorOnce,
   V2_MEMORY_CATEGORIES,
@@ -207,6 +211,7 @@ import {
   primeInMemoryTailRawMessageCache,
   readRawSessionMessageOrdinalPage,
   getRawSessionStoredMessageCount,
+  readRawSessionMessageIdOrdinals,
   readRawSessionMessagePartsById,
   readRawSessionMessageOrdinalById,
   readRawSessionMessageById,
@@ -365,11 +370,13 @@ import {
   detectThinkingBindingMismatch,
   isFable51ThinkingBindingModel,
   detectOverflow,
+  parseProviderModel,
   modelBodyField,
   toModelEntry,
   getPromptFailureDetail,
   promptSyncWithValidatedOutputRetry,
   normalizeSDKResponse,
+  ACTIVE_TOOL_IDS,
   promptSurfaceHashMaterial,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
@@ -422,6 +429,7 @@ import {
   embedShadowTextForProject,
   enqueueShadowEmbeddingItems,
   registerProjectInObservationMode,
+  unregisterProjectShadowEmbedding,
   getProjectEmbeddingSnapshot,
   embedTextForProject,
   embedBatchForProject,
@@ -547,7 +555,7 @@ import {
   setRecompTerminal2,
   runManagedRecomp2,
   runManagedUpgrade2
-} from "./index-faay035c.js";
+} from "./index-djp6rwz6.js";
 import {
   stripJsonComments,
   isPrototypePollutionKey,
@@ -576,6 +584,7 @@ import {
 } from "./index-f9gem5cr.js";
 import {
   resolveOpenCodeDbPath,
+  assertOpenCodeStoreGeneration,
   openCodeDbPathExists,
   formatOpenCodeDbMissingBanner,
   formatOpenCodeDbMissingStatusLine,
@@ -592,9 +601,10 @@ import {
   observeOpenCodeTurnEvent,
   clearTrackedOpenCodeSession,
   assistantAwaitingTools,
+  latestPersistedMessageForRecovery,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-jkrqhc7y.js";
+} from "./index-a9ssj59b.js";
 import {
   getErrorMessage,
   describeError,
@@ -603,13 +613,13 @@ import {
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./index-p474rw9p.js";
+} from "./index-ngjmj6xx.js";
 import {
   detectConflicts,
   resolveCompactionForBoot,
   sendConflictWarning2,
   cleanupConflictWarnings2
-} from "./index-d8mgqezq.js";
+} from "./index-s61hh7gv.js";
 import {
   resolveHistorianModel2,
   resolveOpenCodeAgentOverrides2,
@@ -626,7 +636,7 @@ import {
   compareTaskOrder,
   buildDreamTaskRuntimeConfigs2,
   userMemoryCollectionEnabled2
-} from "./index-bkg2fdj1.js";
+} from "./index-4wwr6cz0.js";
 import {
   logSlowWriteTransaction,
   getOrCreateSessionMeta2,
@@ -636,7 +646,7 @@ import {
   retryPendingSessionCleanups2,
   retryPendingRustSessionCleanupsForProject2,
   clearSession2
-} from "./index-1ar7b3e9.js";
+} from "./index-znraa0kv.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -10370,6 +10380,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;
@@ -10460,6 +10473,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);
@@ -10702,6 +10720,12 @@ function openOpenCodeDb() {
   }
   try {
     const db = new Database(dbPath, { readonly: true });
+    try {
+      assertOpenCodeStoreGeneration(db, "v1", dbPath);
+    } catch (error) {
+      db.close();
+      throw error;
+    }
     db.exec("PRAGMA busy_timeout = 5000");
     clearOpenCodeDbReadFailure();
     return db;
@@ -10781,9 +10805,11 @@ function buildCuratePrompt(args) {
 
 **Project:** ${args.projectPath}
 
+This run covers the whole of the \`${args.category}\` category (the other categories run in later windows).
+
 The memories below are assumed ACCURATE (a separate verify task keeps them true). Your job is pool QUALITY: remove duplicates, tighten wording, and consolidate redundant entries that waste the ~6000-token injection budget. Explain each action in one line first. Do NOT mint new facts (that is the historian's job).
 
-Work ALL THREE phases below in order (A → B → C) over the whole pool. Do NOT stop after consolidating — a run that only merges and never improves or archives is incomplete.
+Work ALL THREE phases below in order (A → B → C) over this category. Do NOT stop after consolidating — a run that only merges and never improves or archives is incomplete.
 
 ### Phase A — Consolidate duplicates
 Group by category, then merge near-identical / superset-subset / same-fact-different-angle clusters into one canonical memory with \`ctx_memory(action="merge", ids=[...], content="...", category="...")\`. Preserve every unique detail; terse present tense; paths/keys verbatim. Every id in a merge MUST share the same category — the system rejects cross-category merges. If two similar memories sit in different categories they are NOT duplicates; do not archive either as a consolidation. One fact per memory.
@@ -11003,6 +11029,7 @@ function buildDreamTaskPrompt(task, args) {
     case "curate":
       return buildCuratePrompt({
         projectPath: args.projectPath,
+        category: args.curate?.category ?? "PROJECT_RULES",
         memories: args.curate?.memories ?? []
       });
     case "maintain-docs":
@@ -11189,7 +11216,19 @@ async function runSessionProjectBackfill(db, source, options = {}) {
   let identityResolutionsSinceYield = 0;
   let afterSessionId = null;
   for (;; ) {
-    const sourcePage = await readPage(afterSessionId, SESSION_PAGE_SIZE);
+    let sourcePage;
+    try {
+      sourcePage = await readPage(afterSessionId, SESSION_PAGE_SIZE);
+    } catch (error) {
+      try {
+        if (!markBackfillRetryPending(db, harness, holderId, now())) {
+          log("[session-projects] backfill lease changed before failure cleanup");
+        }
+      } catch (releaseError) {
+        log(`[session-projects] failed to make backfill lease retryable after discovery failed: ${releaseError}`);
+      }
+      throw error;
+    }
     if (sourcePage.length === 0)
       break;
     afterSessionId = sourcePage.at(-1)?.sessionId ?? afterSessionId;
@@ -11520,17 +11559,47 @@ async function runDeferredV22Backfill(db, options = {}) {
 }
 
 // src/hooks/auto-update-checker/index.ts
-import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync4, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync5, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname4, join as join4 } from "node:path";
 
+// src/shared/auto-update-provenance.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+var AUTO_UPDATE_CHECK_STATE_FILENAME = "last-update-check.json";
+function readAutoUpdateCheckState(path) {
+  if (!existsSync5(path))
+    return null;
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf-8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return null;
+    const raw = value;
+    const state = {};
+    if (typeof raw.lastCheckedMs === "number" && Number.isFinite(raw.lastCheckedMs)) {
+      state.lastCheckedMs = raw.lastCheckedMs;
+    }
+    if (typeof raw.updaterPinnedSpec === "string" && raw.updaterPinnedSpec.length > 0) {
+      state.updaterPinnedSpec = raw.updaterPinnedSpec;
+    }
+    if (typeof raw.updaterPinnedAt === "number" && Number.isFinite(raw.updaterPinnedAt)) {
+      state.updaterPinnedAt = raw.updaterPinnedAt;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+function isUpdaterPinnedSpec(state, configuredSpec) {
+  return state?.updaterPinnedSpec === configuredSpec && typeof state.updaterPinnedAt === "number" && Number.isFinite(state.updaterPinnedAt);
+}
+
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json = __toESM(require_src2(), 1);
 import { spawn } from "node:child_process";
 import {
   accessSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   constants as fsConstants,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   renameSync as renameSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2
@@ -11640,9 +11709,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync5(path))
+      if (!existsSync6(path))
         continue;
-      const parsed = parseJsonConfig(readFileSync3(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync4(path, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -11675,9 +11744,9 @@ function findPackageJsonUp(startPath) {
     let dir = stat.isDirectory() ? startPath : dirname3(startPath);
     for (let i = 0;i < 10; i++) {
       const pkgPath = join3(dir, "package.json");
-      if (existsSync5(pkgPath)) {
+      if (existsSync6(pkgPath)) {
         try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
@@ -11693,9 +11762,9 @@ function findPackageJsonUp(startPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync5(configPath))
+      if (!existsSync6(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync3(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
@@ -11705,7 +11774,7 @@ function getLocalDevPath(directory) {
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
             continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return localPath;
         }
@@ -11722,7 +11791,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(pkgPath, "utf-8")));
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
     return pkg.success ? pkg.data.version ?? null : null;
   } catch {
     return null;
@@ -11779,7 +11848,7 @@ function preflightConfigUpdates(paths, version) {
   for (const path of paths) {
     try {
       accessSync(path, fsConstants.W_OK);
-      const original = readFileSync3(path, "utf-8");
+      const original = readFileSync4(path, "utf-8");
       const updated = configUpdateContent(original, version);
       if (!updated)
         return null;
@@ -11808,7 +11877,7 @@ function restoreConfigs(snapshots) {
 function configsHaveSpec(paths, spec) {
   return paths.every((path) => {
     try {
-      const parsed = parseJsonConfig(readFileSync3(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync4(path, "utf-8"));
       return getPluginEntries(parsed).includes(spec);
     } catch {
       return false;
@@ -11898,9 +11967,9 @@ function getCachedVersion(_spec) {
   const candidates = [getCurrentRuntimePackageJsonPath()].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync5(packageJsonPath))
+      if (!existsSync6(packageJsonPath))
         continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync3(packageJsonPath, "utf-8")));
+      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
         if (!_spec)
           cachedPackageVersion = pkg.data.version;
@@ -11942,7 +12011,6 @@ async function getLatestVersion(channel = "latest", options = {}) {
 // src/hooks/auto-update-checker/index.ts
 var DEFAULT_CHECK_INTERVAL_MS = 60 * 60 * 1000;
 var DEFAULT_INIT_DELAY_MS = 5000;
-var TIMESTAMP_FILENAME = "last-update-check.json";
 var PENDING_UPDATE_FILENAME = "pending-plugin-update.json";
 var PENDING_UPDATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 function warn2(message) {
@@ -11994,34 +12062,50 @@ async function maybeRunCheck(ctx, options) {
   }
   await runStartupCheck(ctx, options);
 }
+function checkStatePath(storageDir) {
+  return join4(storageDir ?? getOpenCodeStorageDir(), AUTO_UPDATE_CHECK_STATE_FILENAME);
+}
+function writeCheckState(path, state) {
+  mkdirSync(dirname4(path), { recursive: true });
+  const tmp = `${path}.tmp.${process.pid}`;
+  writeFileSync3(tmp, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+  renameSync3(tmp, path);
+}
 function claimCheckSlot(storageDir, intervalMs) {
   if (!storageDir)
     return true;
   try {
-    const file = join4(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync6(file)) {
-      try {
-        const raw = JSON.parse(readFileSync4(file, "utf-8"));
-        const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
-        if (Number.isFinite(last) && Date.now() - last < intervalMs) {
-          return false;
-        }
-      } catch {}
-    }
-    mkdirSync(dirname4(file), { recursive: true });
-    const tmp = `${file}.tmp.${process.pid}`;
-    writeFileSync3(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-    renameSync3(tmp, file);
+    const file = checkStatePath(storageDir);
+    const previous = readAutoUpdateCheckState(file) ?? {};
+    const last = previous.lastCheckedMs ?? 0;
+    if (Date.now() - last < intervalMs)
+      return false;
+    writeCheckState(file, { ...previous, lastCheckedMs: Date.now() });
     return true;
   } catch (err) {
     warn2(`[auto-update-checker] Could not coordinate via timestamp file: ${String(err)}`);
     return true;
   }
 }
+function recordUpdaterPinnedSpec(storageDir, spec) {
+  try {
+    const path = checkStatePath(storageDir);
+    const previous = readAutoUpdateCheckState(path) ?? {};
+    writeCheckState(path, {
+      ...previous,
+      updaterPinnedSpec: spec,
+      updaterPinnedAt: Date.now()
+    });
+  } catch (err) {
+    warn2(`[auto-update-checker] Could not record updater pin provenance: ${String(err)}`);
+  }
+}
 function pendingMarkerPath(storageDir) {
   return join4(storageDir ?? getOpenCodeStorageDir(), PENDING_UPDATE_FILENAME);
 }
 function writePendingUpdateMarker(storageDir, update, version) {
+  recordUpdaterPinnedSpec(storageDir, update.spec);
   try {
     const dir = storageDir ?? dirname4(pendingMarkerPath(storageDir));
     mkdirSync(dir, { recursive: true });
@@ -12036,10 +12120,10 @@ function writePendingUpdateMarker(storageDir, update, version) {
 }
 function consumePendingUpdateMarker(storageDir, loadedVersion) {
   const path = pendingMarkerPath(storageDir);
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return;
   try {
-    const marker = JSON.parse(readFileSync4(path, "utf-8"));
+    const marker = JSON.parse(readFileSync5(path, "utf-8"));
     const age = Date.now() - (marker.writtenAt ?? 0);
     const olderThanLoaded = typeof marker.version === "string" && typeof loadedVersion === "string" && (compareSemverCore(marker.version, loadedVersion) ?? 0) < 0;
     if (marker.version === loadedVersion && marker.spec === `${PACKAGE_NAME}@${loadedVersion}` && Array.isArray(marker.configPaths) && marker.configPaths.length === 2) {
@@ -12111,11 +12195,15 @@ async function runBackgroundUpdateCheck(ctx, options) {
     return;
   }
   log(`[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`);
-  if (pluginInfo.isPinned) {
-    showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Version is pinned; update your OpenCode plugin config to upgrade.`, "info", 8000);
-    log("[auto-update-checker] Version is pinned; skipping auto-update");
+  const updaterOwnedPin = pluginInfo.isPinned && isUpdaterPinnedSpec(readAutoUpdateCheckState(checkStatePath(options.storageDir)), pluginInfo.entry);
+  if (pluginInfo.isPinned && !updaterOwnedPin) {
+    showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. This version was pinned by you; update your OpenCode plugin config to upgrade.`, "info", 8000);
+    log("[auto-update-checker] Version was pinned by you; skipping auto-update");
     return;
   }
+  if (updaterOwnedPin) {
+    log("[auto-update-checker] Version was pinned by the updater; continuing auto-update");
+  }
   if (!options.autoUpdate) {
     showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Auto-update is disabled.`, "info", 8000);
     log("[auto-update-checker] Auto-update disabled, notification only");
@@ -12449,9 +12537,11 @@ class SubcModuleTransport {
         this.wrapupSessions.delete(args.sessionId);
     };
     const laneDeadlineMs = Date.now() + attemptTimeoutMs;
-    let releaseLane;
+    let releaseLane = () => {};
     try {
-      releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
+      if (!args.bypassSessionLane) {
+        releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
+      }
     } catch (error) {
       finishWrapupTracking();
       if (args.method === "state_sync" && isDeadlineFailure(error)) {
@@ -12553,12 +12643,13 @@ class SubcModuleTransport {
       args.onTimings?.(timings);
     }
   }
-  async authorityRequest(sessionId, projectRoot, method, body) {
+  async authorityRequest(sessionId, projectRoot, method, body, timeoutMs) {
     const response = await this.call({
       sessionId,
       projectRoot,
       method,
-      body: { ...body, method, v: 1 }
+      body: { ...body, method, v: 1 },
+      timeoutMs
     });
     if (isRecord(response) && isRecord(response.result))
       return response.result;
@@ -12618,6 +12709,20 @@ class SubcModuleTransport {
       throw new Error("mirror.pull omitted page");
     return { page: response.page };
   }
+  async mirrorMemory(args) {
+    const { projectRoot, ...body } = args;
+    const response = await this.authorityRequest(`mirror-memory:${args.module_row_id}`, projectRoot ?? this.bindRootForAuthority(), "mirror.memory", body, 1900);
+    return {
+      row: isRecord(response.row) ? response.row : null
+    };
+  }
+  async memoryIdentityAck(args) {
+    const { projectRoot, ...body } = args;
+    const response = await this.authorityRequest(`memory-identity:${args.project}`, projectRoot ?? this.bindRootForAuthority(), "memory.identity.ack", body);
+    return {
+      acknowledged: typeof response.acknowledged === "number" ? response.acknowledged : 0
+    };
+  }
   async deleteSession(sessionId, projectRoot) {
     await this.call({
       sessionId,
@@ -13567,6 +13672,7 @@ function toRow(r) {
     lastStatus: r.last_status ?? null,
     lastError: r.last_error,
     retryCount: r.retry_count ?? 0,
+    taskStateJson: r.last_checked_commit ?? null,
     lastCheckedCommit: r.last_checked_commit ?? null,
     lastBroadRunAt: r.last_broad_run_at ?? null,
     retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
@@ -13610,7 +13716,12 @@ function writeTaskScheduleState(db, row) {
            retry_count          = excluded.retry_count,
            last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
            ${broadCycleUpdate},
-           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
+           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.taskStateJson ?? row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
+}
+function writeTaskStateJson(db, projectPath, task, taskStateJson) {
+  db.prepare(`INSERT INTO task_schedule_state (project_path, task, last_checked_commit)
+         VALUES (?, ?, ?)
+         ON CONFLICT(project_path, task) DO UPDATE SET last_checked_commit = excluded.last_checked_commit`).run(projectPath, task, taskStateJson);
 }
 function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
   const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
@@ -13622,7 +13733,7 @@ function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
 
 // src/features/magic-context/dreamer/task-executor.ts
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -15046,6 +15157,104 @@ function recordInvocation(args, startedAt, params) {
   });
 }
 
+// src/features/magic-context/dreamer/curate-category-rotation.ts
+var CURATE_MEMORY_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+];
+var LEGACY_CURATE_CATEGORY_BUCKETS = {
+  ARCHITECTURE_DECISIONS: "ARCHITECTURE",
+  CONFIG_DEFAULTS: "CONFIG_VALUES",
+  ENVIRONMENT: "CONFIG_VALUES",
+  KNOWN_ISSUES: "CONSTRAINTS",
+  USER_DIRECTIVES: "PROJECT_RULES",
+  USER_PREFERENCES: "PROJECT_RULES",
+  WORKFLOW_RULES: "PROJECT_RULES"
+};
+function curateCategoryForMemoryCategory(category) {
+  return isCurateMemoryCategory(category) ? category : LEGACY_CURATE_CATEGORY_BUCKETS[category] ?? null;
+}
+function isCurateMemoryCategory(value) {
+  return CURATE_MEMORY_CATEGORIES.includes(value);
+}
+function parseTaskState(raw) {
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function normalizedCursor(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value % CURATE_MEMORY_CATEGORIES.length : 0;
+}
+function readState(db, projectIdentity) {
+  return parseTaskState(getTaskScheduleState(db, projectIdentity, "curate")?.taskStateJson);
+}
+function categoryStartIndex(state, populated) {
+  const active = state.curate?.activeCategory;
+  if (isCurateMemoryCategory(active)) {
+    const activeIndex = CURATE_MEMORY_CATEGORIES.indexOf(active);
+    return populated.has(active) ? activeIndex : (activeIndex + 1) % CURATE_MEMORY_CATEGORIES.length;
+  }
+  return normalizedCursor(state.curate?.cursor);
+}
+function peekCurateCategoryScope(db, projectIdentity, memories) {
+  const populated = new Set(memories.map((memory) => curateCategoryForMemoryCategory(memory.category)).filter((category) => category !== null));
+  const start = categoryStartIndex(readState(db, projectIdentity), populated);
+  for (let offset = 0;offset < CURATE_MEMORY_CATEGORIES.length; offset += 1) {
+    const category = CURATE_MEMORY_CATEGORIES[(start + offset) % CURATE_MEMORY_CATEGORIES.length];
+    const scoped = memories.filter((memory) => curateCategoryForMemoryCategory(memory.category) === category);
+    if (scoped.length > 0)
+      return { category, memories: scoped };
+  }
+  return null;
+}
+function beginCurateCategoryRun(db, projectIdentity, memories) {
+  const scope = peekCurateCategoryScope(db, projectIdentity, memories);
+  if (!scope)
+    return null;
+  const state = readState(db, projectIdentity);
+  writeTaskStateJson(db, projectIdentity, "curate", JSON.stringify({
+    ...state,
+    curate: {
+      cursor: normalizedCursor(state.curate?.cursor),
+      activeCategory: scope.category
+    }
+  }));
+  return scope;
+}
+function curateTaskStateAfterSuccess(db, projectIdentity, category) {
+  const state = readState(db, projectIdentity);
+  return JSON.stringify({
+    ...state,
+    curate: {
+      cursor: (CURATE_MEMORY_CATEGORIES.indexOf(category) + 1) % CURATE_MEMORY_CATEGORIES.length
+    }
+  });
+}
+function getActiveCurateCategory(db, projectIdentity) {
+  const active = readState(db, projectIdentity).curate?.activeCategory;
+  return isCurateMemoryCategory(active) ? active : null;
+}
+function getCurateCategoryScopeRefusal(args) {
+  if (args.requestedCategory && args.requestedCategory !== args.scope) {
+    return `Error: Curate scope is ${args.scope}; ${args.action} cannot target category ${args.requestedCategory}.`;
+  }
+  for (const id of args.ids ?? []) {
+    const category = args.categoryForId(id);
+    if (category && category !== args.scope) {
+      return `Error: Curate scope is ${args.scope}; memory ID ${id} is outside the scoped category.`;
+    }
+  }
+  return null;
+}
+
 // src/features/magic-context/dreamer/memory-claim-safety.ts
 var POLICY_SENTENCE_START = /(?:^|[.!?]\s+|\n\s*)(?:[-*]\s+|\d+[.)]\s+)?(?:you\s+|we\s+)?(?:must(?:\s+not)?|never|always|do\s+not|don't|shall\s+not)\b/i;
 var ACTOR_POLICY = /\b(?:you|we|agents?|masons?|workers?|operators?|users?|maintainers?)\s+(?:must(?:\s+not)?|should(?:\s+not)?|need\s+to|shall(?:\s+not)?|cannot|can't|may\s+not)\b/i;
@@ -17028,7 +17237,7 @@ async function archiveExpiredMemories(args) {
 }
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join7 } from "node:path";
 
 // src/features/magic-context/dreamer/protected-regions.ts
@@ -17132,8 +17341,8 @@ function snapshotMaintainDocsFiles(docsDir) {
   for (const name of MAINTAIN_DOCS_SNAPSHOT_FILES) {
     const path = join7(docsDir, name);
     try {
-      if (existsSync7(path)) {
-        snapshot.set(name, readFileSync5(path, "utf8"));
+      if (existsSync8(path)) {
+        snapshot.set(name, readFileSync6(path, "utf8"));
       }
     } catch {}
   }
@@ -17143,7 +17352,7 @@ function enforceMaintainDocsProtectedRegions(args) {
   for (const [fileName, original] of args.snapshot) {
     const path = join7(args.docsDir, fileName);
     try {
-      const current = readFileSync5(path, "utf8");
+      const current = readFileSync6(path, "utf8");
       const { text, violated } = enforceProtectedRegions(original, current);
       if (!violated) {
         continue;
@@ -17160,7 +17369,7 @@ function enforceMaintainDocsProtectedRegions(args) {
 import { createHash as createHash6 } from "node:crypto";
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync8, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, statSync as statSync3 } from "node:fs";
 import path3 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.
 
@@ -17198,7 +17407,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync8(abs) && statSync3(abs).isFile())
+      if (existsSync9(abs) && statSync3(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -18338,12 +18547,13 @@ function countActiveMemories(db, projectPath) {
 }
 function countLiveMemories(db, projectPath, options = {}) {
   const unclassified = options.unclassifiedOnly && hasMemoryClassifiedAtColumn(db);
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM memories
-              WHERE project_path = ?
-                AND status IN ('active','permanent')
-                AND (expires_at IS NULL OR expires_at > ?)
-                ${unclassified ? "AND classified_at IS NULL" : ""}`).get(projectPath, Date.now());
+  const sql = `SELECT COUNT(*) AS cnt
+                   FROM memories
+                  WHERE project_path = ?
+                    AND status IN ('active','permanent')
+                    AND (expires_at IS NULL OR expires_at > ?)
+                    ${unclassified ? "AND classified_at IS NULL" : ""}`;
+  const row = options.category ? db.prepare(`${sql} AND category = ?`).get(projectPath, Date.now(), options.category) : db.prepare(sql).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countUnmappedActiveMemories(db, projectPath) {
@@ -18454,8 +18664,13 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
       return { pending, total };
     }
     case "curate": {
-      const total = countLiveMemories(db, projectPath);
-      return { pending: total, total };
+      const categories = db.prepare(`SELECT category FROM memories
+                      WHERE project_path = ?
+                        AND status IN ('active','permanent')
+                        AND (expires_at IS NULL OR expires_at > ?)`).all(projectPath, Date.now());
+      const scope = peekCurateCategoryScope(db, projectPath, categories);
+      const total = scope?.memories.length ?? 0;
+      return scope ? { pending: total, total, category: scope.category } : { pending: 0, total: 0 };
     }
     case "compress-cues": {
       const total = countLiveMemories(db, projectPath);
@@ -19307,6 +19522,7 @@ function createDreamTaskExecutor(deps) {
         processed: Math.max(0, processed),
         total: backlogAtStart.pending,
         startedAt,
+        ...backlogAtStart.category ? { category: backlogAtStart.category } : {},
         ...refused === undefined ? {} : { refused: Math.max(0, refused) }
       });
     };
@@ -19359,7 +19575,8 @@ function createDreamTaskExecutor(deps) {
                   totalAtStart: backlogAtStart.total,
                   pendingAtEnd: end.pending,
                   totalAtEnd: end.total,
-                  processed
+                  processed,
+                  ...backlogAtStart.category ? { category: backlogAtStart.category } : {}
                 };
                 return value;
               })()
@@ -19951,8 +20168,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: existsSync9(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync9(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync10(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync10(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const abortController = new AbortController;
   let leaseLost = false;
@@ -19965,6 +20182,7 @@ async function runAgenticTask(config, ctx, helpers) {
   let expiredArchived = 0;
   try {
     let curateMemories;
+    let curateCategory;
     if (task === "curate") {
       expiredArchived = await archiveExpiredMemories({
         db,
@@ -19976,10 +20194,12 @@ async function runAgenticTask(config, ctx, helpers) {
       });
       if (leaseLost)
         throw new Error("Dream lease lost during expired-memory archive");
-      curateMemories = loadActiveMemoryPromptMemories(db, projectIdentity);
-      log(`[dreamer] curate pool: in_scope=${curateMemories.length} expired_archived=${expiredArchived}`);
-      if (curateMemories.length === 0 && expiredArchived > 0) {
-        const progress = formatExpiredArchiveProgress(expiredArchived);
+      const scope = beginCurateCategoryRun(db, projectIdentity, loadActiveMemoryPromptMemories(db, projectIdentity));
+      curateMemories = scope?.memories ?? [];
+      curateCategory = scope?.category;
+      log(`[dreamer] curate pool: category=${curateCategory ?? "none"} in_scope=${curateMemories.length} expired_archived=${expiredArchived}`);
+      if (curateMemories.length === 0) {
+        const progress = expiredArchived > 0 ? formatExpiredArchiveProgress(expiredArchived) : "curate: no populated project-memory category";
         helpers.recordRun("completed", null, {
           memoryChanges: helpers.computeMemoryDelta(memoryBefore),
           progress
@@ -19991,7 +20211,7 @@ async function runAgenticTask(config, ctx, helpers) {
       projectPath: projectIdentity,
       lastDreamAt: lastRunAt ? String(lastRunAt) : null,
       existingDocs,
-      curate: curateMemories ? { memories: curateMemories } : undefined
+      curate: curateMemories && curateCategory ? { category: curateCategory, memories: curateMemories } : undefined
     });
     const createResponse = await createChildSessionWithFence({
       client: requireDreamClient(deps.client),
@@ -20083,16 +20303,34 @@ async function runAgenticTask(config, ctx, helpers) {
       }
     }
     const curateOutput = task === "curate" ? run.validated : undefined;
+    const curateScopeProgress = task === "curate" && curateCategory && curateMemories ? `curate: ${curateCategory} (${curateMemories.length})` : null;
     const progress = [
+      curateScopeProgress,
       expiredArchived > 0 ? formatExpiredArchiveProgress(expiredArchived) : null,
       curateOutput && curateOutput.memoryOperations.completedActions.length > 0 ? formatCurateMemoryOperations(curateOutput.memoryOperations.completedActions) : null,
       curateRefused > 0 ? `curate: refused ${curateRefused} unsafe mutation(s)` : null
     ].filter((value) => Boolean(value)).join("; ");
+    const curateCount = task === "curate" && curateCategory ? loadActiveMemoryPromptMemories(db, projectIdentity).filter((memory) => curateCategoryForMemoryCategory(memory.category) === curateCategory).length : undefined;
+    const curateBacklog = curateCount !== undefined && curateCategory ? {
+      pending: curateCount,
+      total: curateCount,
+      category: curateCategory
+    } : undefined;
     helpers.recordRun("completed", null, {
       memoryChanges: helpers.computeMemoryDelta(memoryBefore),
-      progress: progress || null
+      progress: progress || null,
+      backlogAfter: curateBacklog
     });
-    return { status: "completed", ...progress ? { detail: progress } : {} };
+    return {
+      status: "completed",
+      ...progress ? { detail: progress } : {},
+      ...curateBacklog ? { backlog: curateBacklog } : {},
+      ...curateCategory ? {
+        schedulePatch: {
+          taskStateJson: curateTaskStateAfterSuccess(db, projectIdentity, curateCategory)
+        }
+      } : {}
+    };
   } finally {
     heartbeat.stop();
     if (childSessionId)
@@ -20157,16 +20395,17 @@ 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,
     lastError: error,
     retryCount: 0,
+    taskStateJson: schedulePatch?.taskStateJson,
     retrospectiveWatermarkMs: schedulePatch?.retrospectiveWatermarkMs
   });
 }
@@ -20245,6 +20484,7 @@ async function runDomainGroup(deps, group, cb) {
         }
       }
       let outcome;
+      const startedAt = Date.now();
       try {
         outcome = await executor(due.config, {
           db,
@@ -20258,8 +20498,8 @@ async function runDomainGroup(deps, group, cb) {
       }
       const finishedAt = Date.now();
       if (outcome.status === "completed") {
-        advanceAfterRun(db, projectIdentity, due, finishedAt, "completed", null, outcome.schedulePatch);
-        cb?.onRan?.(due.config.task, outcome.detail);
+        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);
         cb?.onFailed?.(due.config.task, outcome.failureDetail ?? outcome.error);
@@ -20326,6 +20566,7 @@ async function runManualDream(deps) {
     return result;
   }
   const groups = new Map;
+  const runLocalBacklogs = {};
   for (const d of gated) {
     const kind = leaseKindFor(d.config.task);
     const arr = groups.get(kind) ?? [];
@@ -20335,10 +20576,12 @@ async function runManualDream(deps) {
   await Promise.all([...groups.values()].map((group) => runDomainGroup({ ...deps, executor: deps.executor }, group, {
     forceGate,
     leaseWaitMs: MANUAL_RUN_LEASE_WAIT_MS,
-    onRan: (t, detail) => {
+    onRan: (t, detail, backlog) => {
       result.ran.push(t);
       if (detail)
         result.details?.push(detail);
+      if (backlog)
+        runLocalBacklogs[t] = backlog;
     },
     onFailed: (task, error) => {
       result.failed.push(task);
@@ -20347,7 +20590,10 @@ async function runManualDream(deps) {
     },
     onBusy: (t) => result.deferredBusy.push(t)
   })));
-  result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
+  result.backlogAfter = {
+    ...getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames),
+    ...runLocalBacklogs
+  };
   return result;
 }
 async function runDueTasksForProject(deps) {
@@ -21380,6 +21626,8 @@ async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
   registerProjectEmbedding(db, projectIdentity, routing.primary, features, directory);
   if (routing.shadow) {
     registerProjectShadowEmbedding(db, projectIdentity, routing.shadow, directory);
+  } else {
+    unregisterProjectShadowEmbedding(projectIdentity);
   }
 }
 
@@ -22081,6 +22329,56 @@ function createTagger() {
   };
 }
 
+// src/plugin/memory-id-translation.ts
+function unmappedMemoryIdMessage(id) {
+  return `Error: memory id ${id} has no module mapping yet — it was written seconds ago or the mirror is behind; retry or use the id shown in <project-memory>.`;
+}
+function translateHostMemoryIds(db, hostIds) {
+  const moduleIds = [];
+  for (const hostId of hostIds) {
+    const identity = moduleMemoryIdentityForHostId(db, hostId);
+    if (!identity)
+      return { error: unmappedMemoryIdMessage(hostId) };
+    moduleIds.push(identity.moduleRowId);
+  }
+  return { moduleIds };
+}
+function moduleMemoryOperation(response, depth = 0) {
+  if (depth > 4 || response === null || typeof response !== "object")
+    return null;
+  if (Array.isArray(response)) {
+    for (const item of response) {
+      const operation = moduleMemoryOperation(item, depth + 1);
+      if (operation)
+        return operation;
+    }
+    return null;
+  }
+  const record = response;
+  if (record.memory_operation !== null && typeof record.memory_operation === "object" && typeof record.memory_operation.action === "string") {
+    return record.memory_operation;
+  }
+  return moduleMemoryOperation(record.result, depth + 1);
+}
+function translateModuleMemoryMutationReply(args) {
+  const operation = moduleMemoryOperation(args.response);
+  if (operation?.action === "write" && operation.module_id !== undefined) {
+    const identity = hostMemoryIdentityForModuleId(args.db, args.moduleProject, operation.module_id);
+    const category = operation.category ?? args.requestedCategory;
+    return identity ? `Saved memory [ID: ${identity.contextRowId}] in ${category}.` : `Saved memory in ${category}. Its id will appear in <project-memory> on the next pass.`;
+  }
+  if (operation?.action === "merge" && operation.canonical_module_id !== undefined) {
+    const canonical = hostMemoryIdentityForModuleId(args.db, args.moduleProject, operation.canonical_module_id);
+    const superseded = (operation.superseded_module_ids ?? []).map((moduleId) => hostMemoryIdentityForModuleId(args.db, args.moduleProject, moduleId)?.contextRowId).filter((id) => id !== undefined);
+    const category = operation.category ?? args.requestedCategory;
+    if (canonical) {
+      return `Merged memories [${args.requestedHostIds.join(", ")}] into canonical memory [ID: ${canonical.contextRowId}] in ${category}; superseded [${superseded.join(", ")}].`;
+    }
+    return `Merged memories [${args.requestedHostIds.join(", ")}] into a canonical memory in ${category}. Its id will appear in <project-memory> on the next pass.`;
+  }
+  return null;
+}
+
 // src/plugin/rpc-handlers.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { once } from "node:events";
@@ -26971,11 +27269,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",
@@ -27625,36 +27947,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,
@@ -27668,6 +27997,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(isRecord).filter((compartment) => typeof compartment.sequence === "number" && typeof compartment.end_message_id === "string");
   serialized.sort((left, right) => left.sequence - right.sequence);
@@ -28140,21 +28478,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) {
@@ -29517,7 +29936,7 @@ function registerRpcHandlers(rpcServer, args) {
   const buildManagedCtx = async (db) => {
     const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-v1fkhjjr.js");
     const { resolveHistorianModel } = await import("./model-resolution-dxatzjde.js");
-    const { userMemoryCollectionEnabled } = await import("./task-config-ys0arma5.js");
+    const { userMemoryCollectionEnabled } = await import("./task-config-cv8k9y8r.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
     const historianModel = resolveHistorianModel(config, "opencode");
     return {
@@ -29548,8 +29967,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-c4sa354a.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-xnypkxpx.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-0xx1364v.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-jbxknvar.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedRecomp(ctx, sessionId).then((message) => {
@@ -29567,8 +29986,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade } = await import("./recomp-orchestrator-c4sa354a.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-xnypkxpx.js");
+    const { runManagedUpgrade } = await import("./recomp-orchestrator-0xx1364v.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-jbxknvar.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedUpgrade(ctx, sessionId).then((message) => {
@@ -29584,7 +30003,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta } = await import("./storage-meta-session-x3j0q9qy.js");
+      const { updateSessionMeta } = await import("./storage-meta-session-z818pn1e.js");
       updateSessionMeta(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -30100,6 +30519,31 @@ function releaseClaimWithoutDelivery(db, sessionId, claimToken) {
     sessionLog(sessionId, "channel2 terminal-run claim release failed; lease will heal:", error);
   }
 }
+async function deliverSyntheticUserMessage(sessionId, deps) {
+  const promptContext = await resolvePromptContext2(deps.client, sessionId);
+  const body = {
+    noReply: false,
+    parts: [{ type: "text", text: deps.text, synthetic: true }]
+  };
+  if (promptContext?.agent)
+    body.agent = promptContext.agent;
+  if (promptContext?.model) {
+    body.model = {
+      providerID: promptContext.model.providerID,
+      modelID: promptContext.model.modelID
+    };
+  }
+  if (promptContext?.variant)
+    body.variant = promptContext.variant;
+  if (deps.beforeSend && !deps.beforeSend())
+    return false;
+  const session = deps.client.session;
+  if (typeof session?.promptAsync !== "function") {
+    throw new Error("client has no session.promptAsync");
+  }
+  await session.promptAsync({ path: { id: sessionId }, body });
+  return true;
+}
 async function maybeDeliverChannel2(sessionId, deps) {
   let state;
   try {
@@ -30138,36 +30582,25 @@ async function maybeDeliverChannel2(sessionId, deps) {
     return false;
   }
   try {
-    const promptContext = await resolvePromptContext2(client, sessionId);
     const reminder = deps.directiveText ?? buildChannel2Reminder(effectiveU, reclaimableToolOutputCount(deps.baseline?.baselineParts ?? []), deps.oldestReclaimableToolTags);
-    const body = {
-      noReply: false,
-      parts: [{ type: "text", text: reminder, synthetic: true }]
-    };
-    if (promptContext?.agent)
-      body.agent = promptContext.agent;
-    if (promptContext?.model) {
-      body.model = {
-        providerID: promptContext.model.providerID,
-        modelID: promptContext.model.modelID
-      };
-    }
-    if (promptContext?.variant)
-      body.variant = promptContext.variant;
-    const session = client.session;
-    if (typeof session?.promptAsync !== "function") {
-      throw new Error("client has no session.promptAsync");
-    }
-    const claim = getChannel2NudgeClaim(deps.db, sessionId);
-    if (claim.state !== "claimed" || claim.claimToken !== claimToken) {
-      sessionLog(sessionId, `channel2 ceiling nudge delivery skipped: claim no longer owned before send (state=${claim.state || "empty"})`);
-      return false;
-    }
-    if (!subagentRunIsActive(deps, sessionId)) {
-      releaseClaimWithoutDelivery(deps.db, sessionId, claimToken);
+    const sent = await deliverSyntheticUserMessage(sessionId, {
+      client,
+      text: reminder,
+      beforeSend: () => {
+        const claim = getChannel2NudgeClaim(deps.db, sessionId);
+        if (claim.state !== "claimed" || claim.claimToken !== claimToken) {
+          sessionLog(sessionId, `channel2 ceiling nudge delivery skipped: claim no longer owned before send (state=${claim.state || "empty"})`);
+          return false;
+        }
+        if (!subagentRunIsActive(deps, sessionId)) {
+          releaseClaimWithoutDelivery(deps.db, sessionId, claimToken);
+          return false;
+        }
+        return true;
+      }
+    });
+    if (!sent)
       return false;
-    }
-    await session.promptAsync({ path: { id: sessionId }, body });
   } catch (error) {
     try {
       const restored = casChannel2NudgeClaim(deps.db, sessionId, "pending", claimToken);
@@ -30203,7 +30636,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
@@ -30325,7 +30758,7 @@ function replayCavemanCompression(sessionId, db, targets, tags) {
 }
 
 // src/hooks/magic-context/compaction-off-transition.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 var loggedUnverifiedMarkerCleanupRetry = false;
 var COMPACTION_OFF_FLIP_NOTICE = [
   "## Magic Context — compaction-off mode is now active",
@@ -30360,7 +30793,7 @@ function clearCachedM0Baseline(db, sessionId) {
   return (result.changes ?? 0) > 0;
 }
 function cleanupOffMarkers(sessionId) {
-  if (!existsSync11(getOpenCodeDbPath())) {
+  if (!existsSync12(getOpenCodeDbPath())) {
     return { verified: true, removedLineages: 0, removedRows: 0, retainedLineages: 0 };
   }
   return removeMcOwnedCompactionMarkers(sessionId, MARKER_SUMMARY_TEXT);
@@ -31297,7 +31730,7 @@ function createPassOutcome() {
 }
 
 // src/hooks/magic-context/rust-mode-transform.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID6 } from "node:crypto";
 
 // src/hooks/magic-context/raw-fallback-context-limit.ts
 class RawFallbackContextLimitError extends Error {
@@ -33813,7 +34246,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;
@@ -33840,6 +34274,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;
@@ -33861,29 +34296,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);
@@ -33909,13 +34344,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;
@@ -33947,9 +34377,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;
@@ -34711,6 +35138,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) {
@@ -35620,6 +36049,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 = randomUUID6();
+    const originalBody = isRecord4(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 = randomUUID6();
+    sessionLog(args.sessionId, `rust silent resend original_attempt=${originalAttemptId} resend_attempt=${resendAttemptId} silent_gap_ms=${Date.now() - startedAtMs}`);
+    const resendBody = isRecord4(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;
@@ -35836,6 +36323,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;
@@ -35869,11 +36358,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);
@@ -36176,6 +36669,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({
@@ -36370,7 +36864,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");
@@ -36381,7 +36875,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",
@@ -36392,7 +36886,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 {
@@ -36918,6 +37413,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
         });
@@ -37414,6 +37924,7 @@ function createTransform(deps) {
     projectRoot: deps.rustModeProjectRoot,
     notifyParked: deps.onRustModeParked,
     onProjectPrepared: deps.onRustModeProjectPrepared,
+    onEngineReconnectRefusal: deps.onRustEngineReconnectRefusal,
     memorySyncRequestedSessions: deps.rustMemorySyncRequestedSessions,
     allowAuthorityProtocolBypassForTests: deps.rustModeAllowAuthorityProtocolBypassForTests
   }) : undefined;
@@ -38832,6 +39343,142 @@ function formatEmbedFailureSummary(embedded, remaining, failure, style = "markdo
   return `${progress} ${renderEmbeddingFailure(failure?.class ?? "empty_result", style)}`;
 }
 
+// src/hooks/magic-context/rust-refusal-recovery.ts
+var RUST_REFUSAL_RECOVERY_PROMPT = "Magic Context's engine reconnected. Continue from where you stopped.";
+var RUST_REFUSAL_RECOVERY_POLL_MS = 2000;
+var RUST_REFUSAL_RECOVERY_MAX_MS = 5 * 60000;
+var RUST_REFUSAL_RECOVERY_PROBE_TIMEOUT_MS = 2000;
+function errorContainsReconnectRefusal(error) {
+  try {
+    return JSON.stringify(error).includes(ENGINE_RECONNECTING_USER_MESSAGE);
+  } catch {
+    return false;
+  }
+}
+function createRustRefusalRecovery(options) {
+  const watchers = new Map;
+  const latestRefusalBySession = new Map;
+  const pollIntervalMs = options.pollIntervalMs ?? RUST_REFUSAL_RECOVERY_POLL_MS;
+  const maxDurationMs = options.maxDurationMs ?? RUST_REFUSAL_RECOVERY_MAX_MS;
+  const probeTimeoutMs = options.probeTimeoutMs ?? RUST_REFUSAL_RECOVERY_PROBE_TIMEOUT_MS;
+  const readLatestMessage = options.readLatestMessage ?? latestPersistedMessageForRecovery;
+  const cancel = (sessionId) => {
+    const watcher = watchers.get(sessionId);
+    if (!watcher)
+      return;
+    clearTimeout(watcher.timer);
+    watchers.delete(sessionId);
+  };
+  const schedule = (sessionId, watcher) => {
+    watcher.timer = setTimeout(() => void poll(sessionId, watcher), pollIntervalMs);
+  };
+  const probe = async (watcher, sessionId) => {
+    const controller = new AbortController;
+    const timeoutError = new Error("rust refusal recovery probe timed out");
+    const timer = setTimeout(() => controller.abort(timeoutError), probeTimeoutMs);
+    try {
+      await Promise.race([
+        options.moduleClient.call({
+          sessionId,
+          projectRoot: watcher.projectRoot,
+          method: "session.status",
+          body: { method: "session.status", v: 1, session_id: sessionId },
+          signal: controller.signal,
+          timeoutMs: probeTimeoutMs,
+          bypassSessionLane: true
+        }),
+        new Promise((_resolve, reject) => {
+          controller.signal.addEventListener("abort", () => reject(controller.signal.reason ?? timeoutError), { once: true });
+        })
+      ]);
+      return true;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const poll = async (sessionId, watcher) => {
+    if (watchers.get(sessionId) !== watcher)
+      return;
+    if (Date.now() - watcher.armedAtMs >= maxDurationMs) {
+      cancel(sessionId);
+      sessionLog(sessionId, "rust refusal recovery expired before the module became healthy");
+      return;
+    }
+    if (!await probe(watcher, sessionId)) {
+      schedule(sessionId, watcher);
+      return;
+    }
+    let latest;
+    try {
+      latest = readLatestMessage(sessionId);
+    } catch (error) {
+      sessionLog(sessionId, "rust refusal recovery could not read persisted history:", error);
+      schedule(sessionId, watcher);
+      return;
+    }
+    const matchingAssistant = latest?.role === "assistant" && (latest.parentID === undefined || latest.parentID === watcher.refusedUserMessageId) ? latest : null;
+    const stillRefusedStep = matchingAssistant !== null && (errorContainsReconnectRefusal(matchingAssistant.error) || matchingAssistant.parentID === watcher.refusedUserMessageId && matchingAssistant.error === undefined && matchingAssistant.completedAt === undefined);
+    if (!stillRefusedStep) {
+      cancel(sessionId);
+      sessionLog(sessionId, "rust refusal recovery skipped because persisted history advanced past the refused step");
+      return;
+    }
+    if (watcher.state !== "pending" || watchers.get(sessionId) !== watcher)
+      return;
+    watcher.state = "claimed";
+    const delivered = await deliverSyntheticUserMessage(sessionId, {
+      client: options.client,
+      text: RUST_REFUSAL_RECOVERY_PROMPT,
+      beforeSend: () => watchers.get(sessionId) === watcher && watcher.state === "claimed"
+    }).catch((error) => {
+      sessionLog(sessionId, "rust refusal recovery synthetic delivery failed:", error);
+      return false;
+    });
+    if (!delivered) {
+      if (watchers.get(sessionId) === watcher) {
+        watcher.state = "pending";
+        schedule(sessionId, watcher);
+      }
+      return;
+    }
+    watchers.delete(sessionId);
+    sessionLog(sessionId, "rust refusal recovery synthetic continue delivered");
+  };
+  return {
+    arm(args) {
+      if (args.compactionOff || args.providerProvenEmergency)
+        return;
+      const refusalKey = `${args.sessionId}:${args.refusedUserMessageId}`;
+      if (latestRefusalBySession.get(args.sessionId) === refusalKey)
+        return;
+      latestRefusalBySession.set(args.sessionId, refusalKey);
+      const current = watchers.get(args.sessionId);
+      if (current)
+        cancel(args.sessionId);
+      const watcher = {
+        refusalKey,
+        refusedUserMessageId: args.refusedUserMessageId,
+        projectRoot: args.projectRoot,
+        armedAtMs: Date.now(),
+        state: "pending"
+      };
+      watchers.set(args.sessionId, watcher);
+      schedule(args.sessionId, watcher);
+      sessionLog(args.sessionId, `rust refusal recovery armed refusal=${refusalKey}`);
+    },
+    cancel,
+    forget(sessionId) {
+      cancel(sessionId);
+      latestRefusalBySession.delete(sessionId);
+    },
+    activeCountForTests() {
+      return watchers.size;
+    }
+  };
+}
+
 // src/hooks/magic-context/text-complete.ts
 function createTextCompleteHandler() {
   return async (_input, output) => {
@@ -39232,7 +39879,7 @@ function memoryGuidanceBlock(memoryEnabled) {
 ` : "";
 }
 var BASE_INTRO = (memoryEnabled) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
-Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking is NOT an immediate delete — it queues the content, which stays fully visible until space is actually needed (as soon as the next turn if you're already under pressure, much later if not), so mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The newest token-mass window stays protected until displaced. Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
+Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. 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. Mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The newest token-mass window stays protected until displaced. Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
 Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
 ${CTX_NOTE_GUIDANCE}
 ${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
@@ -39993,6 +40640,8 @@ function createMagicContextHook(deps) {
       authoritySeed: (args) => transport.authoritySeed(args),
       authorityDrain: (args) => transport.authorityDrain(args),
       mirrorPull: (args) => transport.mirrorPull(args),
+      mirrorMemory: (args) => transport.mirrorMemory(args),
+      memoryIdentityAck: (args) => transport.memoryIdentityAck(args),
       getCompartmentsAfter: async (sessionId, afterSequence) => {
         const response = await transport.call({
           sessionId,
@@ -40023,18 +40672,45 @@ function createMagicContextHook(deps) {
     return client;
   })();
   const rustModeModuleClient = deps.config.transform_mode === "rust" ? authorityRecoveryModuleClient : undefined;
-  const syncModuleDomain = async (domain) => {
+  const rustRefusalRecovery = rustModeModuleClient ? createRustRefusalRecovery({
+    moduleClient: rustModeModuleClient,
+    client: deps.client
+  }) : undefined;
+  const syncModuleDomain = async (domain, pageBudget) => {
     if (!rustModeModuleClient?.mirrorPull)
       return;
     await drainMirrorPages({
       db,
       module: rustModeModuleClient,
       domain,
-      limit: 1000
+      limit: 1000,
+      pageBudget
     });
   };
   const syncModuleNotes = () => syncModuleDomain("notes");
-  const syncModuleMemories = () => syncModuleDomain("memories");
+  const syncModuleMemoryIdentity = async (moduleProject, moduleRowId, projectRoot) => {
+    if (!rustModeModuleClient?.mirrorMemory)
+      return;
+    const { row } = await rustModeModuleClient.mirrorMemory({
+      module_row_id: moduleRowId,
+      projectRoot
+    });
+    if (!row)
+      return;
+    const identity = applyTargetedMemoryMirrorRow({ db, row });
+    if (!identity || !rustModeModuleClient.memoryIdentityAck)
+      return;
+    await rustModeModuleClient.memoryIdentityAck({
+      project: moduleProject,
+      projectRoot,
+      rows: [
+        {
+          module_row_id: moduleRowId,
+          context_row_id: identity.contextRowId
+        }
+      ]
+    });
+  };
   const rustToolBackends = deps.config.transform_mode === "rust" && rustModeModuleClient ? {
     authorityState: async ({ projectPath, projectRoot, sessionId, domain }) => {
       if (!rustModeModuleClient.authorityStatus)
@@ -40075,7 +40751,7 @@ function createMagicContextHook(deps) {
       filter,
       limit,
       offset,
-      noteId
+      noteIds
     }) => {
       const response = await rustModeModuleClient.call({
         sessionId,
@@ -40096,13 +40772,13 @@ function createMagicContextHook(deps) {
             filter,
             limit,
             offset,
-            note_id: noteId
+            note_ids: noteIds
           }
         }
       });
       await syncModuleNotes();
       if (compileStatus && !moduleNoteResponseIsError(response)) {
-        const moduleRowId = action === "write" ? moduleNoteRowId(response) : noteId ?? null;
+        const moduleRowId = action === "write" ? moduleNoteRowId(response) : noteIds?.[0] ?? null;
         if (moduleRowId === null || !applyMirroredNoteCompileFields({
           db,
           moduleProject: memoryProject,
@@ -40131,6 +40807,11 @@ function createMagicContextHook(deps) {
       reason,
       limit
     }) => {
+      const hostIds = ids ?? [];
+      const translatedIds = translateHostMemoryIds(db, hostIds);
+      if ("error" in translatedIds)
+        return translatedIds.error;
+      const moduleIds = translatedIds.moduleIds;
       const response = await rustModeModuleClient.call({
         sessionId,
         projectRoot,
@@ -40142,14 +40823,24 @@ function createMagicContextHook(deps) {
             action,
             content,
             category,
-            ids,
+            ids: moduleIds,
+            host_ids: hostIds,
+            memory_id_lane: "host",
             reason,
             limit,
             memory_project: memoryProject
           }
         }
       });
-      await syncModuleMemories();
+      const operation = moduleMemoryOperation(response);
+      const newModuleRowId = operation?.action === "write" ? operation.module_id : operation?.action === "merge" ? operation.canonical_module_id : undefined;
+      try {
+        if (newModuleRowId !== undefined) {
+          await syncModuleMemoryIdentity(memoryProject, newModuleRowId, projectRoot);
+        }
+      } catch (error) {
+        log("[magic-context] targeted memory mirror sync failed:", error);
+      }
       if (!moduleNoteResponseIsError(response) && (action === "write" || action === "update" || action === "merge")) {
         (async () => {
           await ensureProjectRegisteredFromOpenCodeDirectory(projectRoot, db);
@@ -40161,7 +40852,13 @@ function createMagicContextHook(deps) {
           log("[magic-context] mirrored memory embedding failed:", error);
         });
       }
-      return response;
+      return translateModuleMemoryMutationReply({
+        db,
+        moduleProject: memoryProject,
+        response,
+        requestedHostIds: hostIds,
+        requestedCategory: category
+      }) ?? response;
     },
     noteEvaluationAvailable: (evaluationProjectPath) => getModuleNoteEvaluationBridge(evaluationProjectPath) !== undefined,
     memorySync: (sessionId) => {
@@ -40298,7 +40995,8 @@ function createMagicContextHook(deps) {
     tsAuthorityRecoveryModuleClient: authorityRecoveryModuleClient,
     rustMemorySyncRequestedSessions,
     onRustModeParked: notifyRustModeParked,
-    onRustModeProjectPrepared: ensureModuleNoteEvaluationBridge
+    onRustModeProjectPrepared: ensureModuleNoteEvaluationBridge,
+    onRustEngineReconnectRefusal: (args) => rustRefusalRecovery?.arm(args)
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -40323,6 +41021,7 @@ function createMagicContextHook(deps) {
     },
     rustSessionCleanup: rustModeModuleClient !== undefined,
     onSessionDeleted: async (sessionId) => {
+      rustRefusalRecovery?.forget(sessionId);
       dropSlot(sessionId, "session-deleted");
       try {
         await transform.clearRustSession(sessionId);
@@ -40965,6 +41664,46 @@ Two recovery modes for finer detail:
 - ctx_expand(message=138) — returns the FULL untruncated content of the message at that ordinal: every text part, and every tool call's complete input + output, read from stored history. This is the cheap way to get back a tool output you dropped with ctx_reduce — the original is still in storage even though the wire shows [dropped §N§]. If the message was deleted from history (session prune/revert), it says so.`;
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
+// src/tools/ctx-expand/mode.ts
+function isInt(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function minOrdinal(domain) {
+  return domain === "non-negative" ? 0 : 1;
+}
+function messageError(domain) {
+  return domain === "non-negative" ? "Error: message must be a non-negative integer." : "Error: message must be a positive integer.";
+}
+function rangeError(domain) {
+  return domain === "non-negative" ? "Error: provide either message=<ordinal>, or start and end (non-negative integers, start <= end)." : "Error: provide either message=<ordinal>, or start and end (positive integers, start <= end).";
+}
+function resolveCtxExpandMode(args, domain) {
+  const min = minOrdinal(domain);
+  const messagePresent = args.message !== undefined && args.message !== null;
+  const message = isInt(args.message) ? args.message : undefined;
+  const start = isInt(args.start) ? args.start : undefined;
+  const end = isInt(args.end) ? args.end : undefined;
+  const messageValid = message !== undefined && message >= min;
+  const rangeValid = start !== undefined && end !== undefined && start >= min && end >= start;
+  const fillerPair = start === 0 && end === 0;
+  const rangeNamed = rangeValid && !fillerPair;
+  if (messageValid && !rangeNamed) {
+    return { kind: "message", message };
+  }
+  if (messagePresent && !messageValid && !rangeNamed) {
+    return { kind: "error", message: messageError(domain) };
+  }
+  if (rangeValid) {
+    return {
+      kind: "range",
+      start,
+      end,
+      verbose: args.verbose === true
+    };
+  }
+  return { kind: "error", message: rangeError(domain) };
+}
+
 // src/tools/ctx-expand/render.ts
 function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -41158,27 +41897,26 @@ function createCtxExpandTool(deps) {
         message: "number"
       });
       const sessionId = toolContext.sessionID;
-      if (args.message !== undefined) {
-        if (typeof args.message !== "number" || !Number.isInteger(args.message) || args.message < 1) {
-          return "Error: message must be a positive integer.";
-        }
-        return renderMessageByOrdinal(sessionId, args.message);
+      const mode = resolveCtxExpandMode(args, "positive");
+      if (mode.kind === "error") {
+        return mode.message;
       }
-      if (!args.start || !args.end || !Number.isInteger(args.start) || !Number.isInteger(args.end) || args.start < 1 || args.end < args.start) {
-        return "Error: provide either message=<ordinal>, or start and end (positive integers, start <= end).";
+      if (mode.kind === "message") {
+        return renderMessageByOrdinal(sessionId, mode.message);
       }
+      const { start, end, verbose } = mode;
       const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
-      if (lastCompartmentEnd >= 0 && args.start > lastCompartmentEnd) {
-        return `Range ${args.start}-${args.end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
+      if (lastCompartmentEnd >= 0 && start > lastCompartmentEnd) {
+        return `Range ${start}-${end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
       }
-      const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(args.end, lastCompartmentEnd) : args.end;
-      if (args.verbose === true) {
-        const v = renderVerboseRange(sessionId, args.start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
+      const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(end, lastCompartmentEnd) : end;
+      if (verbose) {
+        const v = renderVerboseRange(sessionId, start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
         if (!v.text) {
-          return `No messages found in range ${args.start}-${effectiveEnd}. The range may be outside this session's history.`;
+          return `No messages found in range ${start}-${effectiveEnd}. The range may be outside this session's history.`;
         }
         const out = [
-          `Messages ${args.start}-${v.lastOrdinal} (verbose). Recover any one in full with ctx_expand(message=<ordinal>):`,
+          `Messages ${start}-${v.lastOrdinal} (verbose). Recover any one in full with ctx_expand(message=<ordinal>):`,
           "",
           v.text
         ];
@@ -41188,9 +41926,9 @@ function createCtxExpandTool(deps) {
         return out.join(`
 `);
       }
-      const chunk = readSessionChunk(sessionId, CTX_EXPAND_TOKEN_BUDGET, args.start, effectiveEnd + 1);
+      const chunk = readSessionChunk(sessionId, CTX_EXPAND_TOKEN_BUDGET, start, effectiveEnd + 1);
       if (!chunk.text || chunk.messageCount === 0) {
-        return `No messages found in range ${args.start}-${args.end}. The range may be outside this session's history.`;
+        return `No messages found in range ${start}-${end}. The range may be outside this session's history.`;
       }
       const lines = [];
       lines.push(`Messages ${chunk.startIndex}-${chunk.endIndex} (${chunk.messageCount} messages, ~${chunk.tokenEstimate} tokens):`);
@@ -41253,7 +41991,7 @@ function isMemoryCategory(value) {
   return MEMORY_CATEGORIES.has(value);
 }
 function normalizeLimit2(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit === 0) {
     return DEFAULT_SEARCH_LIMIT;
   }
   return Math.max(1, Math.floor(limit));
@@ -41535,6 +42273,27 @@ function createCtxMemoryTool(deps) {
         return "Error: Could not resolve project identity for memory action.";
       }
       await deps.ensureProjectRegistered?.(toolContext.directory, deps.db);
+      const activeCurateCategory = toolContext.agent === DREAMER_AGENT ? getActiveCurateCategory(deps.db, projectPath) : null;
+      if (activeCurateCategory) {
+        const usesCategory = ["write", "update", "merge", "list"].includes(args.action);
+        const usesIds = ["update", "archive", "merge", "get"].includes(args.action);
+        const usesSuccessor = args.action === "update" || args.action === "archive";
+        const scopeRefusal = getCurateCategoryScopeRefusal({
+          scope: activeCurateCategory,
+          action: args.action,
+          requestedCategory: usesCategory ? args.category : undefined,
+          ids: usesIds ? [
+            ...args.ids ?? [],
+            ...usesSuccessor && Number.isInteger(args.superseded_by) ? [args.superseded_by] : []
+          ] : [],
+          categoryForId: (id) => {
+            const category = getMemoryById(deps.db, id)?.category;
+            return category ? curateCategoryForMemoryCategory(category) : null;
+          }
+        });
+        if (scopeRefusal)
+          return scopeRefusal;
+      }
       const curatePreflight = toolContext.agent === DREAMER_AGENT ? preflightCurateMutation({
         db: deps.db,
         params: args,
@@ -41669,7 +42428,8 @@ function createCtxMemoryTool(deps) {
       if (args.action === "list") {
         const limit = normalizeLimit2(args.limit);
         const category = normalizeCategory(args.category);
-        const memories = filterByCategory(getMemoriesByProject(deps.db, projectPath), category).slice(0, limit);
+        const allMemories = getMemoriesByProject(deps.db, projectPath);
+        const memories = (activeCurateCategory ? allMemories.filter((memory) => curateCategoryForMemoryCategory(memory.category) === activeCurateCategory) : filterByCategory(allMemories, category)).slice(0, limit);
         return formatMemoryList(memories);
       }
       if (args.action === "get") {
@@ -41926,7 +42686,7 @@ Use a note when something matters LATER but not in the next few steps: "revisit
 Actions:
 - write: save a note (content). Add surface_condition to make it a smart note (below).
 - read: list notes, newest first. Default: latest active session notes + ready smart notes; page older ones with limit/offset, or inspect other states with filter.
-- update: change a note by note_id. dismiss: retire one by note_id or 1–50 by note_ids; provide exactly one.
+- update: change one note (note_ids=[N]). dismiss: retire 1–50 notes (note_ids=[...]).
 
 Smart notes: pass surface_condition and the note stays hidden until a background checker confirms the condition — using ONLY externally verifiable signals (GitHub state via gh, files on disk, git history, web pages). It cannot see this conversation, so the condition must be checkable from outside:
 ✓ "When PR #42 in cortexkit/magic-context is merged"
@@ -41939,7 +42699,7 @@ Example: ctx_note(action="write", content="Re-run the perf benchmark once the bo
 import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/features/magic-context/smart-notes/condition-compiler.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { isAbsolute as isAbsolute4 } from "node:path";
 
 // ../retina-local-fs/src/path-fence.ts
@@ -42196,7 +42956,7 @@ async function compileSurfaceCondition(surfaceCondition, options) {
       dataDirectory: options.dataDirectory,
       cwd: options.projectPath
     });
-    return { path: resolved, exists: existsSync12(resolved) };
+    return { path: resolved, exists: existsSync13(resolved) };
   });
   let predicates;
   try {
@@ -42451,7 +43211,7 @@ function formatNoteLine(note) {
 }
 var DISMISS_FOOTER = `
 
-To dismiss a stale note: ctx_note(action="dismiss", note_id=N)`;
+To dismiss a stale note: ctx_note(action="dismiss", note_ids=[N])`;
 var DEFAULT_READ_LIMIT = 25;
 function paginateNewestFirst(notes, limit, offset) {
   const total = notes.length;
@@ -42566,8 +43326,7 @@ var ctxNoteArgsShape = {
   filter: tool3.schema.enum(["all", "active", "pending", "ready", "dismissed"]).optional().describe("Optional read filter. Defaults to active session notes + ready smart notes. Use 'all' to inspect every status or 'pending' to inspect unsurfaced smart notes."),
   limit: tool3.schema.number().optional().describe("Max notes per section for read, newest first (default: 25)"),
   offset: tool3.schema.number().optional().describe("Skip this many newest notes for read — page older ones (default: 0)"),
-  note_id: tool3.schema.number().optional().describe("Note ID (required for 'dismiss' and 'update' actions)."),
-  note_ids: tool3.schema.array(tool3.schema.number().int().min(1)).min(1).max(50).optional().describe("One to fifty note ids for 'dismiss' only; do not combine with note_id.")
+  note_ids: tool3.schema.array(tool3.schema.number().int().min(1)).min(1).max(50).optional().describe("Note ids: exactly one for 'update', one to fifty for 'dismiss'. Ignored by 'write' and 'read'.")
 };
 var ctxNoteArgsSchema = tool3.schema.object(ctxNoteArgsShape).passthrough();
 function formatDismissResults(results) {
@@ -42576,9 +43335,10 @@ function formatDismissResults(results) {
 ${results.map((result) => `- Note #${result.noteId}: ${result.outcome}`).join(`
 `)}`;
 }
-function parseDismissNoteIds(value) {
-  if (!Array.isArray(value) || value.length < 1 || value.length > 50 || value.some((id) => typeof id !== "number" || !Number.isInteger(id) || id <= 0)) {
-    return "Error: 'note_ids' must contain 1 to 50 positive integer ids when action is 'dismiss'.";
+function parseNoteIds(action, value) {
+  const max = action === "update" ? 1 : 50;
+  if (!Array.isArray(value) || value.length < 1 || value.length > max || value.some((id) => typeof id !== "number" || !Number.isInteger(id) || id <= 0)) {
+    return action === "update" ? "Error: 'note_ids' must contain exactly one positive integer id when action is 'update'." : "Error: 'note_ids' must contain 1 to 50 positive integer ids when action is 'dismiss'.";
   }
   return value;
 }
@@ -42599,22 +43359,13 @@ function createCtxNoteTool(deps) {
         },
         limit: "number",
         offset: "number",
-        note_id: "number",
         note_ids: { type: "array", items: "number", maxItems: 50 }
       });
       const sessionId = toolContext.sessionID;
       const action = args.action ?? (args.content?.trim() ? "write" : "read");
-      const hasNoteId = args.note_id !== undefined;
-      const hasNoteIds = args.note_ids !== undefined;
-      if (hasNoteId && hasNoteIds) {
-        return "Error: 'note_id' and 'note_ids' cannot be used together; provide one or the other.";
-      }
-      if (hasNoteIds && action !== "dismiss") {
-        return "Error: 'note_ids' is only valid when action is 'dismiss'.";
-      }
-      const dismissNoteIds = action === "dismiss" && hasNoteIds ? parseDismissNoteIds(args.note_ids) : undefined;
-      if (typeof dismissNoteIds === "string")
-        return dismissNoteIds;
+      const noteIds = action === "dismiss" || action === "update" ? parseNoteIds(action, args.note_ids) : undefined;
+      if (typeof noteIds === "string")
+        return noteIds;
       const wakePlaneActive = action === "write" && Boolean(args.surface_condition?.trim()) && await wakePlaneStatus() === "present";
       const surfaceCondition = wakePlaneActive ? undefined : args.surface_condition?.trim();
       const projectIdentity = deps.resolveProjectPath?.(toolContext.directory);
@@ -42663,8 +43414,7 @@ function createCtxNoteTool(deps) {
           filter: args.filter,
           limit: args.limit,
           offset: args.offset,
-          noteId: args.note_id,
-          noteIds: dismissNoteIds
+          noteIds: Array.isArray(noteIds) ? noteIds : undefined
         };
         try {
           const text = moduleNoteText(await rustNote(request), args, action);
@@ -42733,33 +43483,24 @@ wake plane active — create a scheduled wake instead; stored as a plain note.`;
         return `Saved session note #${note.id}.`;
       }
       if (action === "dismiss") {
-        if (dismissNoteIds) {
-          if (!projectIdentity) {
-            return "Error: Could not resolve project identity for note dismiss.";
-          }
-          return formatDismissResults(dismissNotes(deps.db, dismissNoteIds, {
-            projectPath: projectIdentity,
-            sessionId
-          }));
-        }
-        const noteId = args.note_id;
-        if (typeof noteId !== "number") {
-          return "Error: 'note_id' is required when action is 'dismiss'.";
-        }
         if (!projectIdentity) {
           return "Error: Could not resolve project identity for note dismiss.";
         }
-        const dismissed = dismissNote(deps.db, noteId, {
+        const ids = noteIds;
+        if (ids.length === 1) {
+          const dismissed = dismissNote(deps.db, ids[0], {
+            projectPath: projectIdentity,
+            sessionId
+          });
+          return dismissed ? `Note #${ids[0]} dismissed.` : `Error: Note #${ids[0]} not found in your session/project or already dismissed.`;
+        }
+        return formatDismissResults(dismissNotes(deps.db, ids, {
           projectPath: projectIdentity,
           sessionId
-        });
-        return dismissed ? `Note #${noteId} dismissed.` : `Error: Note #${noteId} not found in your session/project or already dismissed.`;
+        }));
       }
       if (action === "update") {
-        const noteId = args.note_id;
-        if (typeof noteId !== "number") {
-          return "Error: 'note_id' is required when action is 'update'.";
-        }
+        const noteId = noteIds[0];
         const updates = {};
         if (args.content?.trim())
           updates.content = args.content.trim();
@@ -42831,7 +43572,7 @@ function createCtxNoteTools(deps) {
 var CTX_REDUCE_DESCRIPTION = `Mark spent tagged content as discardable to reclaim context space. This is NOT an immediate delete. Use §N§ identifiers visible in the conversation. The \`drop\` param accepts ranges: "3-5", "1,2,9", "1-5,8".
 
 How it works:
-- Marking QUEUES content for release. It stays fully visible to you until context space is actually needed — which may be as soon as the next turn if you are already under pressure, or many turns later if not. So mark spent outputs as soon as you finish with them; don't hoard the call for the end of the turn.
+- 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. Mark spent outputs as soon as you finish with them; don't hoard the call for the end of the turn.
 - The newest tags are protected: marking one just queues it until it ages out of the recent window, so marking recent output is harmless.
 - When content is finally released it becomes a short placeholder, and re-running the tool is the only way to get it back. So mark only what you are genuinely DONE with — the test is "have I extracted what I need from this?", not "is it safe / do I have time before it drops?".
 
@@ -43076,7 +43817,7 @@ var VALID_SOURCES = new Set([
   "note"
 ]);
 function normalizeLimit3(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit === 0) {
     return DEFAULT_CTX_SEARCH_LIMIT;
   }
   return Math.max(1, Math.floor(limit));
@@ -43095,7 +43836,7 @@ function normalizeSources(sources) {
       }
     }
   }
-  return result;
+  return sources.length === 0 ? undefined : result;
 }
 var ctxSearchArgsShape = {
   query: tool5.schema.string().optional().describe("Search query. Matches against memory content, Primers, git commit messages, and raw user/assistant message text."),
@@ -43322,7 +44063,7 @@ import {
   chmodSync as chmodSync2,
   mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   renameSync as renameSync5,
   rmSync as rmSync4,
   unlinkSync as unlinkSync2,
@@ -43459,7 +44200,7 @@ class MagicContextRpcServer {
       for (const entry of readdirSync(this.portDir)) {
         if (!entry.startsWith("port-") || !entry.endsWith(".json"))
           continue;
-        const record = parseRpcPortFile(readFileSync6(`${this.portDir}/${entry}`, "utf-8"));
+        const record = parseRpcPortFile(readFileSync7(`${this.portDir}/${entry}`, "utf-8"));
         if (!record || record.pid === process.pid || !isPidAlive(record.pid))
           continue;
         log(`[rpc] another Magic Context RPC server is active for this project (pid ${record.pid}, port ${record.port}); starting separate instance on a new port`);
@@ -43853,7 +44594,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),
@@ -43862,115 +44836,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) {
@@ -43979,18 +45132,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 decode(row) {
   const data = JSON.parse(row.data);
@@ -44007,6 +45169,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();
@@ -44032,6 +45200,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 ? decode(row) : undefined;
+  }
   window(sessionID) {
     return this.db.transaction(() => {
       const cut = this.latestCompaction(sessionID);
@@ -44281,7 +45459,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) => {
@@ -44315,20 +45493,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,
@@ -44349,16 +45603,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))
@@ -44383,7 +45638,6 @@ async function registerContext(context) {
     getCount: (sessionID) => read(sessionID).length
   });
   let transform;
-  let db;
   const refuseIfUnsafe = async (draft) => {
     let unsafe = false;
     try {
@@ -44397,10 +45651,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);
         }
@@ -44420,7 +45672,8 @@ async function registerContext(context) {
       } finally {
         reader.close();
       }
-    } catch {
+    } catch (error) {
+      console.warn("[magic-context] v2 refuseIfUnsafe", error);
       unsafe = true;
     }
     if (unsafe)
@@ -44473,6 +45726,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))
@@ -44589,6 +45862,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;
@@ -44628,18 +45904,18 @@ ${baseline}
 }
 
 // src/v2/hooks/update-check.ts
-import { existsSync as existsSync13, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function packageInfo() {
   let directory = dirname8(fileURLToPath3(import.meta.url));
   for (;; ) {
     try {
-      const pkg = JSON.parse(readFileSync7(join12(directory, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync8(join11(directory, "package.json"), "utf8"));
       if (pkg.name === "@cortexkit/opencode-magic-context" && typeof pkg.version === "string") {
         return {
           version: pkg.version,
-          development: existsSync13(join12(directory, "src/v2/server.ts"))
+          development: existsSync14(join11(directory, "src/v2/server.ts"))
         };
       }
     } catch {}
@@ -44686,7 +45962,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);
@@ -44710,6 +45996,7 @@ var server = async (ctx) => {
   let hooksDeadlineReason = null;
   let deadlinePhase = null;
   emitBootEnteringBreadcrumb(process.pid, ctx.directory, log, flushLogger);
+  setHarness("opencode");
   const configStartedAt = performance.now();
   beginBootQuietPeriod();
   const configMigrationWarnings = migrateMagicContextConfigLocations(ctx.directory, {
@@ -44749,7 +46036,7 @@ var server = async (ctx) => {
     if (hasBannerEntries)
       setTimeout(async () => {
         try {
-          const { sendStatusNotification } = await import("./send-session-notification-xnypkxpx.js");
+          const { sendStatusNotification } = await import("./send-session-notification-jbxknvar.js");
           const clientWithSessions = ctx.client;
           const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
           const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -44766,7 +46053,7 @@ var server = async (ctx) => {
     log(`[magic-context] opencode_db_missing path=${openCodeDbResolution.path} source=${openCodeDbResolution.source}`);
     setTimeout(async () => {
       try {
-        const { sendStatusNotification } = await import("./send-session-notification-xnypkxpx.js");
+        const { sendStatusNotification } = await import("./send-session-notification-jbxknvar.js");
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -45012,12 +46299,12 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-jyj54gbe.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
+      import("./conflict-warning-hook-aktepwpz.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
     }
   }
   const serverUrl = ctx.serverUrl;
   const serverUrlStr = serverUrl instanceof URL ? serverUrl.toString().replace(/\/$/, "") : typeof serverUrl === "string" ? serverUrl.replace(/\/$/, "") : undefined;
-  import("./send-session-notification-xnypkxpx.js").then(({ setNotificationServerUrl }) => {
+  import("./send-session-notification-jbxknvar.js").then(({ setNotificationServerUrl }) => {
     setNotificationServerUrl(serverUrlStr);
   });
   if (conflictResult?.hasConflict) {
@@ -45040,7 +46327,7 @@ var server = async (ctx) => {
       }) => {
         if (!shouldShowAnnouncement())
           return;
-        return import("./conflict-warning-hook-jyj54gbe.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
+        return import("./conflict-warning-hook-aktepwpz.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
       }).catch(() => {});
     }, 8000);
   }