@cortexkit/opencode-magic-context 0.42.3 → 0.42.5

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   sessionLog,
   getLoggerDiagnostics,
   flushLogger
-} from "./index-dkv2dn46.js";
+} from "./index-qp20p2py.js";
 import {
   withContentLanguageDirective,
   buildPrimaryLanguageDirective,
@@ -71,6 +71,7 @@ import {
   checksumAuthoritySeedRows,
   prepareAuthority,
   drainAuthority,
+  getMemoryMirrorStatus,
   applyMirroredNoteCompileFields,
   drainMirrorPages,
   pullMemoryMirrorOnce,
@@ -191,6 +192,7 @@ import {
   isToolPartWithOutput,
   isFilePart,
   buildFileSourceContent,
+  assertExecutableToolInput,
   createDroppedInputToolExecuteBeforeHook,
   isEditTool,
   partHasCompletedResult,
@@ -359,6 +361,7 @@ import {
   replaceSourceContent,
   getSourceContents,
   createChildSessionWithFence,
+  HiddenCompletionRefusal,
   detectThinkingBindingMismatch,
   isFable51ThinkingBindingModel,
   detectOverflow,
@@ -472,6 +475,7 @@ import {
   verificationFileExists,
   normalizeVerificationFiles,
   recordChildInvocation,
+  createV1HiddenCompletionExecutor,
   USER_MEMORY_CANDIDATE_TTL_MS,
   insertUserMemoryCandidates,
   getUserMemoryCandidates,
@@ -522,6 +526,7 @@ import {
   mustMaterialize,
   trimMemoriesToBudgetV2,
   renderMemoryBlockV2,
+  materializeM0,
   prepareCachedM0M1Replay,
   hasCompleteCachedM0M1,
   injectM0M1,
@@ -542,7 +547,7 @@ import {
   setRecompTerminal2,
   runManagedRecomp2,
   runManagedUpgrade2
-} from "./index-wde5446v.js";
+} from "./index-3wbd8sdq.js";
 import {
   stripJsonComments,
   isPrototypePollutionKey,
@@ -568,7 +573,7 @@ import {
   deriveHistorianChunkTokens2,
   resolveKnownHistorianContextLimit2,
   resolveHistorianContextLimit2
-} from "./index-xdtge3y2.js";
+} from "./index-f9gem5cr.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
@@ -589,7 +594,7 @@ import {
   assistantAwaitingTools,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-z8552w7e.js";
+} from "./index-jkrqhc7y.js";
 import {
   getErrorMessage,
   describeError,
@@ -598,13 +603,13 @@ import {
   clearIgnoredMessages2,
   observeIgnoredNotificationEvent2,
   sendStatusNotification2
-} from "./index-gynz8qdc.js";
+} from "./index-p474rw9p.js";
 import {
   detectConflicts,
   resolveCompactionForBoot,
   sendConflictWarning2,
   cleanupConflictWarnings2
-} from "./index-ecz14qke.js";
+} from "./index-d8mgqezq.js";
 import {
   resolveHistorianModel2,
   resolveOpenCodeAgentOverrides2,
@@ -612,6 +617,7 @@ import {
 } from "./index-7k55qm8a.js";
 import {
   CANONICAL_DREAM_TASKS,
+  DREAM_TASK_CAPABILITIES,
   formatDreamTaskBacklogs,
   processedDreamTaskItems,
   leaseKindFor,
@@ -620,7 +626,7 @@ import {
   compareTaskOrder,
   buildDreamTaskRuntimeConfigs2,
   userMemoryCollectionEnabled2
-} from "./index-may8skc8.js";
+} from "./index-4wwr6cz0.js";
 import {
   logSlowWriteTransaction,
   getOrCreateSessionMeta2,
@@ -630,7 +636,7 @@ import {
   retryPendingSessionCleanups2,
   retryPendingRustSessionCleanupsForProject2,
   clearSession2
-} from "./index-sf6x1ga9.js";
+} from "./index-1ar7b3e9.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -646,7 +652,7 @@ import {
   ANNOUNCEMENT_FOOTER2,
   markAnnouncementSeen2,
   shouldShowAnnouncement2
-} from "./index-3wzdwt6p.js";
+} from "./index-ntbmt6rq.js";
 import {
   resolvePromptContext2
 } from "./index-fmsr7v69.js";
@@ -656,12 +662,13 @@ import {
   modelRefLookupOrder
 } from "./index-avwt563y.js";
 import {
+  setHarness,
   getHarness,
   getDataDir,
   getOpenCodeStorageDir,
   getMagicContextStorageResolution,
   getMagicContextStorageDir
-} from "./index-3fe78beq.js";
+} from "./index-4ftb5hcq.js";
 import {
   __toESM,
   __commonJS
@@ -10774,9 +10781,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.
@@ -10996,6 +11005,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":
@@ -12174,7 +12184,7 @@ var SERIAL_LANE_MAX_WAITERS = 16;
 var SERIAL_LANE_MAX_WAITERS_PER_SESSION = 8;
 var SERIAL_LANE_MIN_REMAINING_MS = 25;
 var CANONICAL_ROOT_CACHE_MAX_ENTRIES = 256;
-function getDefaultConnectionFile() {
+function getDefaultSubcConnectionFile() {
   return join5(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 function errorChainSome(error, predicate) {
@@ -12289,7 +12299,7 @@ class SubcModuleTransport {
     return capabilities;
   }
   constructor(connectionFile, moduleId = DEFAULT_MODULE_ID, requestTimeoutMs = MODULE_SEND_TIMEOUT_MS, routeSessionPrefix = "") {
-    this.connectionFile = connectionFile ?? getDefaultConnectionFile();
+    this.connectionFile = connectionFile;
     this.moduleId = moduleId;
     this.requestTimeoutMs = requestTimeoutMs;
     this.routeSessionPrefix = routeSessionPrefix;
@@ -12567,8 +12577,8 @@ class SubcModuleTransport {
   }
   async authorityStatus(args) {
     this.authorityProjectRoot = args.project;
-    const { projectRoot, ...body } = args;
-    const response = await this.authorityRequest(args.project, projectRoot ?? this.bindRootForAuthority(), "authority.status", body);
+    const { projectRoot, sessionId, ...body } = args;
+    const response = await this.authorityRequest(sessionId ?? args.project, projectRoot ?? this.bindRootForAuthority(), "authority.status", body);
     return { authority: response.authority ?? null };
   }
   async authorityPrepare(args) {
@@ -13560,6 +13570,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
@@ -13603,7 +13614,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);
@@ -14041,6 +14057,8 @@ function isTimeoutClassError(error) {
 }
 async function compressOneChunk(args, chunk, sliceMs, signal) {
   let agentSessionId = null;
+  let handle = null;
+  const executor = args.hiddenCompletionExecutor ?? createV1HiddenCompletionExecutor(args.client, args.db, args.sessionDirectory);
   let promptSettled = false;
   const startedAt = Date.now();
   try {
@@ -14048,19 +14066,22 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
       projectPath: args.projectIdentity,
       memories: chunk.map(toPromptMemory)
     });
-    const createResponse = await createChildSessionWithFence({
-      client: args.client,
-      db: args.db,
+    handle = await executor.open({
       parentSessionId: args.parentSessionId,
+      agent: DREAMER_CLASSIFIER_AGENT,
+      kind: "dreamer-task",
+      system: COMPRESS_CUES_SYSTEM_PROMPT,
+      model: args.model,
+      configuredModels: [...args.model ? [args.model] : [], ...args.fallbackModels ?? []],
+      timeoutMs: sliceMs,
       title: "magic-context-dream-compress-cues",
-      directory: args.sessionDirectory
+      directory: args.sessionDirectory,
+      metadata: { task: "compress-cues" }
     });
-    const created = normalizeSDKResponse(createResponse, null, {
-      preferResponseOnMissingData: true
-    });
-    agentSessionId = typeof created?.id === "string" ? created.id : null;
+    agentSessionId = handle.id || null;
     if (!agentSessionId)
       throw new Error("Could not create compress-cues session.");
+    const opened = handle;
     const run = await promptSyncWithValidatedOutputRetry(args.client, {
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory },
@@ -14071,24 +14092,18 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
     }, {
+      transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
       timeoutMs: sliceMs,
       signal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:compress-cues",
-      fetchOutput: async () => {
-        const messagesResponse = await args.client.session.messages({
-          path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory, limit: 50 }
-        });
-        return normalizeSDKResponse(messagesResponse, [], {
-          preferResponseOnMissingData: true
-        });
-      },
-      validateOutput: (messages) => {
-        if (hasLengthCappedOutput(messages)) {
+      fetchOutput: () => executor.collect(opened, 50),
+      validateOutput: (completion) => {
+        const messages = completion.messages ?? [];
+        if (completion.lengthCapped) {
           throw new Error("compress-cues returned length-capped output");
         }
-        const text = extractLatestAssistantText(messages);
+        const text = completion.text;
         if (!text)
           throw new Error("compress-cues returned no output");
         try {
@@ -14103,11 +14118,25 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
       }
     });
     promptSettled = true;
+    if (args.hiddenCompletionExecutor && args.parentSessionId) {
+      recordChildInvocation({
+        db: args.db,
+        parentSessionId: args.parentSessionId,
+        harness: executor.capabilities.harness,
+        subagent: "dreamer",
+        task: "compress-cues",
+        startedAt,
+        status: "completed",
+        tokens: run.output.usage,
+        providerId: run.output.providerId,
+        modelId: run.output.modelId
+      });
+    }
     return args.moduleRoute ? await applyCuesThroughModule(args, chunk, run.validated, signal) : applyCues(args, chunk, run.validated);
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] compress-cues chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
-    if (signal.aborted || error instanceof DreamerProviderOutputFailureError)
+    if (signal.aborted || error instanceof HiddenCompletionRefusal || error instanceof DreamerProviderOutputFailureError)
       throw error;
     return {
       compressed: 0,
@@ -14119,10 +14148,7 @@ async function compressOneChunk(args, chunk, sliceMs, signal) {
       }
     };
   } finally {
-    await teardownChildSession({
-      client: args.client,
-      sessionId: agentSessionId,
-      sessionDirectory: args.sessionDirectory,
+    await executor.close(handle, {
       promptSettled,
       privacySensitive: true,
       context: "[dreamer] compress-cues",
@@ -14777,6 +14803,8 @@ async function runClassify(args) {
 }
 async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
   let agentSessionId = null;
+  let handle = null;
+  const executor = args.hiddenCompletionExecutor ?? createV1HiddenCompletionExecutor(args.client, args.db, args.sessionDirectory);
   let promptSettled = false;
   const startedAt = Date.now();
   const moduleRoute = isModuleRoute(args);
@@ -14791,19 +14819,22 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       recordInvocation(args, startedAt, { status: "completed" });
       return run;
     }
-    const createResponse = await createChildSessionWithFence({
-      client: args.client,
-      db: args.db,
+    handle = await executor.open({
       parentSessionId: args.parentSessionId,
+      agent: DREAMER_CLASSIFIER_AGENT,
+      kind: "dreamer-task",
+      system: withContentLanguageDirective(CLASSIFY_SYSTEM_PROMPT, args.language),
+      model: args.model,
+      configuredModels: [...args.model ? [args.model] : [], ...args.fallbackModels ?? []],
+      timeoutMs: sliceMs,
       title: "magic-context-dream-classify",
-      directory: args.sessionDirectory
+      directory: args.sessionDirectory,
+      metadata: { task: "classify-memories" }
     });
-    const created = normalizeSDKResponse(createResponse, null, {
-      preferResponseOnMissingData: true
-    });
-    agentSessionId = typeof created?.id === "string" ? created.id : null;
+    agentSessionId = handle.id || null;
     if (!agentSessionId)
       throw new Error("Could not create classify session.");
+    const opened = handle;
     const run = await promptSyncWithValidatedOutputRetry(args.client, {
       path: { id: agentSessionId },
       query: { directory: args.sessionDirectory },
@@ -14814,24 +14845,18 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
         parts: [{ type: "text", text: prompt, synthetic: true }]
       }
     }, {
+      transport: Object.assign((request) => executor.attempt(opened, request), { childSessionId: opened.childSessionId }),
       timeoutMs: sliceMs,
       signal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:classify-memories",
-      fetchOutput: async () => {
-        const messagesResponse = await args.client.session.messages({
-          path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory, limit: 50 }
-        });
-        return normalizeSDKResponse(messagesResponse, [], {
-          preferResponseOnMissingData: true
-        });
-      },
-      validateOutput: (messages) => {
-        if (hasLengthCappedOutput(messages)) {
+      fetchOutput: () => executor.collect(opened, 50),
+      validateOutput: (completion) => {
+        const messages = completion.messages ?? [];
+        if (completion.lengthCapped) {
           throw new Error("classify returned length-capped output");
         }
-        const text = extractLatestAssistantText(messages);
+        const text = completion.text;
         if (!text)
           throw new Error("classify returned no output");
         try {
@@ -14846,21 +14871,22 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
       }
     });
     promptSettled = true;
-    recordInvocation(args, startedAt, { status: "completed", messages: run.output });
+    recordInvocation(args, startedAt, {
+      status: "completed",
+      messages: run.output.messages,
+      completion: run.output
+    });
     return applyClassifications(args, chunk.map((candidate) => candidate.contextMemory), run.validated);
   } catch (error) {
     const failure = moduleRoute ? new ClassifyModuleFailureError("module", error) : error;
     const desc = describeError(failure);
     log(`[dreamer] classify chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation(args, startedAt, { status: "failed", error: failure });
-    if (moduleRoute || signal.aborted || failure instanceof DreamerProviderOutputFailureError || getPromptFailureDetail(failure)?.failureClass !== "parse_failed" && getPromptFailureDetail(failure) !== null)
+    if (moduleRoute || failure instanceof HiddenCompletionRefusal || signal.aborted || failure instanceof DreamerProviderOutputFailureError || getPromptFailureDetail(failure)?.failureClass !== "parse_failed" && getPromptFailureDetail(failure) !== null)
       throw failure;
     return { classified: 0, changed: 0 };
   } finally {
-    await teardownChildSession({
-      client: args.client,
-      sessionId: agentSessionId,
-      sessionDirectory: args.sessionDirectory,
+    await executor.close(handle, {
       promptSettled,
       privacySensitive: true,
       context: "[dreamer] classify",
@@ -15014,16 +15040,119 @@ function recordInvocation(args, startedAt, params) {
   recordChildInvocation({
     db: args.db,
     parentSessionId: args.parentSessionId,
-    harness: "opencode",
+    harness: args.hiddenCompletionExecutor?.capabilities.harness ?? "opencode",
     subagent: "dreamer",
     task: "classify-memories",
     startedAt,
     status: params.status,
     messages: params.messages,
+    ...params.completion && !params.completion.messages ? {
+      tokens: params.completion.usage,
+      providerId: params.completion.providerId,
+      modelId: params.completion.modelId
+    } : {},
     error: params.error
   });
 }
 
+// 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;
@@ -18316,12 +18445,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) {
@@ -18432,8 +18562,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);
@@ -19156,7 +19291,7 @@ function dreamRunFailureDetail(error) {
   }
   const described = describeError(error);
   const message = described.brief;
-  const providerFailure = error instanceof Error && error.name === "DreamerProviderOutputFailureError";
+  const providerFailure = error instanceof HiddenCompletionRefusal || error instanceof Error && error.name === "DreamerProviderOutputFailureError";
   return {
     failure_class: providerFailure ? "provider_error" : /no models?|model chain is empty/i.test(message) ? "no_models" : "unknown",
     model_attempted: null,
@@ -19246,13 +19381,20 @@ function formatCurateMemoryOperations(actions) {
   const noun = actions.length === 1 ? "operation" : "operations";
   return `curate: ${actions.length} memory ${noun} applied${actionDetail ? ` (${actionDetail})` : ""}`;
 }
+function requireDreamClient(client) {
+  if (!client)
+    throw new HiddenCompletionRefusal("hidden_tools_unsupported", "This dream task requires the child-session tool transport", true);
+  return client;
+}
 function createDreamTaskExecutor(deps) {
   let parentSessionIdPromise;
   const resolveParentSessionId = () => {
+    if (deps.hiddenCompletionExecutor)
+      return Promise.resolve(deps.parentSessionId);
     if (!parentSessionIdPromise) {
       parentSessionIdPromise = (async () => {
         try {
-          const listResponse = await deps.client.session.list({
+          const listResponse = await requireDreamClient(deps.client).session.list({
             query: { directory: deps.sessionDirectory }
           });
           const sessions = normalizeSDKResponse(listResponse, [], { preferResponseOnMissingData: true });
@@ -19278,6 +19420,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) }
       });
     };
@@ -19330,7 +19473,8 @@ function createDreamTaskExecutor(deps) {
                   totalAtStart: backlogAtStart.total,
                   pendingAtEnd: end.pending,
                   totalAtEnd: end.total,
-                  processed
+                  processed,
+                  ...backlogAtStart.category ? { category: backlogAtStart.category } : {}
                 };
                 return value;
               })()
@@ -19366,6 +19510,9 @@ function createDreamTaskExecutor(deps) {
       return writtenIds.length || deletedIds.length || archivedIds.length || mergedIds.length ? changes : null;
     }
     try {
+      if (deps.hiddenCompletionExecutor?.capabilities.tools === false && DREAM_TASK_CAPABILITIES[config.task].requiresTools) {
+        throw new HiddenCompletionRefusal("hidden_tools_unsupported", `${config.task} requires tools; opencode2 hidden completions have no tool loop`, true);
+      }
       if (config.task === "compress-cues") {
         if (deps.mural?.enabled !== true) {
           log("[dreamer] compress-cues: skipped (mural is not enabled)");
@@ -19375,6 +19522,7 @@ function createDreamTaskExecutor(deps) {
         const result = await runCompressCues({
           db,
           client: deps.client,
+          hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19399,7 +19547,7 @@ function createDreamTaskExecutor(deps) {
       if (config.task === "review-user-memories") {
         const result = await reviewUserMemories({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
           holderId,
@@ -19418,7 +19566,7 @@ function createDreamTaskExecutor(deps) {
       if (config.task === "map-memories") {
         const result = await mapMemories({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19455,7 +19603,7 @@ function createDreamTaskExecutor(deps) {
         const memoryBefore = getMemoryCountsByStatus(db, projectIdentity);
         const result = await runVerify({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19513,6 +19661,7 @@ function createDreamTaskExecutor(deps) {
         const result = await runClassify({
           db,
           client: deps.client,
+          hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19538,7 +19687,7 @@ function createDreamTaskExecutor(deps) {
       if (config.task === "promote-primers") {
         const result = await promotePrimers({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           projectIdentity,
           sessionDirectory: deps.sessionDirectory,
           holderId,
@@ -19555,7 +19704,7 @@ function createDreamTaskExecutor(deps) {
       if (config.task === "refresh-primers") {
         const result = await refreshPrimers({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19576,7 +19725,7 @@ function createDreamTaskExecutor(deps) {
       if (config.task === "evaluate-smart-notes") {
         const result = await evaluateSmartNotes({
           db,
-          client: deps.client,
+          client: requireDreamClient(deps.client),
           projectIdentity,
           parentSessionId: parent,
           sessionDirectory: deps.sessionDirectory,
@@ -19743,7 +19892,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   let promptSettled = false;
   try {
     const createResponse = await createChildSessionWithFence({
-      client: deps.client,
+      client: requireDreamClient(deps.client),
       db,
       parentSessionId: parent ?? undefined,
       title: "magic-context-dream-retrospective",
@@ -19757,7 +19906,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
     const runChildTurn = async (system, userText) => {
       const remainingMs = Math.max(0, deadline - Date.now());
       promptSettled = false;
-      const run = await promptSyncWithValidatedOutputRetry(deps.client, {
+      const run = await promptSyncWithValidatedOutputRetry(requireDreamClient(deps.client), {
         path: { id: sessionId },
         query: { directory: deps.sessionDirectory },
         body: {
@@ -19772,7 +19921,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
         fallbackModels: config.fallbackModels,
         callContext: "dreamer:retrospective",
         fetchOutput: async () => {
-          const messagesResponse = await deps.client.session.messages({
+          const messagesResponse = await requireDreamClient(deps.client).session.messages({
             path: { id: sessionId },
             query: { directory: deps.sessionDirectory, limit: 50 }
           });
@@ -19897,7 +20046,7 @@ async function runRetrospectiveTask(config, ctx, helpers) {
   } finally {
     heartbeat.stop();
     await teardownChildSession({
-      client: deps.client,
+      client: requireDreamClient(deps.client),
       sessionId: childSessionId,
       sessionDirectory: deps.sessionDirectory,
       promptSettled,
@@ -19931,6 +20080,7 @@ async function runAgenticTask(config, ctx, helpers) {
   let expiredArchived = 0;
   try {
     let curateMemories;
+    let curateCategory;
     if (task === "curate") {
       expiredArchived = await archiveExpiredMemories({
         db,
@@ -19942,10 +20092,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
@@ -19957,10 +20109,10 @@ 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: deps.client,
+      client: requireDreamClient(deps.client),
       db,
       parentSessionId: parent ?? undefined,
       title: `magic-context-dream-${task}`,
@@ -19974,7 +20126,7 @@ async function runAgenticTask(config, ctx, helpers) {
       throw new Error("Dreamer could not create its child session.");
     const sessionId = childSessionId;
     const remainingMs = Math.max(0, deadline - Date.now());
-    const run = await promptSyncWithValidatedOutputRetry(deps.client, {
+    const run = await promptSyncWithValidatedOutputRetry(requireDreamClient(deps.client), {
       path: { id: sessionId },
       query: { directory: docsDir },
       body: {
@@ -19989,7 +20141,7 @@ async function runAgenticTask(config, ctx, helpers) {
       fallbackModels: config.fallbackModels,
       callContext: `dreamer:${task}`,
       fetchOutput: async () => {
-        const messagesResponse = await deps.client.session.messages({
+        const messagesResponse = await requireDreamClient(deps.client).session.messages({
           path: { id: sessionId },
           query: {
             directory: docsDir,
@@ -20049,22 +20201,40 @@ 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)
       takeCurateSafetyRefusalCount(childSessionId);
     await teardownChildSession({
-      client: deps.client,
+      client: requireDreamClient(deps.client),
       sessionId: childSessionId,
       sessionDirectory: docsDir,
       promptSettled,
@@ -20133,6 +20303,7 @@ function advanceAfterRun(db, projectIdentity, due, finishedAt, status, error, sc
     lastStatus: status,
     lastError: error,
     retryCount: 0,
+    taskStateJson: schedulePatch?.taskStateJson,
     retrospectiveWatermarkMs: schedulePatch?.retrospectiveWatermarkMs
   });
 }
@@ -20225,7 +20396,7 @@ 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);
+        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);
@@ -20292,6 +20463,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) ?? [];
@@ -20301,10 +20473,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);
@@ -20313,7 +20487,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) {
@@ -24972,6 +25149,10 @@ function statusSummaryFromDetail(detail) {
   if ((detail.loggerDiagnostics?.swallowedWriteCount ?? 0) > 0) {
     warnings.push("status_log_unavailable");
   }
+  if (detail.memoryMirror?.stalled)
+    warnings.push("memory_mirror_stalled");
+  if (detail.memoryAuthorityMismatch)
+    warnings.push("memory_authority_mismatch");
   return {
     inputTokens: detail.inputTokens,
     usableContextTokens: detail.contextLimit,
@@ -25108,6 +25289,9 @@ function formatStatusDiagnosticsMarkdown(detail) {
     `- **${formatCacheTtlDisplay({ value: detail.cacheTtl, source: detail.cacheTtlSource ?? "session", modelKey: detail.cacheTtlModelKey })}**; ${formatCacheLane(detail)}`,
     `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,
     ...detail.hostBackendsModuleSide ? [`- ${RUST_MODE_HOST_PATHS_LINE}`] : [],
+    ...detail.memoryMirror ? [
+      `- **Memory mirror:** cursor ${formatCount2(detail.memoryMirror.cursor)} / ${detail.memoryMirror.feedHead === null ? "unknown" : formatCount2(detail.memoryMirror.feedHead)}; ${formatCount2(detail.memoryMirror.liveRows)} live rows; ${detail.memoryMirror.stalled ? `stalled (${detail.memoryMirror.code})` : "advancing or caught up"}`
+    ] : [],
     `- **Memory:** ${formatCount2(detail.memoryCount)} active; ${formatCount2(detail.memoryBlockCount)} injected`,
     `- **Tags:** ${formatCount2(detail.activeTags)} active, ${formatCount2(detail.droppedTags)} dropped; ${formatCount2(detail.pendingOpsCount)} pending drops`,
     `- **Execute threshold:** ${detail.executeThreshold.toFixed(1)}%${detail.executeThresholdClamped ? " (clamped)" : ""}`
@@ -25118,6 +25302,12 @@ function formatStatusDiagnosticsMarkdown(detail) {
   if (detail.lastTransformError) {
     lines.push(`- **Warning:** ${renderUserFacingFailure("transform_update_failed")}`);
   }
+  if (detail.memoryMirror?.stalled) {
+    lines.push(`- **Warning:** ${renderUserFacingFailure("memory_mirror_stalled")}`);
+  }
+  if (detail.memoryAuthorityMismatch) {
+    lines.push(`- **Warning:** ${renderUserFacingFailure("memory_authority_mismatch")}`);
+  }
   return lines.join(`
 `);
 }
@@ -29005,9 +29195,16 @@ function buildSidebarSnapshotRpcResponse(db, sessionId, directory, liveSessionSt
 }
 function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessionState, injectionBudgetTokens, moduleStatus, compactionEnabled = true) {
   const base = buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens, config, moduleStatus, compactionEnabled);
+  const rustMode = config?.transform_mode === "rust";
+  const projectIdentity = rustMode ? resolveProjectIdentity(directory) : null;
+  const moduleMemoryAuthority = moduleStatus?.authority?.memories;
+  const moduleMemoryState = moduleMemoryAuthority?.state;
+  const moduleFeedHead = moduleStatus?.memory_mirror?.feed_head;
   const detail = {
     ...base,
-    hostBackendsModuleSide: config?.transform_mode === "rust",
+    hostBackendsModuleSide: rustMode,
+    memoryMirror: rustMode ? getMemoryMirrorStatus(db, moduleFeedHead) : undefined,
+    memoryAuthorityMismatch: rustMode && moduleStatus?.authority !== undefined && projectIdentity !== null && getAuthorityManagedMarker(db, projectIdentity) !== null && (moduleMemoryState === "TS" || moduleMemoryAuthority === null),
     activeProfile: typeof config?.profile === "string" ? config.profile : null,
     tagCounter: 0,
     activeTags: 0,
@@ -29461,9 +29658,9 @@ function registerRpcHandlers(rpcServer, args) {
     return { count: buildCompartmentCount(db, sessionId, moduleStatus) };
   });
   const buildManagedCtx = async (db) => {
-    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-s2pgnnm4.js");
+    const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-v1fkhjjr.js");
     const { resolveHistorianModel } = await import("./model-resolution-dxatzjde.js");
-    const { userMemoryCollectionEnabled } = await import("./task-config-hnv93r7p.js");
+    const { userMemoryCollectionEnabled } = await import("./task-config-cv8k9y8r.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
     const historianModel = resolveHistorianModel(config, "opencode");
     return {
@@ -29494,8 +29691,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-447vycpt.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-2mzgd3zf.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-k20sfpm2.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-xnypkxpx.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedRecomp(ctx, sessionId).then((message) => {
@@ -29513,8 +29710,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade } = await import("./recomp-orchestrator-447vycpt.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-2mzgd3zf.js");
+    const { runManagedUpgrade } = await import("./recomp-orchestrator-k20sfpm2.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-xnypkxpx.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
     runManagedUpgrade(ctx, sessionId).then((message) => {
@@ -29530,7 +29727,7 @@ function registerRpcHandlers(rpcServer, args) {
     if (!db)
       return { ok: false, error: "db unavailable" };
     try {
-      const { updateSessionMeta } = await import("./storage-meta-session-fkmfhswa.js");
+      const { updateSessionMeta } = await import("./storage-meta-session-x3j0q9qy.js");
       updateSessionMeta(db, sessionId, { upgradeRemindedAt: Date.now() });
       return { ok: true };
     } catch (error) {
@@ -30179,7 +30376,8 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
     compressedToLite: 0,
     compressedToFull: 0,
     compressedToUltra: 0,
-    mutatedTextTags: 0
+    mutatedTextTags: 0,
+    textReductions: []
   };
   if (!config.enabled)
     return result;
@@ -30219,9 +30417,15 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config) {
       const target = targets.get(tag.tagNumber);
       if (!target)
         continue;
+      const priorContent = target.getContent?.();
       const didMutate = target.setContent(compressed);
-      if (didMutate)
+      if (didMutate) {
         result.mutatedTextTags += 1;
+        result.textReductions.push({
+          tagNumber: tag.tagNumber,
+          removedCharacters: Math.max(0, (priorContent?.length ?? originalText.length) - compressed.length)
+        });
+      }
       updateCavemanDepth(db, sessionId, tag.tagNumber, targetDepth);
       if (targetDepth === DEPTH_LITE)
         result.compressedToLite += 1;
@@ -32018,6 +32222,73 @@ function dropStaleReduceCalls(messages, frozenIds, options = {}) {
   return { didDrop, newlyStrippedIds };
 }
 
+// src/hooks/magic-context/dropped-token-estimate.ts
+var TAG_QUERY_CHUNK_SIZE = 900;
+var ESTIMATED_CHARACTERS_PER_TOKEN = 3.5;
+function estimateCharacters(characters) {
+  return Math.ceil(Math.max(0, characters) / ESTIMATED_CHARACTERS_PER_TOKEN);
+}
+function persistedCountOrByteEstimate(count, bytes) {
+  return typeof count === "number" && Number.isFinite(count) ? Math.max(0, count) : estimateCharacters(bytes);
+}
+function loadPersistedTagTokenCounts(db, sessionId, tagNumbers) {
+  const countsByTag = new Map;
+  for (let offset = 0;offset < tagNumbers.length; offset += TAG_QUERY_CHUNK_SIZE) {
+    const chunk = tagNumbers.slice(offset, offset + TAG_QUERY_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT tag_number AS tagNumber,
+                        type,
+                        byte_size AS byteSize,
+                        input_byte_size AS inputByteSize,
+                        reasoning_byte_size AS reasoningByteSize,
+                        token_count AS tokenCount,
+                        input_token_count AS inputTokenCount,
+                        reasoning_token_count AS reasoningTokenCount
+                   FROM tags
+                  WHERE session_id = ? AND tag_number IN (${placeholders})`).all(sessionId, ...chunk);
+    for (const row of rows)
+      countsByTag.set(row.tagNumber, row);
+  }
+  return countsByTag;
+}
+function estimateDroppedTokensFromTagReductions(db, sessionId, reductions) {
+  if (reductions.length === 0)
+    return 0;
+  const structuralByTag = new Map;
+  const partialCharactersByTag = new Map;
+  for (const reduction of reductions) {
+    if (reduction.mode === "partial") {
+      partialCharactersByTag.set(reduction.tagNumber, (partialCharactersByTag.get(reduction.tagNumber) ?? 0) + Math.max(0, reduction.removedCharacters));
+      continue;
+    }
+    const prior = structuralByTag.get(reduction.tagNumber);
+    if (!prior || reduction.mode === "full") {
+      structuralByTag.set(reduction.tagNumber, reduction);
+    }
+  }
+  const tagNumbers = [...new Set([...structuralByTag.keys(), ...partialCharactersByTag.keys()])];
+  const countsByTag = loadPersistedTagTokenCounts(db, sessionId, tagNumbers);
+  let total = 0;
+  for (const [tagNumber, reduction] of structuralByTag) {
+    const row = countsByTag.get(tagNumber);
+    if (!row)
+      continue;
+    total += persistedCountOrByteEstimate(row.tokenCount, row.byteSize);
+    if (reduction.mode === "full") {
+      total += persistedCountOrByteEstimate(row.reasoningTokenCount, row.reasoningByteSize);
+      if (row.type === "tool") {
+        total += persistedCountOrByteEstimate(row.inputTokenCount, row.inputByteSize);
+      }
+    }
+  }
+  for (const [tagNumber, removedCharacters] of partialCharactersByTag) {
+    if (structuralByTag.has(tagNumber) || !countsByTag.has(tagNumber))
+      continue;
+    total += estimateCharacters(removedCharacters);
+  }
+  return Math.max(0, Math.round(total));
+}
+
 // src/hooks/magic-context/fold-execution-gate.ts
 function foldExecutesThisPass(foldDue, materialized) {
   return foldDue && materialized;
@@ -32088,6 +32359,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
   let emergencyReclaimedTokens = 0;
   let deduplicatedTools = 0;
   let droppedInjections = 0;
+  const droppedTokenReductions = [];
   if (config.emergency) {
     const emergency = config.emergency;
     const priorInputSample = getEmergencyInputSample(db, sessionId);
@@ -32123,6 +32395,10 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
             updateTagDropMode(db, sessionId, tag.tagNumber, skeleton ? "truncated" : "full");
             droppedTools++;
             emergencyDroppedTools++;
+            droppedTokenReductions.push({
+              tagNumber: tag.tagNumber,
+              mode: result === "removed" ? "full" : "truncated"
+            });
             emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(tag);
           }
         }
@@ -32157,12 +32433,18 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
         const strippedSource = stripTagPrefix(stripped);
         if (strippedSource.trim().length === 0) {
           const dropResult = target.drop?.() ?? "absent";
-          const didReplace = dropResult === "absent" ? target.setContent(`[dropped §${tag.tagNumber}§]`) : false;
+          const replacement = `[dropped §${tag.tagNumber}§]`;
+          const didReplace = dropResult === "absent" ? target.setContent(replacement) : false;
           if (dropResult === "removed" || dropResult === "absent") {
             replaceSourceContent(db, sessionId, tag.tagNumber, "");
             updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
             if (dropResult === "removed" || didReplace) {
               droppedInjections++;
+              droppedTokenReductions.push(dropResult === "removed" ? { tagNumber: tag.tagNumber, mode: "full" } : {
+                tagNumber: tag.tagNumber,
+                mode: "partial",
+                removedCharacters: Math.max(0, content.length - replacement.length)
+              });
             }
           }
         } else {
@@ -32170,6 +32452,11 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           if (didSet) {
             replaceSourceContent(db, sessionId, tag.tagNumber, strippedSource);
             droppedInjections++;
+            droppedTokenReductions.push({
+              tagNumber: tag.tagNumber,
+              mode: "partial",
+              removedCharacters: Math.max(0, content.length - stripped.length)
+            });
           }
         }
       }
@@ -32209,6 +32496,10 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
           if (result === "removed" || result === "truncated") {
             deduplicatedTools++;
+            droppedTokenReductions.push({
+              tagNumber: tag.tagNumber,
+              mode: result === "removed" ? "full" : "truncated"
+            });
           }
         }
       }
@@ -32227,6 +32518,10 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     });
     compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
     mutatedTextTags = cavemanResult.mutatedTextTags;
+    droppedTokenReductions.push(...cavemanResult.textReductions.map((reduction) => ({
+      ...reduction,
+      mode: "partial"
+    })));
   }
   return {
     droppedTools,
@@ -32235,7 +32530,8 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     emergencyDroppedTools,
     emergencyReclaimedTokens,
     compressedTextTags,
-    mutatedTextTags
+    mutatedTextTags,
+    droppedTokenReductions
   };
 }
 function extractToolInfo(part) {
@@ -32475,7 +32771,7 @@ var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
-function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set) {
+function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced) {
   let didMutateMessage = false;
   let admitted = false;
   let startedAt = 0;
@@ -32484,6 +32780,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
       admitted = true;
       startedAt = performance.now();
       const tags = preloadedTags ?? getTagsBySession(db, sessionId);
+      const tagById = new Map(tags.map((tag) => [tag.tagNumber, tag]));
       const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
       const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
       const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
@@ -32516,6 +32813,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
               continue;
             }
             didMutateMessage = true;
+            onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "edit_marker" });
             updateTagDropMode(db, sessionId, pendingOp.tagId, "edit_marker");
             shouldPersistDrop = true;
           } else if (skeletonWindow.has(pendingOp.tagId)) {
@@ -32525,6 +32823,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             }
             if (truncResult === "truncated") {
               didMutateMessage = true;
+              onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "truncated" });
             }
             updateTagDropMode(db, sessionId, pendingOp.tagId, "truncated");
             shouldPersistDrop = true;
@@ -32535,14 +32834,24 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             }
             if (dropResult === "removed") {
               didMutateMessage = true;
+              onTagReduced?.({ tagNumber: pendingOp.tagId, mode: "full" });
             }
             updateTagDropMode(db, sessionId, pendingOp.tagId, "full");
             shouldPersistDrop = true;
           }
         } else if (target) {
-          const changed = target.setContent(buildReplacementContent(pendingOp.tagId));
-          if (changed)
+          const replacement = buildReplacementContent(pendingOp.tagId);
+          const priorContent = target.getContent?.();
+          const changed = target.setContent(replacement);
+          if (changed) {
             didMutateMessage = true;
+            const originalCharacters = typeof priorContent === "string" ? priorContent.length : tagById.get(pendingOp.tagId)?.byteSize ?? replacement.length;
+            onTagReduced?.({
+              tagNumber: pendingOp.tagId,
+              mode: "partial",
+              removedCharacters: Math.max(0, originalCharacters - replacement.length)
+            });
+          }
           shouldPersistDrop = true;
         } else if (!synthetic) {
           shouldPersistDrop = true;
@@ -33530,6 +33839,10 @@ function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
   sessionLog(args.sessionId, "compaction-marker drain: CAS-clear failed but no pending blob remains; another drain already cleared it");
   return "cas-lost-already-cleared";
 }
+var defaultCompactionMarkerStrategy = {
+  applyDeferred: applyDeferredCompactionMarker,
+  reconcile: reconcileMarkerRepresentation
+};
 async function abortSessionFailClosed(client, sessionId) {
   if (typeof client.session?.abort !== "function") {
     throw new Error("OpenCode session.abort is unavailable");
@@ -33753,7 +34066,7 @@ async function runPostTransformPhase(args) {
   let heuristicOrReasoningDidMutate = false;
   let droppedCount = 0;
   let droppedTokens = 0;
-  const tokensBeforeReductions = isCacheBustingPass || shouldApplyPendingOps ? estimateTokens(JSON.stringify(args.messages)) : 0;
+  const droppedTokenReductions = [];
   let emergencyReclaimedTokens = 0;
   let emergency = false;
   let m0M1InjectedThisPass = false;
@@ -33775,7 +34088,7 @@ async function runPostTransformPhase(args) {
       const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : foldExecutedThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into executed m[0] bust, scheduler=${args.schedulerDecision})` : `scheduler_execute (scheduler=${args.schedulerDecision})`;
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${formatPendingOpsDepth()}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       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);
+      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);
@@ -33828,7 +34141,11 @@ async function runPostTransformPhase(args) {
           emergencyDroppedTools: cleanup.emergencyDroppedTools,
           emergencyReclaimedTokens: cleanup.emergencyReclaimedTokens,
           compressedTextTags: cleanup.compressedTextTags + ridingCleanup.compressedTextTags,
-          mutatedTextTags: cleanup.mutatedTextTags + ridingCleanup.mutatedTextTags
+          mutatedTextTags: cleanup.mutatedTextTags + ridingCleanup.mutatedTextTags,
+          droppedTokenReductions: [
+            ...cleanup.droppedTokenReductions,
+            ...ridingCleanup.droppedTokenReductions
+          ]
         };
         routineCleanupApplied = true;
       }
@@ -33840,6 +34157,7 @@ async function runPostTransformPhase(args) {
       droppedCount += cleanup.droppedTools + cleanup.deduplicatedTools + cleanup.droppedInjections + cleanup.mutatedTextTags;
       emergency ||= cleanup.emergencyDroppedTools > 0;
       emergencyReclaimedTokens += cleanup.emergencyReclaimedTokens;
+      droppedTokenReductions.push(...cleanup.droppedTokenReductions);
       const t7 = performance.now();
       const clearedReasoning = routineCleanupApplied && canUseEmptySentinels ? clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge) : 0;
       if (routineCleanupApplied && canUseEmptySentinels) {
@@ -33927,7 +34245,7 @@ async function runPostTransformPhase(args) {
       }
       autoReclaimTargetCount = syntheticPendingOps.length;
       if (syntheticPendingOps.length > 0) {
-        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds);
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTagIds, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
           autoReclaimDidMutateThisPass = true;
@@ -33965,7 +34283,7 @@ async function runPostTransformPhase(args) {
     updateSessionMeta2(args.db, args.sessionId, { lastTransformError: getErrorMessage(error) });
   }
   if (isCacheBustingPass) {
-    droppedTokens = Math.max(0, tokensBeforeReductions - estimateTokens(JSON.stringify(args.messages)));
+    droppedTokens = estimateDroppedTokensFromTagReductions(args.db, args.sessionId, droppedTokenReductions);
   }
   const replaySnapshot = !compactionOff ? loadPostprocessReplaySnapshot(args.db, args.sessionId) : undefined;
   if (canUseEmptySentinels && !compactionOff && replaySnapshot) {
@@ -34131,7 +34449,7 @@ async function runPostTransformPhase(args) {
         suppressV12HistoryDrain = true;
         sessionLog(args.sessionId, `compaction-marker drain: pending ordinal ${pending.ordinal} is newer than consumed boundary ${args.pendingCompartmentInjection?.compartmentEndMessage ?? "<none>"}; preserving deferred history refresh signal`);
       } else {
-        const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
+        const outcome = (args.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy).applyDeferred(args.db, args.sessionId, pending, args.sessionDirectory);
         switch (outcome.kind) {
           case "applied":
           case "already-current":
@@ -34156,7 +34474,7 @@ async function runPostTransformPhase(args) {
     }
   }
   if (!compactionOff) {
-    reconcileMarkerRepresentation(args.messages, persistedCompactionMarkerState, {
+    (args.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy).reconcile(args.messages, persistedCompactionMarkerState, {
       db: args.db,
       sessionId: args.sessionId,
       tagger: args.tagger,
@@ -34848,6 +35166,10 @@ function responseValue(response) {
   throw new Error("module transform returned a non-object response");
 }
 function mirrorProjectionKey(response) {
+  const memoryMirrorHead = response.memory_mirror_head;
+  if (typeof memoryMirrorHead === "number" && Number.isSafeInteger(memoryMirrorHead) && memoryMirrorHead >= 0) {
+    return JSON.stringify(["memory-feed", memoryMirrorHead]);
+  }
   const rowVersion = response.row_version;
   if (typeof rowVersion !== "number" || !Number.isSafeInteger(rowVersion) || rowVersion < 0) {
     return null;
@@ -36940,7 +37262,7 @@ async function runCompartmentPhaseImpl(args) {
       sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
       updateSessionMeta2(args.db, args.sessionId, { compartmentInProgress: false });
       compartmentInProgress = false;
-    } else if (!args.client) {
+    } else if (!args.client && !args.hiddenCompletionExecutor) {
       sessionLog(args.sessionId, "transform: cannot start compartment agent without client");
       updateSessionMeta2(args.db, args.sessionId, { compartmentInProgress: false });
       compartmentInProgress = false;
@@ -36948,6 +37270,8 @@ async function runCompartmentPhaseImpl(args) {
       sessionLog(args.sessionId, "transform: compartmentInProgress flag set, starting agent");
       startCompartmentAgent({
         client: args.client,
+        hiddenCompletionExecutor: args.hiddenCompletionExecutor,
+        compactionMarkerStrategy: args.compactionMarkerStrategy,
         db: args.db,
         sessionId: args.sessionId,
         historianChunkTokens: args.historianChunkTokens,
@@ -36976,10 +37300,12 @@ async function runCompartmentPhaseImpl(args) {
   let awaitedCompartmentRun = false;
   if (historianRunnable && args.canRunCompartments && !args.skipAwaitForThisPass && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE) {
     let activeRun = getActiveCompartmentRun(args.sessionId);
-    if (!activeRun && hasEligibleHistoryForCompartment() && args.client) {
+    if (!activeRun && hasEligibleHistoryForCompartment() && (args.client || args.hiddenCompletionExecutor)) {
       sessionLog(args.sessionId, `transform: 95% reached (${args.contextUsage.percentage.toFixed(1)}%), force-starting compartment agent and blocking`);
       startCompartmentAgent({
         client: args.client,
+        hiddenCompletionExecutor: args.hiddenCompletionExecutor,
+        compactionMarkerStrategy: args.compactionMarkerStrategy,
         db: args.db,
         sessionId: args.sessionId,
         historianChunkTokens: args.historianChunkTokens,
@@ -37214,7 +37540,16 @@ function scheduleTsAuthorityRecovery(args) {
     }
   });
 }
+function resolveTransformHostSeams(deps) {
+  return {
+    hostRawMessages: deps.hostRawMessages ?? readRawSessionMessages,
+    hostProtectedTailBoundary: deps.hostProtectedTailBoundary ?? resolveOpenCodeProtectedTailBoundary,
+    hostModelFallback: deps.hostModelFallback ?? findLastAssistantModelFromOpenCodeDb,
+    hostRefuse: deps.hostRefuse ?? abortSessionFailClosed
+  };
+}
 function createTransform(deps) {
+  const host = resolveTransformHostSeams(deps);
   const loadedSessions = new Set;
   const rustModeTransform = deps.transformMode === "rust" && deps.rustModeModuleClient ? createRustModeTransform(deps, {
     moduleClient: deps.rustModeModuleClient,
@@ -37250,7 +37585,7 @@ function createTransform(deps) {
     logTransformTiming(sessionId, "findSessionId", startTime, `messages=${messages.length}`);
     const db = deps.db;
     if (deps.client !== undefined) {
-      scheduleReconciliation(db, sessionId, readRawSessionMessages);
+      scheduleReconciliation(db, sessionId, host.hostRawMessages);
     }
     const tUserMsg = performance.now();
     const currentTurnId = findLastUserMessageId(messages);
@@ -37353,7 +37688,7 @@ function createTransform(deps) {
     }
     const compartmentDirectory = sessionDirectory;
     const historianRunnable = deps.historianRunnable !== false;
-    const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && deps.client !== undefined && compartmentDirectory.length > 0;
+    const canRunCompartments = fullFeatureMode && !compactionOff && historianRunnable && (deps.client !== undefined || deps.hiddenCompletionExecutor !== undefined) && compartmentDirectory.length > 0;
     const fallbackModelId = deps.getFallbackModelId?.(sessionId);
     const tModelDetect = performance.now();
     const persistedUsageBeforeResets = contextUsagePassSnapshot(sessionMeta).persistedUsage;
@@ -37458,7 +37793,7 @@ function createTransform(deps) {
     }
     let modelForBudget = deps.liveModelBySession?.get(sessionId);
     if (!modelForBudget) {
-      const recovered = findLastAssistantModelFromOpenCodeDb(sessionId);
+      const recovered = host.hostModelFallback(sessionId);
       if (recovered) {
         modelForBudget = recovered;
         deps.liveModelBySession?.set(sessionId, recovered);
@@ -37514,7 +37849,7 @@ function createTransform(deps) {
       if (!canRunCompartments)
         return null;
       if (_boundarySnapshotCache === undefined || emergencyTailScale) {
-        const snapshot = resolveOpenCodeProtectedTailBoundary({
+        const snapshot = host.hostProtectedTailBoundary({
           db,
           sessionId: resolvedSessionId,
           mode: "transform-force",
@@ -37546,7 +37881,7 @@ function createTransform(deps) {
         boundarySnapshot = getRunnableBoundaryForCompartment(scale);
       }
       if (false) {}
-      if (!canRunCompartments || !deps.client || !boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || !boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
         return false;
       }
       if (getActiveCompartmentRun(sessionId)) {
@@ -37555,6 +37890,8 @@ function createTransform(deps) {
       updateSessionMeta2(db, sessionId, { compartmentInProgress: true });
       startCompartmentAgent({
         client: deps.client,
+        hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
+        compactionMarkerStrategy: deps.compactionMarkerStrategy,
         db,
         sessionId,
         historianChunkTokens: deps.getHistorianChunkTokens?.() ?? 20000,
@@ -37761,6 +38098,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const rawGetNotifParams = deps.getNotificationParams;
     const tCompartmentPhase = performance.now();
     const compartmentPhase = await runCompartmentPhase({
+      hiddenCompletionExecutor: deps.hiddenCompletionExecutor,
+      compactionMarkerStrategy: deps.compactionMarkerStrategy,
       canRunCompartments,
       fullFeatureMode,
       compactionOff,
@@ -37871,6 +38210,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const protectedCutoff = protectionWindow.cutoff;
     const tPostProcess = performance.now();
     const postTransformResult = await runPostTransformPhase({
+      compactionMarkerStrategy: deps.compactionMarkerStrategy ?? defaultCompactionMarkerStrategy,
       sessionId,
       db,
       messages,
@@ -37988,7 +38328,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           throw new EmergencyFailClosedError(`Emergency recovery notification was ${notification}`);
         }
         try {
-          await abortSessionFailClosed(deps.client, sessionId);
+          await host.hostRefuse(deps.client, sessionId);
         } catch (error) {
           sessionLog(sessionId, "transform: emergency fail-closed abort failed; refusing to return a sendable prompt:", getErrorMessage(error));
           throw new EmergencyFailClosedError("Emergency recovery abort failed", {
@@ -39785,7 +40125,7 @@ function createMagicContextHook(deps) {
   };
   const rustMemorySyncRequestedSessions = new Set;
   const authorityRecoveryModuleClient = deps.rustModeModuleClient ?? (() => {
-    const transport = new SubcModuleTransport(deps.config.subc?.connection_file);
+    const transport = new SubcModuleTransport(deps.config.subc?.connection_file ?? getDefaultSubcConnectionFile());
     const client = {
       call: (args) => transport.call(args),
       stateSyncCapabilities: (args) => transport.stateSyncCapabilities(args),
@@ -39839,13 +40179,14 @@ function createMagicContextHook(deps) {
   const syncModuleNotes = () => syncModuleDomain("notes");
   const syncModuleMemories = () => syncModuleDomain("memories");
   const rustToolBackends = deps.config.transform_mode === "rust" && rustModeModuleClient ? {
-    authorityState: async ({ projectPath, projectRoot, domain }) => {
+    authorityState: async ({ projectPath, projectRoot, sessionId, domain }) => {
       if (!rustModeModuleClient.authorityStatus)
         return null;
       const result = await rustModeModuleClient.authorityStatus({
         context_store_uuid: ensureContextStoreUuid(db),
         project: projectPath,
         projectRoot,
+        sessionId,
         domain
       });
       return result.authority?.state ?? null;
@@ -39930,7 +40271,8 @@ function createMagicContextHook(deps) {
       content,
       category,
       ids,
-      reason
+      reason,
+      limit
     }) => {
       const response = await rustModeModuleClient.call({
         sessionId,
@@ -39945,6 +40287,7 @@ function createMagicContextHook(deps) {
             category,
             ids,
             reason,
+            limit,
             memory_project: memoryProject
           }
         }
@@ -41070,6 +41413,9 @@ function memoryAuthorityRefusal(args) {
   const isMutation = args.action !== undefined && ["write", "update", "archive", "merge"].includes(args.action);
   return renderCapabilityRefusal(isMutation ? "memory_write" : "memory_access");
 }
+function memoryAuthorityMismatchRefusal() {
+  return renderUserFacingFailure("memory_authority_mismatch");
+}
 function moduleMemoryText(response, args) {
   let value = response;
   if (value !== null && typeof value === "object" && "result" in value) {
@@ -41332,6 +41678,24 @@ 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 scopeRefusal = getCurateCategoryScopeRefusal({
+          scope: activeCurateCategory,
+          action: args.action,
+          requestedCategory: args.category,
+          ids: [
+            ...args.ids ?? [],
+            ...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,
@@ -41339,13 +41703,14 @@ function createCtxMemoryTool(deps) {
       }) : { skip: null, successor: null };
       if (curatePreflight.skip)
         return curatePreflight.skip;
-      if (args.action !== "list") {
+      {
         const marker = getAuthorityManagedMarker(deps.db, projectPath);
         let authorityState = null;
         try {
           authorityState = await deps.rustToolBackends?.authorityState?.({
             projectPath,
             projectRoot: toolContext.directory,
+            sessionId: toolContext.sessionID,
             domain: "memories"
           }) ?? null;
         } catch (error) {
@@ -41382,7 +41747,8 @@ function createCtxMemoryTool(deps) {
               content: moduleArgs.content,
               category: moduleArgs.category,
               ids: moduleArgs.ids,
-              reason: moduleArgs.reason
+              reason: moduleArgs.reason,
+              limit: moduleArgs.action === "list" ? normalizeLimit2(moduleArgs.limit) : undefined
             }), moduleArgs);
             return text ?? memoryAuthorityRefusal(args);
           } catch (error) {
@@ -41393,6 +41759,9 @@ function createCtxMemoryTool(deps) {
             return memoryAuthorityRefusal(args);
           }
         }
+        if (marker && (authorityState === null || authorityState === "TS")) {
+          return memoryAuthorityMismatchRefusal();
+        }
         if (marker || authorityState === "PREPARING" || authorityState === "DRAINING") {
           return memoryAuthorityRefusal(args);
         }
@@ -41461,7 +41830,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") {
@@ -42417,6 +42787,7 @@ function createCtxNoteTool(deps) {
           notesAuthority = await deps.rustToolBackends.authorityState({
             projectPath: projectIdentity,
             projectRoot: toolContext.directory,
+            sessionId,
             domain: "notes"
           });
         } catch (error) {
@@ -43383,6 +43754,1111 @@ function json(body, status = 200) {
   });
 }
 
+// src/v2/fold/markers.ts
+var v2CompactionMarkerStrategy = {
+  setPending: () => {},
+  publish: () => false,
+  applyDeferred: () => ({ kind: "already-current" }),
+  reconcile: () => false
+};
+
+// src/v2/fold/owner.ts
+import { createHash as createHash15 } from "node:crypto";
+var foldDigest = (value) => createHash15("sha256").update(value).digest("hex");
+
+class FoldOwner {
+  storage;
+  pending = new Map;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  async serial(sessionID, operation) {
+    const previous = this.pending.get(sessionID) ?? Promise.resolve();
+    const next = previous.catch(() => {}).then(operation);
+    this.pending.set(sessionID, next);
+    try {
+      return await next;
+    } finally {
+      if (this.pending.get(sessionID) === next)
+        this.pending.delete(sessionID);
+    }
+  }
+  key(sessionID) {
+    return `fold/v1/${sessionID}`;
+  }
+  async read(sessionID) {
+    return await this.storage.get(this.key(sessionID));
+  }
+  async supply(args) {
+    return this.serial(args.sessionID, async () => {
+      const previous = await this.read(args.sessionID);
+      const same = previous && (args.runningCut !== undefined ? previous.cutSeq === args.runningCut : previous.cutSeq === undefined && previous.watermark === args.watermark);
+      if (same)
+        return previous;
+      const submitted = args.materialize();
+      const next = {
+        watermark: args.watermark,
+        cutSeq: args.runningCut,
+        submitted,
+        submittedSha: foldDigest(submitted)
+      };
+      await this.storage.set(this.key(args.sessionID), next);
+      return next;
+    });
+  }
+  async observe(args) {
+    return this.serial(args.sessionID, async () => {
+      let state = await this.read(args.sessionID);
+      const renderedSha = foldDigest(JSON.stringify(args.rendered));
+      if (!state) {
+        args.onHard("boot_recovery");
+        state = {
+          watermark: args.cutSeq,
+          submitted: args.summary,
+          submittedSha: foldDigest(args.summary),
+          reason: "boot_recovery"
+        };
+      }
+      const reason = args.cutSeq < state.watermark ? "host_cut_before_watermark" : state.submittedSha !== foldDigest(args.summary) || state.renderedSha && state.renderedSha !== renderedSha ? "host_rerender" : undefined;
+      if (reason && state.rejectedSha !== renderedSha) {
+        args.onHard(reason);
+        state.reason = reason;
+        state.rejectedSha = renderedSha;
+      }
+      if (state.cutSeq === undefined && args.cutSeq >= state.watermark)
+        state.cutSeq = args.cutSeq;
+      if (!state.rendered && reason !== "host_cut_before_watermark") {
+        state.rendered = structuredClone(args.rendered);
+        state.renderedSha = renderedSha;
+        state.renderedSummary = args.summary;
+      }
+      await this.storage.set(this.key(args.sessionID), state);
+      return state;
+    });
+  }
+}
+
+// src/v2/fold/restore.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function attachmentParts(files) {
+  const seen = new Map;
+  return files.flatMap((file) => {
+    if (imageMimes.has(file.mime) && file.source.type === "inline" && file.mention?.text) {
+      const key = JSON.stringify([
+        file.mime,
+        file.name ?? null,
+        file.description ?? null,
+        file.mention.text
+      ]);
+      const payloads = seen.get(key) ?? new Set;
+      if (payloads.has(file.data))
+        return [];
+      payloads.add(file.data);
+      seen.set(key, payloads);
+    }
+    const uri = file.source.type === "uri" ? file.source.uri : undefined;
+    const location = uri?.startsWith("file:") ? fileURLToPath2(uri) : undefined;
+    if (file.mime === "text/plain" || file.mime === "application/x-directory") {
+      const directory = file.mime === "application/x-directory";
+      return [
+        {
+          type: "text",
+          text: `
+
+${[
+            directory ? `Attached directory: ${location ?? file.name ?? uri ?? "directory"}` : `Attached file: ${file.name ?? uri ?? "inline attachment"}`,
+            file.description === undefined ? undefined : `Description: ${file.description}`,
+            directory && !file.data.length ? undefined : "",
+            directory && !file.data.length ? undefined : Buffer.from(file.data, "base64").toString("utf8")
+          ].filter((line) => line !== undefined).join(`
+`)}`,
+          metadata: {
+            attachment: {
+              source: file.source,
+              name: file.name,
+              description: file.description
+            }
+          }
+        }
+      ];
+    }
+    if (!imageMimes.has(file.mime) && file.mime !== "application/pdf")
+      return [];
+    return [
+      ...location ? [{ type: "text", text: `Attached file: ${location}` }] : [],
+      {
+        type: "media",
+        mediaType: file.mime,
+        data: file.data,
+        filename: file.name,
+        metadata: file.description === undefined ? undefined : { description: file.description }
+      }
+    ];
+  });
+}
+function restoreRow(row, model) {
+  const data = row.data;
+  const make = (role, content, metadata = data.metadata) => ({
+    id: row.id,
+    role,
+    content,
+    ...metadata === undefined ? {} : { metadata }
+  });
+  if (row.type === "user") {
+    const skills = data.skills ?? [];
+    const content = [
+      ...skills.flatMap((skill) => skill.text === undefined ? [] : [{ type: "text", text: skill.text }]),
+      ...data.text ? [{ type: "text", text: data.text }] : [],
+      ...attachmentParts(data.files ?? [])
+    ];
+    return content.length ? [
+      make("user", content, {
+        ...data.metadata ?? {},
+        ...data.agents?.length ? { agents: data.agents } : {}
+      })
+    ] : [];
+  }
+  if (["synthetic", "skill", "system"].includes(row.type))
+    return [
+      make(row.type === "system" ? "system" : "user", [
+        { type: "text", text: data.text ?? "" }
+      ])
+    ];
+  if (row.type === "location-switched")
+    return [
+      make("user", [
+        {
+          type: "text",
+          text: `The working directory has been changed to ${data.location.directory}.`
+        }
+      ])
+    ];
+  if (row.type === "shell")
+    return data.metadata?.background === true ? [] : [
+      make("user", [
+        {
+          type: "text",
+          text: `The following shell command was executed by the user:
+
+Command:
+${data.command}
+
+Output:
+${data.output?.output ?? ""}`
+        }
+      ])
+    ];
+  if (row.type !== "assistant")
+    return [];
+  const previousModel = data.model;
+  const sameProvider = previousModel?.providerID === model.providerID;
+  const sameModel = sameProvider && previousModel?.id === model.id;
+  const reuse = sameModel && data.error === undefined;
+  const metadata = (state) => state === undefined ? undefined : { [model.providerID]: state };
+  const content = [];
+  const results = [];
+  for (const part of data.content ?? []) {
+    if (part.type === "text") {
+      if (part.text !== "")
+        content.push({
+          type: "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text !== "" || reuse && part.state !== undefined)
+        content.push({
+          type: reuse || data.error === undefined ? "reasoning" : "text",
+          text: part.text,
+          providerMetadata: reuse ? metadata(part.state) : undefined
+        });
+      continue;
+    }
+    const state = part.state;
+    const completed = state.status === "completed" || state.status === "error";
+    const toolReuse = reuse || sameModel && part.executed === true && completed;
+    let input = state.input;
+    if (state.status === "streaming" && typeof input === "string") {
+      try {
+        input = JSON.parse(input);
+      } catch {}
+    }
+    content.push({
+      type: "tool-call",
+      id: part.id,
+      name: part.name,
+      input,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerState) : undefined
+    });
+    if (!completed)
+      continue;
+    const toolContent = state.content ?? [];
+    const single = toolContent.length === 1 ? toolContent[0] : undefined;
+    const result = {
+      type: "tool-result",
+      id: part.id,
+      name: part.name,
+      providerExecuted: part.executed,
+      providerMetadata: toolReuse ? metadata(part.providerResultState ?? part.providerState) : sameProvider ? metadata(part.providerResultState) : undefined,
+      result: state.status === "error" ? { error: state.error, content: toolContent } : single?.type === "text" ? { type: "text", value: single.text } : { type: "content", value: toolContent },
+      ...state.status === "error" ? { resultType: "error" } : {}
+    };
+    if (part.executed === true)
+      content.push(result);
+    else
+      results.push({ role: "tool", content: [result] });
+  }
+  return [...content.length ? [make("assistant", content)] : [], ...results];
+}
+
+// src/v2/hidden-completion.ts
+function meter(system, prompt, text) {
+  return {
+    input: estimateTokens(system) + estimateTokens(prompt),
+    output: estimateTokens(text),
+    cacheRead: 0,
+    cacheWrite: 0
+  };
+}
+async function createV2HiddenCompletionExecutor(host, currentModel) {
+  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 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);
+    }
+    draft.system = [
+      {
+        type: "text",
+        text: typeof body.system === "string" ? body.system : attempt.run.identity.system
+      }
+    ];
+    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;
+  });
+  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;
+    },
+    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)
+        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);
+      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(`
+`);
+        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;
+        run.completion = {
+          text: result.text,
+          usage,
+          lengthCapped: false,
+          providerId: actual.providerID,
+          modelId: actual.modelID
+        };
+      } finally {
+        if (!request.signal?.aborted)
+          pending.delete(marker);
+      }
+    },
+    async collect(handle) {
+      const completion = runs.get(handle)?.completion;
+      if (!completion)
+        throw new Error("Hidden completion has no settled output");
+      return completion;
+    },
+    async close() {}
+  };
+}
+
+// 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);
+}
+function decode(row) {
+  const data = JSON.parse(row.data);
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error(`Invalid session_message data at seq ${row.seq}`);
+  }
+  if (row.type === "idle" && !["succeeded", "failed", "interrupted"].includes(String(data.outcome))) {
+    throw new Error(`Invalid idle outcome at seq ${row.seq}`);
+  }
+  return { ...row, data };
+}
+
+class V2StoreReader {
+  db;
+  constructor(path) {
+    this.db = new Database(path, { readonly: true, fileMustExist: true });
+  }
+  close() {
+    this.db.close();
+  }
+  page(sessionID, options = {}) {
+    const limit = options.limit ?? 100;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4)
+      throw new Error("Invalid page limit");
+    const after = options.after ?? -1;
+    if (!Number.isSafeInteger(after))
+      throw new Error("Invalid seq cursor");
+    const rows = this.db.prepare(`SELECT id, session_id, type, seq, data FROM session_message
+            WHERE session_id = ? AND seq > ? ${options.type ? "AND type = ?" : ""}
+            ORDER BY seq ASC LIMIT ?`).all(...options.type ? [sessionID, after, options.type, limit] : [sessionID, after, limit]).map(decode);
+    return { rows, cursor: rows.at(-1)?.seq };
+  }
+  latestCompaction(sessionID) {
+    const row = this.db.prepare(`SELECT id, session_id, type, seq, data FROM session_message
+            WHERE session_id = ? AND type = 'compaction' AND json_extract(data, '$.status') = 'completed'
+            ORDER BY seq DESC LIMIT 1`).get(sessionID);
+    return row ? decode(row) : undefined;
+  }
+  idleRows(sessionID, after = -1) {
+    return this.all(sessionID, after, "idle");
+  }
+  window(sessionID) {
+    return this.db.transaction(() => {
+      const cut = this.latestCompaction(sessionID);
+      return this.all(sessionID, cut ? cut.seq - 1 : -1);
+    })();
+  }
+  history(sessionID) {
+    return this.all(sessionID, -1);
+  }
+  all(sessionID, after, type) {
+    const rows = [];
+    for (;; ) {
+      const page = this.page(sessionID, { after, type });
+      rows.push(...page.rows);
+      if (page.rows.length < 100 || page.cursor === undefined)
+        return rows;
+      after = page.cursor;
+    }
+  }
+}
+
+// src/v2/hooks/channel2.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+async function deliverSynthetic(context, sessionID, text) {
+  const id = `msg_${randomBytes2(12).toString("hex")}`;
+  await context.storage.set(`synthetic/${sessionID}/${id}`, { id });
+  await context.session.synthetic({ sessionID, id, text, delivery: "steer" });
+  return id;
+}
+async function isAdmittedSynthetic(context, sessionID, id) {
+  const record = await context.storage.get(`synthetic/${sessionID}/${id}`);
+  return record !== null && typeof record === "object" && "id" in record && record.id === id;
+}
+async function deliverPendingChannel2(context, db, sessionID, baseline) {
+  if (getChannel2NudgeState(db, sessionID) !== "pending")
+    return;
+  const evaluation = evaluateChannel2(baseline);
+  if (!evaluation.evaluable || !evaluation.shouldTrigger)
+    return;
+  const token = randomBytes2(16).toString("hex");
+  if (!claimChannel2NudgeState(db, sessionID, token))
+    return;
+  try {
+    await deliverSynthetic(context, sessionID, buildChannel2Reminder(evaluation.reclaimableTokens, reclaimableToolOutputCount(baseline?.baselineParts ?? [])));
+  } catch (error) {
+    casChannel2NudgeClaim(db, sessionID, "pending", token);
+    throw error;
+  }
+  casChannel2NudgeClaim(db, sessionID, "delivered", token);
+}
+
+// src/v2/hooks/dream-trigger.ts
+function startDreamTrigger(context, args) {
+  const controller = new AbortController;
+  const done = (async () => {
+    try {
+      for await (const value of context.event.subscribe({ signal: controller.signal })) {
+        if (controller.signal.aborted)
+          break;
+        const event = value;
+        if (event.type !== "session.execution.succeeded" || !event.data?.sessionID)
+          continue;
+        const db = openDatabase();
+        if (!db)
+          continue;
+        try {
+          await runDueTasksForProject({
+            db,
+            projectIdentity: args.projectIdentity(),
+            tasks: buildDreamTaskRuntimeConfigs2(args.config, "opencode", args.language, args.mural?.model),
+            executor: createDreamTaskExecutor({
+              hiddenCompletionExecutor: args.executor,
+              parentSessionId: event.data.sessionID,
+              sessionDirectory: context.location.directory,
+              openOpenCodeDb: () => null,
+              language: args.language,
+              mural: args.mural
+            })
+          });
+        } catch (error) {
+          console.warn("[magic-context] v2 dream scheduling failed", error);
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted)
+        console.warn("[magic-context] v2 dream event subscription failed", error);
+    }
+  })();
+  return {
+    async dispose() {
+      controller.abort();
+      await done;
+    }
+  };
+}
+
+// src/v2/hooks/payload.ts
+var HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
+function adaptPayload(draft, admittedIDs = new Set) {
+  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
+  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
+  const results = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-result" && typeof part.id === "string") {
+        const queue = results.get(part.id) ?? [];
+        queue.push({ part, message });
+        results.set(part.id, queue);
+      }
+    }
+  }
+  const paired = new Set;
+  const bridges = new Map;
+  const originals = new Map;
+  const nativeTool = (call, result) => {
+    const value = result?.part.result?.value;
+    const output = typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
+    const part = {
+      type: "tool",
+      callID: call?.id ?? result?.part.id,
+      tool: call?.name ?? result?.part.name,
+      state: {
+        input: structuredClone(call?.input ?? {}),
+        status: result ? "completed" : "running",
+        ...result ? { output } : {}
+      }
+    };
+    bridges.set(part, { call, result: result?.part, resultMessage: result?.message, output });
+    if (result)
+      paired.add(result.part);
+    return part;
+  };
+  const callParts = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-call")
+        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
+    }
+  }
+  const messages = [];
+  for (const message of source) {
+    const parts = [];
+    for (const content of message.content) {
+      if (paired.has(content))
+        continue;
+      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : structuredClone(content));
+      if (message.id && admittedIDs.has(message.id))
+        part.synthetic = true;
+      parts.push(part);
+    }
+    if (!parts.length && message.content.length)
+      continue;
+    const mapped = {
+      info: {
+        id: message.id,
+        sessionID: draft.sessionID,
+        role: message.role,
+        ...{
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agent: draft.agent,
+          tools: draft.tools
+        }
+      },
+      parts
+    };
+    originals.set(mapped, message);
+    messages.push(mapped);
+  }
+  return {
+    messages,
+    commit() {
+      let head = 0;
+      const rendered = [];
+      for (const message of messages) {
+        const original = originals.get(message);
+        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
+        const content = [];
+        const following = [];
+        for (const candidate of message.parts) {
+          const part = candidate;
+          const bridge = bridges.get(part);
+          if (!bridge) {
+            const { synthetic: _synthetic, ...clean } = part;
+            content.push(clean);
+            continue;
+          }
+          const state = part.state;
+          if (bridge.call)
+            content.push({ ...bridge.call, input: state.input });
+          if (bridge.result && bridge.resultMessage) {
+            const result = {
+              ...bridge.result,
+              result: state.output === bridge.output ? bridge.result.result : { type: "text", value: state.output }
+            };
+            if (bridge.resultMessage === original)
+              content.push(result);
+            else
+              following.push({ ...bridge.resultMessage, content: [result] });
+          }
+        }
+        if (content.length || !original?.content.length) {
+          const value = {
+            ...original,
+            id,
+            role: message.info.role ?? "user",
+            content
+          };
+          const existing = id ? existingHeads.get(id) : undefined;
+          rendered.push(existing ? Object.assign(existing, { content }) : value);
+        }
+        rendered.push(...following);
+      }
+      draft.messages.splice(0, draft.messages.length, ...rendered);
+    }
+  };
+}
+
+// src/v2/hooks/refusal.ts
+class V2ContextRefusal extends Error {
+  constructor(message = "Context full — /ctx-flush or /clear to continue.", options) {
+    super(message, options);
+    this.name = "V2ContextRefusal";
+  }
+}
+async function interruptBeforeProvider(session, sessionID) {
+  let timer;
+  try {
+    const result = await Promise.race([
+      session.interrupt({ sessionID }),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("interrupt exceeded 2000 ms")), 2000);
+      })
+    ]);
+    if (result.interrupted !== true)
+      throw new Error("interrupt arrived after the turn became idle");
+  } catch (cause) {
+    throw new V2ContextRefusal(undefined, { cause });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/v2/hooks/store.ts
+var isRawRow = (row) => ["user", "synthetic", "assistant", "skill", "shell", "system"].includes(row.type);
+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),
+    role: row.type === "assistant" ? "assistant" : "user",
+    createdAt: row.data.time?.created,
+    parts: row.type === "assistant" ? (row.data.content ?? []).map((part) => {
+      if (part.type !== "tool")
+        return { ...part };
+      const state = part.state;
+      const content = state.content;
+      return {
+        type: "tool",
+        tool: part.name,
+        callID: part.id,
+        state: {
+          ...state,
+          output: content?.filter((p) => p.type === "text").map((p) => p.text).join(`
+`) ?? ""
+        }
+      };
+    }) : [{ type: "text", text: row.data.text ?? "" }]
+  }));
+}
+
+// src/v2/hooks/context.ts
+function createHostSeams(context, read, liveModels) {
+  return {
+    hostRawMessages: read,
+    hostProtectedTailBoundary: (args) => resolveOpenCodeProtectedTailBoundary({
+      ...args,
+      cacheNamespace: `opencode2:${args.sessionId}`
+    }),
+    hostModelFallback: (sessionID) => liveModels.get(sessionID) ?? null,
+    hostRefuse: (_client, sessionID) => interruptBeforeProvider(context.session, sessionID)
+  };
+}
+async function registerContext(context) {
+  const directory = context.location.directory;
+  const config = loadPluginConfigDetailed(directory).config;
+  if (!config.enabled || !isCompactionEnabled(config))
+    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 dreamTrigger = hiddenCompletionExecutor && config.dreamer && !config.dreamer.disable ? startDreamTrigger(context, {
+    config: config.dreamer,
+    executor: hiddenCompletionExecutor,
+    projectIdentity: () => resolveProjectIdentity(directory) ?? directory,
+    language: config.language,
+    mural: config.mural
+  }) : undefined;
+  const historianModels = resolveHistorianModel2(config, "opencode");
+  const usage = new Map;
+  const channel1 = new Map;
+  const variants = new Map;
+  const agents = new Map;
+  const historyRefreshSessions = new Set;
+  const pendingMaterializationSessions = new Set;
+  const lastHeuristicsTurnId = new Map;
+  const rawProviders = new Map;
+  let passDuties;
+  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")
+      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 output = { output: text };
+      await toolDuties({ ...draft, args: draft.input }, output);
+      if (draft.result && output.output !== text) {
+        if (typeof content === "string")
+          draft.result.content = output.output;
+        else if (Array.isArray(content) && output.output.startsWith(text))
+          content.push({ type: "text", text: output.output.slice(text.length) });
+      }
+      const baseline = channel1.get(draft.sessionID);
+      await deliverPendingChannel2(context, db, draft.sessionID, baseline);
+    } catch (error) {
+      console.warn("[magic-context] v2 Channel 2 delivery deferred", error);
+    }
+  });
+  const read = (sessionID) => {
+    const reader = new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+    try {
+      return rawMessages(reader.history(sessionID));
+    } finally {
+      reader.close();
+    }
+  };
+  const pagedRead = Object.assign(read, {
+    readPage: (sessionID, after, limit, watermark) => read(sessionID).filter((m) => m.ordinal > after && m.ordinal <= watermark).slice(0, limit),
+    getCount: (sessionID) => read(sessionID).length
+  });
+  let transform;
+  let db;
+  const refuseIfUnsafe = async (draft) => {
+    let unsafe = false;
+    try {
+      db ??= openDatabase();
+      if (!db || !isDatabasePersisted(db))
+        throw new Error("context storage is not durable");
+      getOrCreateSessionMeta2(db, draft.sessionID);
+      const reader = new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+      try {
+        const latest = reader.history(draft.sessionID).filter((row) => row.type === "assistant").at(-1);
+        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)
+            limits.set(`${model.providerID}/${model.id}`, model.limit.context);
+          queriedModels.add(modelKey);
+        }
+        const limit = limits.get(modelKey);
+        if (tokens && limit && Number.isFinite(limit) && limit > 0) {
+          const inputTokens = tokens.input + tokens.cache.read + tokens.cache.write;
+          unsafe = inputTokens / limit >= 0.95;
+          const completed = latest?.data.time?.completed;
+          if (typeof completed === "number")
+            updateSessionMeta2(db, draft.sessionID, { lastResponseTime: completed });
+          usage.set(draft.sessionID, {
+            usage: { inputTokens, percentage: inputTokens / limit * 100 },
+            hasUsageTokens: true,
+            updatedAt: Date.now()
+          });
+        }
+      } finally {
+        reader.close();
+      }
+    } catch {
+      unsafe = true;
+    }
+    if (unsafe)
+      await interruptBeforeProvider(context.session, draft.sessionID);
+    return unsafe;
+  };
+  const materialize = (draft) => {
+    db ??= openDatabase();
+    if (!db || !isDatabasePersisted(db))
+      throw new Error("context storage is not durable");
+    const state = getOrCreateSessionMeta2(db, draft.sessionID);
+    return materializeM0({
+      db,
+      sessionId: draft.sessionID,
+      state,
+      projectPath: resolveProjectIdentity(directory) ?? directory,
+      projectDirectory: directory,
+      memoryEnabled: config.memory.enabled,
+      memoryInjectionBudgetTokens: config.memory.injection_budget_tokens,
+      hardSignals: {
+        systemHash: foldDigest(JSON.stringify(draft.system)),
+        toolSetHash: "",
+        modelKey: `${draft.model.providerID}/${draft.model.id}`,
+        cacheExpired: false,
+        lastResponseTime: state.lastResponseTime
+      }
+    }).m0Text;
+  };
+  await context.session.hook("compaction", async (draft) => {
+    const reader = new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+    try {
+      const rows = reader.history(draft.sessionID);
+      const ids = new Set(draft.messages.map((message) => message.id));
+      const watermark = Math.max(-1, ...rows.filter((row) => ids.has(row.id)).map((row) => row.seq));
+      const running = rows.filter((row) => row.type === "compaction" && row.data.status === "running").at(-1);
+      const fold = await folds.supply({
+        sessionID: draft.sessionID,
+        watermark,
+        runningCut: running?.seq,
+        materialize: () => materialize(draft)
+      });
+      draft.result = { summary: fold.submitted };
+    } catch (cause) {
+      await interruptBeforeProvider(context.session, draft.sessionID);
+      throw new V2ContextRefusal("Magic Context could not preserve the host checkpoint.", {
+        cause
+      });
+    } finally {
+      reader.close();
+    }
+  });
+  await context.session.hook("context", async (draft) => {
+    let postFold = false;
+    try {
+      if (await refuseIfUnsafe(draft))
+        return;
+      if (!db)
+        return;
+      const storage = db;
+      updateSessionMeta2(db, draft.sessionID, {
+        systemPromptHash: foldDigest(JSON.stringify(draft.system))
+      });
+      await preloadTokenizer();
+      passDuties ??= createChatMessageHook({
+        db,
+        liveModelBySession: liveModels,
+        variantBySession: variants,
+        agentBySession: agents,
+        historyRefreshSessions,
+        pendingMaterializationSessions,
+        lastHeuristicsTurnId,
+        systemPromptRefreshSessions: new Set,
+        cacheTtlConfig: config.cache_ttl,
+        upgradeReminder: (sessionID) => maybeSendUpgradeReminder({
+          db: storage,
+          client: undefined,
+          getNotificationParams: () => ({}),
+          sendStatusNotification: async (_client, id, text) => {
+            pushNotification2("toast", { message: text, variant: "info" }, id);
+            return "queued";
+          }
+        }, sessionID)
+      });
+      await passDuties({
+        sessionID: draft.sessionID,
+        agent: draft.agent,
+        variant: draft.model.variant,
+        model: { providerID: draft.model.providerID, modelID: draft.model.id }
+      });
+      if (!rawProviders.has(draft.sessionID))
+        rawProviders.set(draft.sessionID, setRawMessageProvider(draft.sessionID, {
+          readMessages: () => read(draft.sessionID)
+        }));
+      transform ??= createTransform({
+        db,
+        tagger: createTagger(),
+        scheduler: createScheduler({
+          executeThresholdPercentage: config.execute_threshold_percentage
+        }),
+        contextUsageMap: usage,
+        protectedTokens: config.protected_tokens,
+        protectedTokenTierOverrides: getProtectedTokensTierOverrides(config),
+        executeThresholdPercentage: config.execute_threshold_percentage,
+        liveModelBySession: liveModels,
+        channel1StateBySession: channel1,
+        historyRefreshSessions,
+        pendingMaterializationSessions,
+        lastHeuristicsTurnId,
+        variantBySession: variants,
+        clearReasoningAge: config.clear_reasoning_age,
+        directory,
+        projectPath: directory,
+        hiddenCompletionExecutor,
+        historianRunnable: hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
+        historianModel: historianModels.primary,
+        fallbackModels: historianModels.fallbacks,
+        historianTimeoutMs: config.historian_timeout_ms,
+        historianMaxOutputTokens: config.historian?.maxTokens,
+        historianTwoPass: config.historian?.two_pass,
+        compactionMarkerStrategy: v2CompactionMarkerStrategy,
+        memoryConfig: {
+          enabled: config.memory.enabled,
+          injectionBudgetTokens: config.memory.injection_budget_tokens,
+          autoPromote: config.memory.auto_promote
+        },
+        ...createHostSeams(context, pagedRead, liveModels)
+      });
+      const admitted = new Set;
+      for (const message of draft.messages) {
+        if (message.id && await isAdmittedSynthetic(context, draft.sessionID, message.id))
+          admitted.add(message.id);
+      }
+      const reader = new V2StoreReader(gaDatabasePath(getDataDir(), process.env.OPENCODE_CHANNEL ?? "latest"));
+      let checkpoint;
+      let submitted;
+      try {
+        const cut = reader.latestCompaction(draft.sessionID);
+        const incoming = cut && draft.messages.find((message) => message.id === cut.id);
+        postFold = cut !== undefined;
+        if (cut && !incoming)
+          throw new Error("The host checkpoint disappeared from the context draft");
+        if (cut && incoming) {
+          const identity = await folds.observe({
+            sessionID: draft.sessionID,
+            cutSeq: cut.seq,
+            summary: cut.data.summary ?? "",
+            rendered: incoming,
+            onHard: (reason) => {
+              console.warn(`[magic-context] HARD reason=${reason} session=${draft.sessionID}`);
+              materialize(draft);
+              pendingMaterializationSessions.add(draft.sessionID);
+            }
+          });
+          checkpoint = structuredClone(identity.rendered ?? incoming);
+          submitted = identity.rendered ? identity.renderedSummary ?? identity.submitted : cut.data.summary ?? "";
+          const all = reader.history(draft.sessionID);
+          const boundaryID = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(draft.sessionID)?.id;
+          const boundary = all.find((row) => row.id === boundaryID)?.seq ?? -1;
+          const present = new Set(draft.messages.map((message) => message.id));
+          const restored = all.filter((row) => row.seq > boundary && row.seq <= cut.seq && !present.has(row.id)).flatMap((row) => restoreRow(row, draft.model));
+          draft.messages.splice(0, draft.messages.length, ...restored, ...draft.messages.filter((message) => message !== incoming));
+        }
+      } finally {
+        reader.close();
+      }
+      const mapped = adaptPayload(draft, admitted);
+      await transform({}, mapped);
+      mapped.commit();
+      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;
+        if (typeof baseline === "string") {
+          for (const part of checkpoint.content)
+            if (part.type === "text" && typeof part.text === "string") {
+              part.text = part.text.replace(`<summary>
+${submitted}
+</summary>`, `<summary>
+${baseline}
+</summary>`);
+            }
+          const volatile = draft.messages.find((message) => message.id === HEAD_IDS[1]);
+          if (volatile && head)
+            volatile.content.push(...head.content.filter((part) => part.type !== "text"));
+          draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
+        }
+      }
+    } catch (error) {
+      if (error instanceof V2ContextRefusal)
+        throw error;
+      if (postFold) {
+        await interruptBeforeProvider(context.session, draft.sessionID);
+        throw new V2ContextRefusal("Magic Context could not restore the unarchived host history.", { cause: error });
+      }
+      console.warn("[magic-context] v2 context unavailable", error);
+    }
+  });
+  return {
+    async dispose() {
+      await dreamTrigger?.dispose();
+      for (const release of rawProviders.values())
+        release();
+      rawProviders.clear();
+    }
+  };
+}
+
+// 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 { 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"));
+      if (pkg.name === "@cortexkit/opencode-magic-context" && typeof pkg.version === "string") {
+        return {
+          version: pkg.version,
+          development: existsSync13(join12(directory, "src/v2/server.ts"))
+        };
+      }
+    } catch {}
+    const parent = dirname8(directory);
+    if (parent === directory)
+      throw new Error("Magic Context package manifest is unavailable");
+    directory = parent;
+  }
+}
+function startUpdateChecks(context, check = (signal) => {
+  return packageInfo().development ? Promise.resolve(null) : getLatestVersion("latest", { signal });
+}) {
+  const controller = new AbortController;
+  const done = (async () => {
+    try {
+      for await (const _event of context.event.subscribe({ signal: controller.signal })) {
+        if (controller.signal.aborted)
+          break;
+        const last = await context.storage.get("version-check-at");
+        if (typeof last === "number" && Date.now() - last < 60 * 60 * 1000)
+          continue;
+        await context.storage.set("version-check-at", Date.now());
+        const latest = await check(controller.signal);
+        const comparison = latest ? compareSemverCore(latest, packageInfo().version) : null;
+        if (!controller.signal.aborted && comparison !== null && comparison > 0) {
+          pushNotification2("toast", {
+            message: `Magic Context ${latest} is available. Update the plugin to install it.`,
+            variant: "info"
+          });
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted)
+        console.warn("[magic-context] v2 update check unavailable", error);
+    }
+  })();
+  return {
+    done,
+    async dispose() {
+      controller.abort();
+      await done;
+    }
+  };
+}
+
+// src/v2/server.ts
+async function setup(context) {
+  setHarness("opencode2");
+  const duties = await registerContext(context);
+  const checks = loadPluginConfigDetailed(context.location.directory).config.auto_update === false ? undefined : startUpdateChecks(context);
+  console.info("[magic-context] @cortexkit/opencode-magic-context v2 setup");
+  return async () => {
+    await checks?.dispose();
+    await duties?.dispose();
+  };
+}
+
 // src/index.ts
 var BOOT_SERVER_DEADLINE_MS = 15000;
 var RESOLVED_CONFIG_TIMEOUT_MS = 2000;
@@ -43435,7 +44911,7 @@ var server = async (ctx) => {
     if (hasBannerEntries)
       setTimeout(async () => {
         try {
-          const { sendStatusNotification } = await import("./send-session-notification-2mzgd3zf.js");
+          const { sendStatusNotification } = await import("./send-session-notification-xnypkxpx.js");
           const clientWithSessions = ctx.client;
           const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
           const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -43452,7 +44928,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-2mzgd3zf.js");
+        const { sendStatusNotification } = await import("./send-session-notification-xnypkxpx.js");
         const clientWithSessions = ctx.client;
         const sessions = await Promise.resolve(clientWithSessions.session?.list?.()).catch(() => null);
         const sessionList = Array.isArray(sessions) ? sessions : sessions?.data;
@@ -43484,9 +44960,9 @@ var server = async (ctx) => {
   }
   conflictMs = performance.now() - conflictStartedAt;
   const liveSessionState = createLiveSessionState();
-  const rustModeModuleTransport = pluginConfig.transform_mode === "rust" ? new SubcModuleTransport(pluginConfig.subc?.connection_file) : undefined;
+  const rustModeModuleTransport = pluginConfig.transform_mode === "rust" ? new SubcModuleTransport(pluginConfig.subc?.connection_file ?? getDefaultSubcConnectionFile()) : undefined;
   const rustModeModuleClient = rustModeModuleTransport;
-  const sessionCleanupModuleClient = pluginConfig.enabled ? rustModeModuleTransport ?? new SubcModuleTransport(pluginConfig.subc?.connection_file) : undefined;
+  const sessionCleanupModuleClient = pluginConfig.enabled ? rustModeModuleTransport ?? new SubcModuleTransport(pluginConfig.subc?.connection_file ?? getDefaultSubcConnectionFile()) : undefined;
   const hooksPhase = await runBootPhaseWithinBudget(bootBudget, "hooks", () => createSessionHooksAsync({
     ctx,
     pluginConfig,
@@ -43698,12 +45174,12 @@ var server = async (ctx) => {
   {
     const fence = getSchemaFenceRejection();
     if (fence) {
-      import("./conflict-warning-hook-aedp084d.js").then(({ sendSchemaFenceWarning }) => sendSchemaFenceWarning(ctx.client, ctx.directory, fence));
+      import("./conflict-warning-hook-jyj54gbe.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-2mzgd3zf.js").then(({ setNotificationServerUrl }) => {
+  import("./send-session-notification-xnypkxpx.js").then(({ setNotificationServerUrl }) => {
     setNotificationServerUrl(serverUrlStr);
   });
   if (conflictResult?.hasConflict) {
@@ -43717,7 +45193,7 @@ var server = async (ctx) => {
   }
   if (pluginConfig.enabled && !conflictResult?.hasConflict) {
     setTimeout(() => {
-      import("./announcement-3c1vertn.js").then(({
+      import("./announcement-8mgn61fw.js").then(({
         shouldShowAnnouncement,
         ANNOUNCEMENT_VERSION,
         ANNOUNCEMENT_FEATURES,
@@ -43726,7 +45202,7 @@ var server = async (ctx) => {
       }) => {
         if (!shouldShowAnnouncement())
           return;
-        return import("./conflict-warning-hook-aedp084d.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
+        return import("./conflict-warning-hook-jyj54gbe.js").then(({ sendStartupAnnouncement }) => sendStartupAnnouncement(ctx.client, ctx.directory, ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, markAnnouncementSeen));
       }).catch(() => {});
     }, 8000);
   }
@@ -43882,7 +45358,8 @@ var server = async (ctx) => {
 };
 var plugin = {
   id: "opencode-magic-context",
-  server
+  server,
+  setup
 };
 var src_default = plugin;
 export {