@cortexkit/pi-magic-context 0.38.0 → 0.39.0

package/dist/index.js

@@ -134,6 +134,7 @@ import {
   getAllStatusTagTokenTotalsFlat,
   getAutoSearchHintDecisions,
   getCachedAbsoluteMessageCount,
+  getChannel1NudgeState,
   getChannel2NudgeClaim,
   getChannel2NudgeState,
   getCompactionModeRecord,
@@ -149,7 +150,6 @@ import {
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getLastIndexedOrdinal,
-  getLastNudgeLevel,
   getLastNudgeUndropped,
   getLatestHistorianInvocationId,
   getLegacyProtectedTailStartOrdinal,
@@ -343,11 +343,11 @@ import {
   saveRecompStagingPass,
   saveSourceContent,
   scheduleAfterBootQuiet,
+  setChannel1NudgeState,
   setChannel2NudgeState,
   setCompactionModeRecord,
   setDeferredExecutePendingIfAbsent,
   setEmergencyDropSample,
-  setLastNudgeLevel,
   setLastNudgeUndropped,
   setMemoryClassification,
   setMuralCue,
@@ -361,6 +361,7 @@ import {
   setSqlitePragmaConfig,
   setStoragePrivatePermissionEnforcement,
   setTodoSnapshot,
+  shouldUseStickyChannel1Reminder,
   sourceNameForMemory,
   stripChannel1ReminderSpans,
   stripMemoryMuralBlock,
@@ -395,7 +396,7 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-6hs6yh6r.js";
+} from "./index-qqgk7jmy.js";
 import {
   pushNotification
 } from "./index-hw34xmzk.js";
@@ -411,55 +412,110 @@ import {
 import {
   __require,
   __toESM
-} from "./index-wckvcay0.js";
+} from "./index-1yh8g550.js";
 
 // src/index.ts
 import { createRequire as createRequire3 } from "node:module";
 import { join as join5, resolve as resolve2 } from "node:path";
 
-// ../plugin/src/shared/resolve-fallbacks.ts
-function resolveFallbackChain(userFallbacks) {
-  const userList = normalizeUserFallbacks(userFallbacks);
-  return dedupe(userList.filter(isValidModelSpec));
+// ../plugin/src/shared/model-resolution.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
-function normalizeUserFallbacks(userFallbacks) {
-  if (!userFallbacks)
-    return [];
-  if (typeof userFallbacks === "string") {
-    const trimmed = userFallbacks.trim();
-    return trimmed ? [trimmed] : [];
+function readString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function hasOwn(record, key) {
+  return Object.hasOwn(record, key);
+}
+function normalizeModelEntry(entry, harness) {
+  if (typeof entry === "string") {
+    const model2 = readString(entry);
+    return model2 ? { model: model2 } : undefined;
   }
-  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+  const objectEntry = asRecord(entry);
+  if (!objectEntry)
+    return;
+  const model = readString(objectEntry.model);
+  if (!model)
+    return;
+  const qualifier = readString(objectEntry[harness === "opencode" ? "variant" : "thinking_level"]);
+  return qualifier ? { model, qualifier } : { model };
 }
-function isValidModelSpec(spec) {
-  const slash = spec.indexOf("/");
-  return slash > 0 && slash < spec.length - 1;
+function isValidModelReference(entry) {
+  const slash = entry.model.indexOf("/");
+  return slash > 0 && slash < entry.model.length - 1;
 }
-function dedupe(list) {
-  const seen = new Set;
-  const out = [];
-  for (const item of list) {
-    if (seen.has(item))
+function sameAttempt(a, b) {
+  return a.model === b.model && a.qualifier === b.qualifier;
+}
+function resolveFallbackEntries(value, harness) {
+  const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+  const resolved = [];
+  for (const value2 of values) {
+    const entry = normalizeModelEntry(value2, harness);
+    if (!entry || !isValidModelReference(entry))
       continue;
-    seen.add(item);
-    out.push(item);
+    if (resolved.some((candidate) => sameAttempt(candidate, entry)))
+      continue;
+    resolved.push(entry);
   }
-  return out;
+  return resolved;
 }
-function parseProviderModel(spec) {
-  const slash = spec.indexOf("/");
-  if (slash < 1 || slash >= spec.length - 1)
-    return null;
+function resolvePrimaryEntry(args) {
+  const entry = normalizeModelEntry(args.entry, args.harness);
+  if (!entry)
+    return;
+  const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
+  return qualifier ? { ...entry, qualifier } : entry;
+}
+function resolveHistorianModel(config, harness) {
+  const historian = asRecord(asRecord(config)?.historian);
+  const block = asRecord(historian?.[harness]);
+  if (!block)
+    return { fallbacks: [] };
   return {
-    providerID: spec.slice(0, slash).trim(),
-    modelID: spec.slice(slash + 1).trim()
+    primary: resolvePrimaryEntry({
+      entry: block.model,
+      defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+      harness
+    }),
+    fallbacks: resolveFallbackEntries(block.fallback_models, harness)
   };
 }
-function modelBodyField(spec) {
-  if (!spec)
-    return {};
-  const parsed = parseProviderModel(spec);
-  return parsed ? { model: parsed } : {};
+function resolveDreamerTaskModel(args) {
+  const dreamer = asRecord(asRecord(args.config)?.dreamer);
+  const harnessBlock = asRecord(dreamer?.[args.harness]);
+  const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
+  const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
+  if (!harnessBlock) {
+    return {
+      fallbacks: [],
+      schedule: readString(schedulingTask?.schedule),
+      timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
+      promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
+    };
+  }
+  const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
+  const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
+  const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+  const usesMuralModel = !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
+  const primarySource = taskHasModel ? taskBlock?.model : usesMuralModel ? args.muralModel : harnessBlock.model;
+  const fallbackSource = taskBlock !== undefined && hasOwn(taskBlock, "fallback_models") ? taskBlock.fallback_models : harnessBlock.fallback_models;
+  return {
+    primary: resolvePrimaryEntry({
+      entry: primarySource,
+      defaultQualifier: usesMuralModel ? harnessQualifier : taskQualifier ?? harnessQualifier,
+      harness: args.harness
+    }),
+    fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+    schedule: readString(schedulingTask?.schedule),
+    timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
+    promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
+  };
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-registry.ts
@@ -528,25 +584,23 @@ function compareTaskOrder(a, b) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-config.ts
-function buildDreamTaskRuntimeConfigs(dreamer, language) {
-  const tasks = dreamer.tasks ?? {};
+function buildDreamTaskRuntimeConfigs(dreamer, harness, language, muralModel) {
   return CANONICAL_DREAM_TASKS.map((task) => {
-    const t = tasks[task] ?? {
-      schedule: "",
-      timeout_minutes: 20
-    };
-    const model = task === "compress-cues" ? t.model : t.model ?? dreamer.model;
-    const fallbackModels = resolveFallbackChain(t.fallback_models ?? dreamer.fallback_models);
-    const thinkingLevel = t.thinking_level ?? dreamer.thinking_level;
+    const resolved = resolveDreamerTaskModel({
+      config: { dreamer },
+      harness,
+      task,
+      muralModel
+    });
     return {
       task,
-      schedule: t.schedule,
-      model,
-      fallbackModels,
-      thinkingLevel,
+      schedule: resolved.schedule ?? "",
+      model: resolved.primary,
+      fallbackModels: resolved.fallbacks,
+      thinkingLevel: harness === "pi" ? resolved.primary?.qualifier : undefined,
       language,
-      timeoutMinutes: t.timeout_minutes ?? 20,
-      promotionThreshold: t.promotion_threshold
+      timeoutMinutes: resolved.timeoutMinutes ?? 20,
+      promotionThreshold: resolved.promotionThreshold
     };
   });
 }
@@ -1951,6 +2005,59 @@ function shouldKeepSubagents() {
   return keepSubagents;
 }
 
+// ../plugin/src/shared/resolve-fallbacks.ts
+function resolveFallbackChain(userFallbacks) {
+  const userList = normalizeUserFallbacks(userFallbacks);
+  return dedupe(userList.filter(isValidModelSpec));
+}
+function normalizeUserFallbacks(userFallbacks) {
+  if (!userFallbacks)
+    return [];
+  if (typeof userFallbacks === "string") {
+    const trimmed = userFallbacks.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function isValidModelSpec(spec) {
+  const slash = spec.indexOf("/");
+  return slash > 0 && slash < spec.length - 1;
+}
+function dedupe(list) {
+  const seen = new Set;
+  const out = [];
+  for (const item of list) {
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function parseProviderModel(spec) {
+  const slash = spec.indexOf("/");
+  if (slash < 1 || slash >= spec.length - 1)
+    return null;
+  return {
+    providerID: spec.slice(0, slash).trim(),
+    modelID: spec.slice(slash + 1).trim()
+  };
+}
+function modelBodyField(spec) {
+  const entry = toModelEntry(spec);
+  if (!entry)
+    return {};
+  const parsed = parseProviderModel(entry.model);
+  return parsed ? { model: parsed, ...entry.qualifier ? { variant: entry.qualifier } : {} } : {};
+}
+function toModelEntry(spec) {
+  if (typeof spec === "string") {
+    const model = spec.trim();
+    return model ? { model } : undefined;
+  }
+  return spec;
+}
+
 // src/clone-inheritance.ts
 import { readFile } from "node:fs/promises";
 var CONTENT_ID_SUFFIX = /:(?:p|file)\d+$/;
@@ -2530,14 +2637,35 @@ class PiSubagentRunner {
     return { result: isolatedResult, extensionRetryUsed: true };
   }
   async runModelChain(options, runMode, primaryModelRef) {
-    const models = [options.model, ...options.fallbackModels ?? []].filter((model) => typeof model === "string" && model.length > 0);
-    const attempts = models.length > 0 ? models : [undefined];
+    const attempts = [];
+    const seenAttempts = new Set;
+    const appendAttempt = (candidate) => {
+      if (!candidate.model)
+        return;
+      const key = `${candidate.model}\x00${candidate.qualifier ?? ""}`;
+      if (seenAttempts.has(key))
+        return;
+      seenAttempts.add(key);
+      attempts.push(candidate);
+    };
+    if (options.model) {
+      appendAttempt({
+        model: options.model,
+        ...options.thinkingLevel ? { qualifier: options.thinkingLevel } : {}
+      });
+    }
+    for (const candidate of options.fallbackModels ?? []) {
+      appendAttempt(typeof candidate === "string" ? { model: candidate } : candidate);
+    }
+    if (attempts.length === 0)
+      attempts.push(undefined);
     let lastResult = null;
     for (let index = 0;index < attempts.length; index += 1) {
-      const model = attempts[index];
+      const attempt = attempts[index];
       const attemptOptions = {
         ...options,
-        model,
+        model: attempt?.model,
+        thinkingLevel: attempt?.qualifier,
         fallbackModels: undefined
       };
       const result = await this.runOnce(attemptOptions, runMode, index === 0 ? primaryModelRef : undefined);
@@ -3748,11 +3876,11 @@ async function trySendTuiToast(sessionId, text, params, forcePersist) {
   const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
   const toastVariant = inferToastVariant(text);
   const duration = params.toastDurationMs ?? 5000;
-  const { isTuiConnected: checkTui } = await import("./rpc-notifications-s2rw51c6.js");
+  const { isTuiConnected: checkTui } = await import("./rpc-notifications-gmhvmfpy.js");
   if (!checkTui(sessionId))
     return false;
   try {
-    const { pushNotification: pushNotification2 } = await import("./rpc-notifications-s2rw51c6.js");
+    const { pushNotification: pushNotification2 } = await import("./rpc-notifications-gmhvmfpy.js");
     pushNotification2("toast", {
       title,
       message,
@@ -3801,7 +3929,7 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
     queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
     return "queued";
   }
-  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-7n7s6xv7.js");
+  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-q00qgjm6.js");
   if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
     sessionLog(sessionId, "notification skipped (session not titled yet)");
     return "skipped";
@@ -3820,7 +3948,7 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
   let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
   if (!agent || !model || !variant) {
     try {
-      const { resolvePromptContext } = await import("./prompt-context-602yq94t.js");
+      const { resolvePromptContext } = await import("./prompt-context-3kjq9ejq.js");
       const resolved = await resolvePromptContext(client, sessionId);
       if (resolved) {
         agent = agent ?? resolved.agent;
@@ -4091,15 +4219,18 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
     log(`[${callContext}] primary (${explicitPrimaryLabel}) failed: ${shortErr(error)}; trying ${fallbacks.length} fallback(s)`);
   }
   for (let i = 0;i < fallbacks.length; i += 1) {
-    const parsed = parseProviderModel(fallbacks[i]);
+    const fallback = toModelEntry(fallbacks[i]);
+    const parsed = fallback ? parseProviderModel(fallback.model) : null;
     if (!parsed) {
-      log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+      log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
       continue;
     }
     const label = `${parsed.providerID}/${parsed.modelID}`;
+    const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
     const attemptArgs = copyPromptArgs(baseArgs, {
-      ...baseBody,
-      model: parsed
+      ...bodyWithoutPrimaryVariant,
+      model: parsed,
+      ...fallback?.qualifier ? { variant: fallback.qualifier } : {}
     });
     try {
       await attemptOnce(client, attemptArgs, timeoutMs, options.signal, callContext, label);
@@ -4115,7 +4246,7 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
       }
     }
   }
-  log(`[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; last error: ${shortErr(lastError)}`);
+  log(`[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; last error: ${shortErr(lastError)}`);
   throw lastError ?? new Error("All fallback models failed");
 }
 async function attemptAndValidate(client, args, timeoutMs, signal, callContext, attempt, options) {
@@ -4153,15 +4284,18 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
     log(`[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(error)}; trying ${fallbacks.length} fallback(s)`);
   }
   for (let i = 0;i < fallbacks.length; i += 1) {
-    const parsed = parseProviderModel(fallbacks[i]);
+    const fallback = toModelEntry(fallbacks[i]);
+    const parsed = fallback ? parseProviderModel(fallback.model) : null;
     if (!parsed) {
-      log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+      log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
       continue;
     }
     const label = `${parsed.providerID}/${parsed.modelID}`;
+    const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
     const attemptArgs = copyPromptArgs(baseArgs, {
-      ...baseBody,
-      model: parsed
+      ...bodyWithoutPrimaryVariant,
+      model: parsed,
+      ...fallback?.qualifier ? { variant: fallback.qualifier } : {}
     });
     const attempt = {
       label,
@@ -4186,7 +4320,7 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
       }
     }
   }
-  log(`[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`);
+  log(`[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`);
   throw firstError ?? lastError ?? new Error("All fallback models failed validation");
 }
 // ../plugin/src/shared/normalize-sdk-response.ts
@@ -6882,22 +7016,67 @@ var asyncModulePromise = null;
 function getAsyncModule() {
   asyncModulePromise ??= (async () => {
     const [{ default: singlefileAsyncifyVariant }, { newQuickJSAsyncWASMModuleFromVariant }] = await Promise.all([
-      import("./index-ayd60xnw.js").then((m)=>__toESM(m.default,1)),
-      import("./index-3pnd4qh9.js")
+      import("./index-rgdqj8nj.js").then((m)=>__toESM(m.default,1)),
+      import("./index-8sseka65.js")
     ]);
     return newQuickJSAsyncWASMModuleFromVariant(singlefileAsyncifyVariant);
   })();
   return asyncModulePromise;
 }
+function acquireSandboxModule(signal) {
+  const modulePromise = getAsyncModule();
+  if (!signal)
+    return modulePromise;
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new Error("smart-note check aborted"));
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason ?? new Error("smart-note check aborted"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    modulePromise.then((module) => {
+      cleanup();
+      resolve(module);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
 var sandboxRunChain = Promise.resolve();
-function withSandboxLock(fn) {
-  const run = sandboxRunChain.then(fn, fn);
+function withSandboxLock(fn, signal, cancelled) {
+  const start = () => signal?.aborted && cancelled ? cancelled() : fn();
+  const run = sandboxRunChain.then(start, start);
   sandboxRunChain = run.then(() => {
     return;
   }, () => {
     return;
   });
-  return run;
+  return resolveBeforeAbort(run, signal, cancelled);
+}
+function resolveBeforeAbort(run, signal, cancelled) {
+  if (!signal || !cancelled)
+    return run;
+  if (signal.aborted)
+    return Promise.resolve(cancelled());
+  return new Promise((resolve, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    const abort = () => {
+      cleanup();
+      resolve(cancelled());
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    run.then((result) => {
+      cleanup();
+      resolve(result);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
 }
 var DEFAULT_TIMEOUT_MS = 2000;
 var DEFAULT_HEAP_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -6924,9 +7103,17 @@ async function runCompiledSmartNoteCheck(options) {
   if (Buffer.byteLength(options.compiledCheck, "utf8") > MAX_COMPILED_CHECK_BYTES) {
     return failureResult("compiled check exceeds 64 KiB", false);
   }
-  return withSandboxLock(() => runCompiledSmartNoteCheckLocked(options));
+  let quickjs;
+  try {
+    quickjs = await acquireSandboxModule(options.signal);
+  } catch (error) {
+    if (options.signal?.aborted)
+      return cancelledResult(options.signal.reason);
+    return failureResult(formatSandboxError(error), false);
+  }
+  return withSandboxLock(() => runCompiledSmartNoteCheckLocked(options, quickjs), options.signal, () => cancelledResult(options.signal?.reason));
 }
-async function runCompiledSmartNoteCheckLocked(options) {
+async function runCompiledSmartNoteCheckLocked(options, quickjs) {
   if (options.signal?.aborted)
     return cancelledResult(options.signal.reason);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -6946,8 +7133,6 @@ async function runCompiledSmartNoteCheckLocked(options) {
     throwIfRunAborted(controller.signal);
     const capabilities = resolveCapabilitiesForRun(options, controller.signal);
     const deadline = Date.now() + timeoutMs;
-    const quickjs = await getAsyncModule();
-    throwIfRunAborted(controller.signal);
     const context = quickjs.newContext();
     try {
       context.runtime.setMemoryLimit(options.heapLimitBytes ?? DEFAULT_HEAP_LIMIT_BYTES);
@@ -7552,7 +7737,7 @@ async function evaluateSmartNotes(args) {
       projectIdentity: args.projectIdentity,
       projectRoot,
       maxChecks: 10,
-      sweepBudgetMs: 1e4,
+      sweepBudgetMs: args.sweepBudgetMs ?? 1e4,
       leaseHeld,
       signal: leaseAbortController.signal,
       retinaHandoff: args.retinaHandoff
@@ -8077,19 +8262,26 @@ function parseMapMemoriesManifest(text) {
   if (out.length === 0 && body.trim().length > 0) {
     throw new Error(describeUnrecognizedManifestShape(text, "mappings", "memory"));
   }
-  assertNoDuplicateManifestIds(out.map((entry) => entry.id), "mappings");
   return out;
 }
 function validateMapMemoriesManifest(text, expectedIds) {
   const parsed = parseMapMemoriesManifest(text);
   assertParsedManifestNonEmpty(parsed.length, expectedIds.size, text, "mappings", "memory");
-  assertManifestCoversExactly(parsed.map((entry) => entry.id), expectedIds, "mappings");
+  assertNoDuplicateManifestIds(parsed.filter((entry) => expectedIds.has(entry.id)).map((entry) => entry.id), "mappings");
   return parsed;
 }
 
 // ../plugin/src/features/magic-context/dreamer/map-memories.ts
 var MAP_BATCH_SIZE = 80;
+var MAP_BATCH_FLOOR_MS = 240000;
+var CONSECUTIVE_TIMEOUT_LIMIT2 = 2;
 var MAX_INDEPENDENT_REQUEUE_PER_RUN = MAP_BATCH_SIZE;
+function computeMapBatchSliceMs(remainingMs, batchesRemaining) {
+  return Math.min(remainingMs, Math.max(MAP_BATCH_FLOOR_MS, Math.floor(remainingMs / batchesRemaining)));
+}
+function isTimeoutClassError2(error) {
+  return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
+}
 function shouldRequeueIndependentMapping(state2, content, repoDir) {
   if (!state2.hasSentinel || state2.files.length > 0)
     return false;
@@ -8137,27 +8329,64 @@ async function mapMemories(args) {
     return result;
   const batches = [];
   for (let i = 0;i < inputs.length; i += MAP_BATCH_SIZE) {
-    batches.push(inputs.slice(i, i + MAP_BATCH_SIZE));
+    batches.push({ inputs: inputs.slice(i, i + MAP_BATCH_SIZE), isOmissionRetry: false });
   }
   result.remaining = inputs.length;
   const abortController = new AbortController;
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => abortController.abort(), args.leaseAcquisition);
   try {
+    let consecutiveTimeouts = 0;
+    let timeoutStreakElapsedMs = [];
     for (let i = 0;i < batches.length; i += 1) {
       const remainingMs = Math.max(0, args.deadline - Date.now());
-      if (remainingMs <= 0)
+      if (remainingMs <= 0) {
+        result.stopReason = "deadline";
         break;
-      const batchesRemaining = batches.length - i;
-      const sliceMs = Math.max(1, Math.floor(remainingMs / batchesRemaining));
-      const counts = await mapOneBatch(args, batches[i], sliceMs, abortController.signal);
-      result.mapped += counts.mapped;
-      result.independent += counts.independent;
-      result.remaining -= counts.mapped + counts.independent;
-      result.batches += 1;
-      args.onProgress?.(result.mapped + result.independent);
+      }
+      if (remainingMs < MAP_BATCH_FLOOR_MS) {
+        result.stopReason = "deadline";
+        log(`[dreamer] map-memories: stopping before batch ${i + 1}/${batches.length} — remaining budget ${remainingMs}ms is below the ${MAP_BATCH_FLOOR_MS}ms batch floor; banking ${result.mapped + result.independent} mapping(s)`);
+        break;
+      }
+      const sliceMs = computeMapBatchSliceMs(remainingMs, batches.length - i);
+      const batch = batches[i];
+      if (!batch)
+        break;
+      const outcome = await mapOneBatch(args, batch.inputs, sliceMs, abortController.signal);
+      const committed = outcome.mapped + outcome.independent;
+      result.mapped += outcome.mapped;
+      result.independent += outcome.independent;
+      result.remaining -= committed;
+      if (committed > 0) {
+        result.batches += 1;
+        args.onProgress?.(result.mapped + result.independent);
+      }
+      if (outcome.requeue?.length) {
+        if (!batch.isOmissionRetry) {
+          batches.splice(i + 1, 0, {
+            inputs: outcome.requeue,
+            isOmissionRetry: true
+          });
+          log(`[dreamer] map-memories: committed ${committed}/${batch.inputs.length} mapping(s); requeueing ${outcome.requeue.length} omitted id(s) in a targeted retry`);
+        } else {
+          log(`[dreamer] map-memories: targeted retry still omitted ${outcome.requeue.length} id(s); leaving them unmapped for the next run`);
+        }
+      }
+      if (outcome.failure?.class === "timeout") {
+        consecutiveTimeouts += 1;
+        timeoutStreakElapsedMs.push(outcome.failure.elapsedMs);
+        if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUT_LIMIT2) {
+          result.stopReason = "timeout-circuit-breaker";
+          log(`[dreamer] map-memories starvation: circuit breaker tripped after ${consecutiveTimeouts} consecutive batch timeouts (model too slow for its time slice); per-batch elapsed [${timeoutStreakElapsedMs.join("ms, ")}ms] vs ${sliceMs}ms slice; stopping with ${result.remaining} mapping(s) remaining`);
+          break;
+        }
+      } else {
+        consecutiveTimeouts = 0;
+        timeoutStreakElapsedMs = [];
+      }
     }
     result.complete = result.remaining === 0;
-    log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
+    log(`[dreamer] map-memories: committed=${result.mapped + result.independent} mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}${result.stopReason ? ` stop_reason=${result.stopReason}` : ""}`);
     return result;
   } finally {
     heartbeat.stop();
@@ -8211,12 +8440,16 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("map-memories returned no output");
-        validateMapMemoriesManifest(text, new Set(batch.map((memory) => memory.id)));
-        return text;
+        return validateMapMemoriesManifest(text, new Set(batch.map((memory) => memory.id)));
       }
     });
     recordInvocation2(args, startedAt, { status: "completed", messages: run.output });
-    return await applyBatchMappings(args, batch, run.validated);
+    const outcome = await applyParsedBatchMappings(args, batch, run.validated);
+    const returnedIds = new Set(run.validated.filter((entry) => batch.some((memory) => memory.id === entry.id)).map((entry) => entry.id));
+    return {
+      ...outcome,
+      requeue: batch.filter((memory) => !returnedIds.has(memory.id))
+    };
   } catch (error) {
     const desc = describeError(error);
     log(`[dreamer] map-memories batch failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
@@ -8225,7 +8458,14 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
       throw error;
     if (signal.aborted)
       throw error;
-    return { mapped: 0, independent: 0 };
+    return {
+      mapped: 0,
+      independent: 0,
+      failure: {
+        class: isTimeoutClassError2(error) ? "timeout" : "other",
+        elapsedMs: Date.now() - startedAt
+      }
+    };
   } finally {
     if (agentSessionId && !shouldKeepSubagents()) {
       await args.client.session.delete({
@@ -8237,14 +8477,21 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
     }
   }
 }
-async function applyBatchMappings(args, batch, manifestText) {
-  const batchIds = new Set(batch.map((m) => m.id));
-  const parsed = parseMapMemoriesManifest(manifestText);
-  assertManifestCoversExactly(parsed.map((entry) => entry.id), batchIds, "mappings");
-  if (parsed.length === 0)
+async function applyParsedBatchMappings(args, batch, parsed) {
+  const batchIds = new Set(batch.map((memory) => memory.id));
+  const valid = parsed.filter((entry) => batchIds.has(entry.id));
+  const unknown = parsed.filter((entry) => !batchIds.has(entry.id));
+  if (unknown.length > 0) {
+    log(`[dreamer] map-memories warning: dropping ${unknown.length} unknown mapping entr${unknown.length === 1 ? "y" : "ies"} outside the current batch (${unknown.map((entry) => entry.id).join(", ")})`);
+  }
+  assertNoDuplicateManifestIds(valid.map((entry) => entry.id), "mappings");
+  if (valid.length * 2 < batch.length) {
+    throw new Error(`mappings manifest covers ${valid.length}/${batch.length} batch ids after filtering unknown entries; rejecting mostly-wrong manifest`);
+  }
+  if (valid.length === 0)
     return { mapped: 0, independent: 0 };
   const planned = [];
-  for (const p of parsed) {
+  for (const p of valid) {
     if (p.independent) {
       planned.push({ id: p.id, files: [], independent: true });
       continue;
@@ -9549,14 +9796,13 @@ function parseVerifyManifest(text) {
   if (verifyIds(out).length === 0 && body.trim().length > 0) {
     throw new Error(describeUnrecognizedManifestShape(text, "verify", "verified"));
   }
-  assertNoDuplicateManifestIds(verifyIds(out), "verify");
   return out;
 }
 function validateVerifyManifest(text, expectedIds) {
   const parsed = parseVerifyManifest(text);
   const ids = verifyIds(parsed);
   assertParsedManifestNonEmpty(ids.length, expectedIds.size, text, "verify", "verified");
-  assertManifestCoversExactly(ids, expectedIds, "verify");
+  assertNoDuplicateManifestIds(ids.filter((id) => expectedIds.has(id)), "verify");
   return parsed;
 }
 
@@ -9709,19 +9955,14 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("verify returned no output");
-        try {
-          validateVerifyManifest(text, new Set(batch.map((memory) => memory.id)));
-        } catch (error) {
-          const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
-          if (providerFailure)
-            throw providerFailure;
-          throw error;
-        }
-        return text;
+        const providerFailure = providerOutputFailureFromInvalidManifest(messages, text);
+        if (providerFailure)
+          throw providerFailure;
+        return validateVerifyManifest(text, new Set(batch.map((memory) => memory.id)));
       }
     });
     recordInvocation4(args, startedAt, { status: "completed", messages: run.output });
-    return await applyVerifyManifest(args, batch, run.validated);
+    return await applyParsedVerifyManifest(args, batch, run.validated);
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
@@ -9741,17 +9982,31 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     }
   }
 }
-async function applyVerifyManifest(args, batch, manifestText) {
+async function applyParsedVerifyManifest(args, batch, parsed) {
   const batchIds = new Set(batch.map((m) => m.id));
-  const parsed = parseVerifyManifest(manifestText);
-  assertManifestCoversExactly([...parsed.verified, ...parsed.updated, ...parsed.archived].map((entry) => entry.id), batchIds, "verify");
+  const valid = {
+    verified: parsed.verified.filter((entry) => batchIds.has(entry.id)),
+    updated: parsed.updated.filter((entry) => batchIds.has(entry.id)),
+    archived: parsed.archived.filter((entry) => batchIds.has(entry.id))
+  };
+  const unknown = [...parsed.verified, ...parsed.updated, ...parsed.archived].filter((entry) => !batchIds.has(entry.id));
+  if (unknown.length > 0) {
+    log(`[dreamer] verify warning: dropping ${unknown.length} unknown verification entr${unknown.length === 1 ? "y" : "ies"} outside the current batch (${unknown.map((entry) => entry.id).join(", ")})`);
+  }
+  const validIds = [...valid.verified, ...valid.updated, ...valid.archived].map((entry) => entry.id);
+  assertNoDuplicateManifestIds(validIds, "verify");
+  if (validIds.length * 2 < batch.length) {
+    throw new Error(`verify manifest covers ${validIds.length}/${batch.length} batch ids after filtering unknown entries; rejecting mostly-wrong manifest`);
+  }
+  if (validIds.length === 0)
+    return { verified: 0, updated: 0, archived: 0 };
   const now = Date.now();
   const writes = [];
-  for (const v of parsed.verified) {
+  for (const v of valid.verified) {
     const files = await normalizeFiles(args, v.files);
     writes.push({ kind: "verify", id: v.id, files });
   }
-  for (const u of parsed.updated) {
+  for (const u of valid.updated) {
     const content = u.content.trim();
     if (!content || content.length > 20000) {
       const files2 = await normalizeFiles(args, u.files);
@@ -9767,7 +10022,7 @@ async function applyVerifyManifest(args, batch, manifestText) {
       hash: computeNormalizedHash(content)
     });
   }
-  for (const a of parsed.archived) {
+  for (const a of valid.archived) {
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
   if (writes.length === 0)
@@ -10074,7 +10329,7 @@ function createDreamTaskExecutor(deps) {
           leaseKey,
           deadline,
           leaseAcquisition,
-          model: config.model ?? deps.mural.model ?? deps.dreamerModel,
+          model: config.model,
           fallbackModels: config.fallbackModels,
           moduleRoute,
           onProgress: (processed) => reportProgress(processed)
@@ -10123,8 +10378,19 @@ function createDreamTaskExecutor(deps) {
           moduleRoute,
           onProgress: (processed) => reportProgress(processed)
         });
-        log(`[dreamer] map-memories: mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining}`);
+        log(`[dreamer] map-memories: committed=${result.mapped + result.independent} mapped=${result.mapped} independent=${result.independent} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}${result.stopReason ? ` stop_reason=${result.stopReason}` : ""}`);
         if (!result.complete) {
+          if (result.stopReason === "timeout-circuit-breaker") {
+            const error2 = `map-memories starvation: timeout circuit breaker stopped the run with ${result.remaining} remain`;
+            recordRun("failed", error2);
+            return { status: "failed", transient: true, error: error2 };
+          }
+          const processed = result.mapped + result.independent;
+          if (processed > 0) {
+            const progress = `map-memories: committed ${processed} mapping(s) (mapped ${result.mapped}, independent ${result.independent}); ${result.remaining} remain`;
+            recordRun("completed", null, { progress });
+            return { status: "completed" };
+          }
           const error = incompleteMessage(result.remaining);
           recordRun("failed", error);
           return { status: "failed", transient: true, error };
@@ -10951,6 +11217,7 @@ async function runDueTasksForProject(deps) {
 import { statSync as statSync2 } from "node:fs";
 
 // ../plugin/src/features/magic-context/dreamer/retrospective-orphan-sweep.ts
+var HISTORIAN_CHILD_TITLE = "magic-context-compartment";
 var RETROSPECTIVE_CHILD_TITLE = "magic-context-dream-retrospective";
 var USER_MEMORIES_CHILD_TITLE = "magic-context-dream-user-memories";
 var CURATE_CHILD_TITLE = "magic-context-dream-curate";
@@ -10976,16 +11243,34 @@ var PRIVACY_SENSITIVE_CHILD_TITLE_MATCHES = {
   ],
   prefixes: [SMART_NOTE_COMPILE_CHILD_TITLE_PREFIX, SMART_NOTE_CONFIRM_CHILD_TITLE_PREFIX]
 };
+var HISTORIAN_CHILD_TITLE_MATCHES = {
+  exact: [HISTORIAN_CHILD_TITLE],
+  prefixes: []
+};
+var INTERNAL_CHILD_TITLE_MATCHES = {
+  exact: [HISTORIAN_CHILD_TITLE, ...PRIVACY_SENSITIVE_CHILD_TITLE_MATCHES.exact],
+  prefixes: PRIVACY_SENSITIVE_CHILD_TITLE_MATCHES.prefixes
+};
 function retrospectiveOrphanStaleMs(taskTimeoutMinutes) {
   const timeoutCandidates = Array.isArray(taskTimeoutMinutes) ? taskTimeoutMinutes : [taskTimeoutMinutes];
   const maxTimeoutMinutes = Math.max(...timeoutCandidates.map((minutes) => Math.max(1, minutes ?? 20)), 20);
   const timeoutMs = maxTimeoutMinutes * 60000;
   return Math.max(60 * 60000, timeoutMs * 3);
 }
+var HISTORIAN_OUTER_ATTEMPTS = 3;
+var HISTORIAN_MODEL_SUGGESTION_ATTEMPTS = 2;
+var HISTORIAN_MAX_RETRY_BACKOFF_MS = 11000;
+var HISTORIAN_DETACHED_WRITER_GRACE_MS = 15 * 60000;
+function historianOrphanStaleMs(timeoutMs, fallbackModelCount) {
+  const timeout = Math.max(60000, timeoutMs);
+  const fallbackCount = Math.max(0, Math.floor(fallbackModelCount));
+  const fullAttemptBudget = timeout * HISTORIAN_OUTER_ATTEMPTS * HISTORIAN_MODEL_SUGGESTION_ATTEMPTS * (fallbackCount + 1);
+  return Math.max(60 * 60000, fullAttemptBudget + HISTORIAN_MAX_RETRY_BACKOFF_MS + HISTORIAN_DETACHED_WRITER_GRACE_MS);
+}
 async function sweepOrphanedRetrospectiveChildren(args) {
   const { opencodeDb, client, sessionDirectory, staleMs } = args;
-  const titleMatches = args.titleMatches ?? PRIVACY_SENSITIVE_CHILD_TITLE_MATCHES;
-  if (!opencodeDb)
+  const titleMatches = args.titleMatches ?? INTERNAL_CHILD_TITLE_MATCHES;
+  if (!opencodeDb || args.keepSubagents === true)
     return 0;
   const now = args.now ?? Date.now();
   const cutoff = now - staleMs;
@@ -11008,7 +11293,7 @@ async function sweepOrphanedRetrospectiveChildren(args) {
                   ORDER BY time_created ASC
                   LIMIT 200`).all(...titleParams, sessionDirectory, cutoff);
   } catch (error) {
-    log(`[dreamer] retrospective orphan sweep: read skipped (${String(error)})`);
+    log(`[magic-context] internal child orphan sweep: read skipped (${String(error)})`);
     return 0;
   }
   if (rows.length === 0)
@@ -11023,7 +11308,7 @@ async function sweepOrphanedRetrospectiveChildren(args) {
     }
   }
   if (deleted > 0) {
-    log(`[dreamer] swept ${deleted} crash-orphaned privacy-sensitive child session(s)`);
+    log(`[magic-context] swept ${deleted} stale internal child session(s)`);
   }
   return deleted;
 }
@@ -11163,7 +11448,7 @@ function scheduleInitialProjectRun(reg, db) {
   startupTimers.set(reg.directory, timer);
 }
 async function runProjectMaintenance(reg, origin, db) {
-  const projectMaintenanceEnabled = Boolean(reg.dreamerConfig && reg.dreamerConfig.disable !== true) || reg.memoryEnabled === true || reg.gitCommitIndexing?.enabled === true;
+  const projectMaintenanceEnabled = Boolean(reg.dreamerConfig && reg.dreamerConfig.disable !== true) || reg.memoryEnabled === true || reg.gitCommitIndexing?.enabled === true || reg.historianChildSweep !== undefined;
   if (!projectMaintenanceEnabled)
     return;
   await reg.ensureRegistered(reg.directory, db);
@@ -11200,6 +11485,7 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
   if (gcDeleted > 0) {
     log(`[magic-context] GC'd ${gcDeleted} stale embedding row(s) for ${reg.projectIdentity} ` + `(memory=${gc.memoryRowsDeleted} commit=${gc.commitRowsDeleted} chunk=${gc.chunkRowsDeleted})`);
   }
+  await sweepOrphanedHistorianChildren(reg);
   const dreamerConfig = reg.dreamerConfig;
   const dreamingEnabled = Boolean(dreamerConfig && dreamerConfig.disable !== true);
   if (commitIndexingEnabled && reg.gitCommitIndexing) {
@@ -11215,7 +11501,7 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
   }
   try {
     await runCompiledSmartNoteSweep(reg, db);
-    const runtimeConfigs = buildDreamTaskRuntimeConfigs(dreamerConfig, reg.language);
+    const runtimeConfigs = buildDreamTaskRuntimeConfigs(dreamerConfig, "opencode", reg.language, reg.mural?.model);
     const executor = createDreamTaskExecutor({
       client: reg.client,
       sessionDirectory: reg.directory,
@@ -11225,7 +11511,6 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(dreamerConfig),
       ensureProjectRegistered: reg.ensureRegistered,
       language: reg.language,
-      dreamerModel: dreamerConfig.model,
       mural: reg.mural,
       memoryInjectionBudgetTokens: reg.memoryInjectionBudgetTokens,
       retinaHandoff: reg.retinaHandoff,
@@ -11263,6 +11548,27 @@ async function sweepProject(reg, origin, db, gitCommitEnabled) {
     log(`[dreamer] timer-triggered task scheduling failed for ${reg.projectIdentity}:`, error);
   }
 }
+async function sweepOrphanedHistorianChildren(reg) {
+  const config = reg.historianChildSweep;
+  if (!config || config.keepSubagents)
+    return;
+  const ocDb = openOpenCodeDb();
+  if (!ocDb)
+    return;
+  try {
+    await sweepOrphanedRetrospectiveChildren({
+      opencodeDb: ocDb,
+      client: reg.client,
+      sessionDirectory: reg.directory,
+      staleMs: historianOrphanStaleMs(config.timeoutMs, config.fallbackModelCount),
+      titleMatches: HISTORIAN_CHILD_TITLE_MATCHES
+    });
+  } catch (error) {
+    log(`[magic-context] historian child orphan sweep failed for ${reg.projectIdentity}:`, error);
+  } finally {
+    closeQuietly(ocDb);
+  }
+}
 async function runCompiledSmartNoteSweep(reg, db) {
   const leaseKey = leaseKeyFor("evaluate-smart-notes", reg.projectIdentity);
   const holderId = crypto.randomUUID();
@@ -11590,11 +11896,13 @@ function registerPiDreamerProject(opts) {
   startDreamScheduleTimerFn({
     directory: opts.projectDir,
     projectIdentity: opts.projectIdentity,
+    harness: "pi",
     client,
     dreamerConfig: opts.config,
     language: opts.language,
     gitCommitIndexing: opts.gitCommitIndexing,
     retinaHandoff: opts.retinaHandoff,
+    mural: opts.mural,
     ensureRegistered: ensureProjectRegisteredFromPiDirectory,
     retrospectiveRawProvider: () => new PiRetrospectiveRawProvider({ projectCwd: opts.projectDir }),
     primerRawProviderFactory: createPiPrimerRawProviderFactory()
@@ -11608,7 +11916,7 @@ function registerPiDreamerProject(opts) {
   const runManual = async (task) => runManualDream({
     db: opts.db,
     projectIdentity: opts.projectIdentity,
-    tasks: buildDreamTaskRuntimeConfigs(opts.config, opts.language),
+    tasks: buildDreamTaskRuntimeConfigs(opts.config, "pi", opts.language, opts.mural?.model),
     executor: createDreamTaskExecutor({
       client,
       sessionDirectory: opts.projectDir,
@@ -11620,7 +11928,8 @@ function registerPiDreamerProject(opts) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(opts.config),
       ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
       language: opts.language,
-      retinaHandoff: opts.retinaHandoff
+      retinaHandoff: opts.retinaHandoff,
+      mural: opts.mural
     }),
     task
   });
@@ -11656,7 +11965,6 @@ async function awaitInFlightDreamers() {
 }
 function createPiDreamerClient(opts) {
   const runner = piSubagentRunnerFactory();
-  const model = opts.config.model;
   const session = {
     create: async (args) => {
       const sessionId = `magic-context-pi-dream-${++sessionCounter}`;
@@ -11677,7 +11985,7 @@ function createPiDreamerClient(opts) {
       }
       const userMessage = extractUserMessage(args);
       const systemPrompt = extractSystemPrompt(args);
-      const perTaskModel = extractBodyModel(args) ?? model;
+      const perTaskModel = extractBodyModel(args);
       const requestedAgent = extractBodyAgent(args) ?? "magic-context-dreamer";
       const runPromise = runner.run({
         agent: requestedAgent,
@@ -11688,7 +11996,7 @@ function createPiDreamerClient(opts) {
         timeoutMs: 30 * 60 * 1000,
         cwd: dreamSession.directory,
         signal: args.signal ?? undefined,
-        thinkingLevel: opts.config.thinking_level
+        thinkingLevel: extractBodyVariant(args)
       });
       inFlightDreams.add(runPromise);
       try {
@@ -11779,6 +12087,13 @@ function extractBodyModel(args) {
   }
   return;
 }
+function extractBodyVariant(args) {
+  const body = args.body;
+  if (typeof body !== "object" || body === null)
+    return;
+  const variant = body.variant;
+  return typeof variant === "string" && variant.length > 0 ? variant : undefined;
+}
 function extractBodyAgent(args) {
   const body = args.body;
   if (typeof body !== "object" || body === null)
@@ -12916,10 +13231,19 @@ function writeTransformDecisionRow(dbPath, row) {
 function writeTransformDecisionRowOnDatabase(db, row, configureBusyTimeout) {
   if (configureBusyTimeout)
     db.exec("PRAGMA busy_timeout=0");
+  const systemHashPrev = row.materialized ? row.systemHashPrev : null;
+  const systemHashNew = row.materialized ? row.systemHashNew : null;
+  const m0ModelKeyPrev = row.materialized ? row.m0ModelKeyPrev : null;
+  const m0ModelKeyNew = row.materialized ? row.m0ModelKeyNew : null;
+  const m0ToolSetHashPrev = row.m0ToolSetHashPrev ?? null;
+  const m0ToolSetHashNew = row.m0ToolSetHashNew ?? null;
   db.prepare(`INSERT OR REPLACE INTO transform_decisions (
                 session_id, harness, message_id, ts_ms, decision, materialized,
-                materialize_reason, emergency, dropped_tokens, dropped_count, input_tokens
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.sessionId, row.harness, row.messageId, row.tsMs, row.decision, row.materialized ? 1 : 0, row.materializeReason, row.emergency ? 1 : 0, Math.max(0, Math.floor(row.droppedTokens)), Math.max(0, Math.floor(row.droppedCount)), Math.max(0, Math.floor(row.inputTokens)));
+                materialize_reason, system_hash_prev, system_hash_new,
+                m0_tool_set_hash_prev, m0_tool_set_hash_new,
+                m0_model_key_prev, m0_model_key_new, emergency, dropped_tokens,
+                dropped_count, input_tokens
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.sessionId, row.harness, row.messageId, row.tsMs, row.decision, row.materialized ? 1 : 0, row.materializeReason, systemHashPrev, systemHashNew, m0ToolSetHashPrev, m0ToolSetHashNew, m0ModelKeyPrev, m0ModelKeyNew, row.emergency ? 1 : 0, Math.max(0, Math.floor(row.droppedTokens)), Math.max(0, Math.floor(row.droppedCount)), Math.max(0, Math.floor(row.inputTokens)));
   db.prepare(`DELETE FROM transform_decisions
              WHERE session_id = ? AND harness = ?
                AND rowid NOT IN (
@@ -15975,6 +16299,17 @@ function isSyntheticMessage(message, index, input) {
   const role = typeof message.role === "string" ? message.role : "";
   return role === "system" || role === "custom" || role === "compactionSummary";
 }
+function countRealPiUserMessages(input) {
+  let count = 0;
+  for (let index = 0;index < input.messages.length; index += 1) {
+    const message = input.messages[index];
+    if (!isRecord3(message) || message.role !== "user")
+      continue;
+    if (!isSyntheticMessage(message, index, input))
+      count += 1;
+  }
+  return count;
+}
 function imageContentAndTokens(part) {
   const data = typeof part.data === "string" ? part.data : "";
   const mimeType = typeof part.mimeType === "string" ? part.mimeType : "image/png";
@@ -16168,7 +16503,7 @@ function excludedDraft(key, value) {
     tokens: 0
   };
 }
-function finalizeParts(drafts, protectedTags) {
+function finalizeParts(drafts, protectedTags, pendingDropTagNumbers) {
   const visibleTags = new Map;
   for (const part of drafts) {
     if (part.kind !== "excluded" && part.tag)
@@ -16183,7 +16518,8 @@ function finalizeParts(drafts, protectedTags) {
   const parts = drafts.map((draft) => {
     const protectedPart = draft.tag ? protectedNumbers.has(draft.tag.tagNumber) : false;
     const tokens = Math.max(0, draft.tokens);
-    const uTokens = draft.tag && !protectedPart && draft.kind !== "excluded" ? tokens : 0;
+    const queuedForDrop = draft.tag ? pendingDropTagNumbers.has(draft.tag.tagNumber) : false;
+    const uTokens = draft.tag && !protectedPart && !queuedForDrop && draft.kind !== "excluded" ? tokens : 0;
     t += tokens;
     u += uTokens;
     return {
@@ -16194,7 +16530,8 @@ function finalizeParts(drafts, protectedTags) {
       uTokens,
       tagNumber: draft.tag?.tagNumber ?? null,
       tagStatus: draft.tag ? "active" : null,
-      protected: protectedPart
+      protected: protectedPart,
+      queuedForDrop
     };
   });
   const clampedT = Math.max(0, t);
@@ -16336,29 +16673,34 @@ function measurePiTailHygiene(input) {
       drafts.push(excludedDraft(`${key}\x00excluded`, part));
     }
   }
-  return finalizeParts(drafts, input.protectedTags);
+  return finalizeParts(drafts, input.protectedTags, input.pendingDropTagNumbers ?? new Set);
 }
 function sameMeasuredPrefix(baseline, current) {
   if (current.length < baseline.length)
-    return { valid: false, boundaryAdvanceU: 0 };
+    return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
   let boundaryAdvanceU = 0;
+  let queuedDropDeltaU = 0;
   for (let index = 0;index < baseline.length; index += 1) {
     const before = baseline[index];
     const after = current[index];
     if (before.key !== after.key || before.contentHash !== after.contentHash || before.kind !== after.kind || before.tokens !== after.tokens || before.tagNumber !== after.tagNumber || before.tagStatus !== after.tagStatus) {
-      return { valid: false, boundaryAdvanceU: 0 };
+      return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
     }
     if (!before.protected && after.protected)
-      return { valid: false, boundaryAdvanceU: 0 };
+      return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
     if (before.protected && !after.protected) {
       if (after.tagStatus !== "active")
-        return { valid: false, boundaryAdvanceU: 0 };
-      boundaryAdvanceU += after.tokens;
+        return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
+      boundaryAdvanceU += after.uTokens;
+    } else if (before.queuedForDrop !== after.queuedForDrop) {
+      if (before.tagStatus !== "active" || after.tagStatus !== "active")
+        return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
+      queuedDropDeltaU += after.uTokens - before.uTokens;
     } else if (before.uTokens !== after.uTokens) {
-      return { valid: false, boundaryAdvanceU: 0 };
+      return { valid: false, boundaryAdvanceU: 0, queuedDropDeltaU: 0 };
     }
   }
-  return { valid: true, boundaryAdvanceU };
+  return { valid: true, boundaryAdvanceU, queuedDropDeltaU };
 }
 function refreshPiTailHygieneBaseline(input) {
   const measured = measurePiTailHygiene(input);
@@ -16390,7 +16732,7 @@ function refreshPiTailHygieneBaseline(input) {
     };
   }
   let turnDeltaT = 0;
-  let turnDeltaU = prefix.boundaryAdvanceU;
+  let turnDeltaU = prefix.boundaryAdvanceU + prefix.queuedDropDeltaU;
   for (let index = input.previous.baselineParts.length;index < measured.parts.length; index += 1) {
     const part = measured.parts[index];
     turnDeltaT += part.tokens;
@@ -16484,20 +16826,38 @@ function maybeChannel1ReminderForToolResult(args) {
   if (deltaTokens === 0)
     return null;
   state2.turnDeltaT += deltaTokens;
+  if (state2.agentDropsAppliedThisPass)
+    return null;
+  const nudgeState = getChannel1NudgeState(db, sessionId);
   const decision = decideChannel1({
     ...state2,
     lastNudgeUndropped: getLastNudgeUndropped(db, sessionId),
-    lastNudgeLevel: getLastNudgeLevel(db, sessionId),
+    lastNudgeLevel: nudgeState.level,
     hasRecentReduce: state2.reducedSinceRefresh
   });
   setLastNudgeUndropped(db, sessionId, decision.nextLastNudge);
-  setLastNudgeLevel(db, sessionId, decision.nextLastNudgeLevel);
-  if (!decision.fire)
+  if (!decision.fire) {
+    setChannel1NudgeState(db, sessionId, {
+      level: decision.nextLastNudgeLevel,
+      ordinal: decision.nextLastNudgeLevel === "" ? 0 : nudgeState.ordinal
+    });
     return null;
-  return {
+  }
+  const sticky = shouldUseStickyChannel1Reminder({
+    lastLevel: nudgeState.level,
+    lastOrdinal: nudgeState.ordinal,
+    level: decision.level,
+    currentRealUserTurnCount: state2.realUserTurnCount
+  });
+  const block = {
     type: "text",
-    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state2.oldestReclaimableToolTags)
+    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state2.usableWindow, state2.oldestReclaimableToolTags, sticky)
   };
+  setChannel1NudgeState(db, sessionId, {
+    level: decision.level,
+    ordinal: state2.realUserTurnCount
+  });
+  return block;
 }
 var CHANNEL2_NUDGE_CUSTOM_TYPE = "magic-context:ceiling-nudge";
 function maybeDeliverChannel2Pi(pi, db, sessionId) {
@@ -16528,7 +16888,7 @@ function maybeDeliverChannel2Pi(pi, db, sessionId) {
   try {
     const message = {
       customType: CHANNEL2_NUDGE_CUSTOM_TYPE,
-      content: buildChannel2Reminder(undropped, baseline.oldestReclaimableToolTags),
+      content: buildChannel2Reminder(undropped, baseline.usableWindow, baseline.oldestReclaimableToolTags),
       display: false,
       details: { kind: "channel-2-ceiling-nudge" }
     };
@@ -17694,6 +18054,11 @@ function injectM0M1Pi(state2, db, piMessages, entryIds, recomputeM1ThisPass = fa
     m0 = stripMemoryMuralBlock(m0);
   prependM0M1Messages(piMessages, m0, m1, muralWire);
   sessionLog(state2.sessionId, `injected m[0]/m[1] into Pi messages (${m0.length} + ${m1.length} bytes, materialized=${materialized}${decision.reason ? ` reason=${decision.reason}` : ""})`);
+  const comparison = decision.mismatch;
+  const systemHashPrev = comparison?.signal === "systemHash" && typeof comparison.cached === "string" ? comparison.cached : null;
+  const systemHashNew = comparison?.signal === "systemHash" && typeof comparison.current === "string" ? comparison.current : null;
+  const m0ModelKeyPrev = comparison?.signal === "modelKey" && typeof comparison.cached === "string" ? comparison.cached : null;
+  const m0ModelKeyNew = comparison?.signal === "modelKey" && typeof comparison.current === "string" ? comparison.current : null;
   const memPath = memoryProjectPath(state2);
   const workspace = resolveWorkspaceRenderContextPi(state2, db);
   const memoryCount = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories).length : getMemoriesByProject(db, memPath, ["active", "permanent"]).length : 0;
@@ -17705,6 +18070,10 @@ function injectM0M1Pi(state2, db, piMessages, entryIds, recomputeM1ThisPass = fa
     skippedVisibleMessages,
     m0Materialized: materialized,
     m0Reason: decision.reason,
+    systemHashPrev: materialized ? systemHashPrev : null,
+    systemHashNew: materialized ? systemHashNew : null,
+    m0ModelKeyPrev: materialized ? m0ModelKeyPrev : null,
+    m0ModelKeyNew: materialized ? m0ModelKeyNew : null,
     m0Bytes: m0.length,
     m1Bytes: m1.length,
     contentionExhausted,
@@ -20860,7 +21229,7 @@ function buildReferenceBlocks(args) {
 
 // src/pi-historian-runner.ts
 var HISTORIAN_AGENT_NAME = "magic-context-historian";
-var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 120000;
+var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
 var MAX_HISTORIAN_RETRIES = 2;
 var HISTORIAN_ALERT_COOLDOWN_MS = 60 * 1000;
 var lastHistorianAlertBySession = new Map;
@@ -20961,19 +21330,24 @@ async function runHistorianSubagentWithTransientRetries(args) {
   }
   return historianAbortResult(startedAt);
 }
-function buildHistorianFallbackChain(primaryModel, fallbackModels, fallbackModelId) {
-  const seen = new Set;
-  if (primaryModel)
-    seen.add(primaryModel);
+function buildHistorianFallbackChain(primaryModel, primaryThinkingLevel, fallbackModels, fallbackModelId) {
+  const seen = new Set([
+    `${primaryModel}\x00${primaryThinkingLevel ?? ""}`
+  ]);
   const chain = [];
   for (const candidate of fallbackModels ?? []) {
-    if (!candidate || seen.has(candidate))
+    const entry = typeof candidate === "string" ? { model: candidate } : candidate;
+    const key = `${entry.model}\x00${entry.qualifier ?? ""}`;
+    if (!entry.model || seen.has(key))
       continue;
-    seen.add(candidate);
-    chain.push({ modelId: candidate, kind: "configured" });
+    seen.add(key);
+    chain.push({ entry, kind: "configured" });
   }
-  if (fallbackModelId && !seen.has(fallbackModelId)) {
-    chain.push({ modelId: fallbackModelId, kind: "session" });
+  if (fallbackModelId) {
+    const entry = { model: fallbackModelId };
+    const key = `${entry.model}\x00`;
+    if (!seen.has(key))
+      chain.push({ entry, kind: "session" });
   }
   return chain;
 }
@@ -21292,11 +21666,11 @@ ${chunkText}`,
           validatedDraftText = repairResult.assistantText;
         }
       }
-      const fallbackChain = buildHistorianFallbackChain(historianModel, fallbackModels, fallbackModelId);
+      const fallbackChain = buildHistorianFallbackChain(historianModel, thinkingLevel, fallbackModels, fallbackModelId);
       if (validatedPass.kind !== "ok" && !(validatedPass.kind === "spawn-failed" && validatedPass.reason === "abort") && fallbackChain.length > 0) {
         for (let i = 0;i < fallbackChain.length; i += 1) {
           const candidate = fallbackChain[i];
-          sessionLog(sessionId, `historian: escalating to ${candidate.kind === "session" ? "session-model last resort" : "configured fallback model"} ${candidate.modelId}`);
+          sessionLog(sessionId, `historian: escalating to ${candidate.kind === "session" ? "session-model last resort" : "configured fallback model"} ${candidate.entry.model}`);
           const fbResult = await runHistorianSubagentWithTransientRetries({
             runner,
             sessionId,
@@ -21306,11 +21680,11 @@ ${chunkText}`,
               agent: HISTORIAN_AGENT_NAME,
               systemPrompt: historianSystemPrompt,
               userMessage: prompt,
-              model: candidate.modelId,
+              model: candidate.entry.model,
               timeoutMs: historianTimeoutMs,
               cwd: directory,
               signal,
-              thinkingLevel,
+              thinkingLevel: candidate.entry.qualifier,
               onProgress: buildProgressLogger("fallback"),
               accountingSessionId: sessionId,
               accountingSubagent: "historian"
@@ -24324,6 +24698,10 @@ function registerPiContextHandler(pi, baseOptions) {
           decision: schedulerDecision,
           materialized: result.materialized,
           materializeReason: normalizeMaterializeReason("pi", result.materializeReason, result.materialized),
+          systemHashPrev: result.materialized ? result.injectionResult?.systemHashPrev ?? null : null,
+          systemHashNew: result.materialized ? result.injectionResult?.systemHashNew ?? null : null,
+          m0ModelKeyPrev: result.materialized ? result.injectionResult?.m0ModelKeyPrev ?? null : null,
+          m0ModelKeyNew: result.materialized ? result.injectionResult?.m0ModelKeyNew ?? null : null,
           emergency: result.emergency,
           droppedTokens: result.droppedTokens,
           droppedCount: result.droppedCount,
@@ -24415,11 +24793,13 @@ function registerPiContextHandler(pi, baseOptions) {
         if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
           const tags = getTagsBySession(options.db, sessionId);
           const protectedTags = options.protectedTags ?? 20;
+          const pendingDropTagNumbers = new Set(getPendingOps(options.db, sessionId).filter((operation) => operation.operation === "drop").map((operation) => operation.tagId));
           const stableId = (message) => message && typeof message === "object" ? result.postCommitEntryIdByRef.get(message) : undefined;
           const baseline = refreshPiTailHygieneBaseline({
             messages: outputMessages,
             tags,
             protectedTags,
+            pendingDropTagNumbers,
             stableId,
             syntheticLeadingCount: result.syntheticLeadingCount,
             cacheBusting: result.bustedThisPass,
@@ -24430,7 +24810,17 @@ function registerPiContextHandler(pi, baseOptions) {
           const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags(options.db, sessionId, protectedTags);
           const channelState = {
             ...baseline,
+            usableWindow: usageContextLimit ?? 0,
+            realUserTurnCount: countRealPiUserMessages({
+              messages: outputMessages,
+              tags,
+              protectedTags,
+              pendingDropTagNumbers,
+              stableId,
+              syntheticLeadingCount: result.syntheticLeadingCount
+            }),
             reducedSinceRefresh: false,
+            agentDropsAppliedThisPass: result.agentDropsAppliedThisPass,
             oldestReclaimableToolTags
           };
           setPiChannel1Baseline(sessionId, channelState);
@@ -24455,6 +24845,7 @@ function registerPiContextHandler(pi, baseOptions) {
             messages: outputMessages,
             tags,
             protectedTags,
+            pendingDropTagNumbers,
             stableId,
             syntheticLeadingCount: result.syntheticLeadingCount,
             expectedSignature: baseline.contentSignature
@@ -24984,6 +25375,7 @@ async function runCompactionOffPipeline(args) {
     droppedCount: 0,
     emergency: false,
     bustedThisPass: injectionResult?.m0Materialized === true,
+    agentDropsAppliedThisPass: false,
     targetCount: 0,
     reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags: [],
@@ -25425,7 +25817,11 @@ async function runPipeline(args) {
       injectionResult = preFoldInjectionResult?.m0Materialized ? {
         ...wireInjectionResult,
         m0Materialized: true,
-        m0Reason: preFoldInjectionResult.m0Reason ?? wireInjectionResult.m0Reason
+        m0Reason: preFoldInjectionResult.m0Reason ?? wireInjectionResult.m0Reason,
+        systemHashPrev: preFoldInjectionResult.systemHashPrev ?? null,
+        systemHashNew: preFoldInjectionResult.systemHashNew ?? null,
+        m0ModelKeyPrev: preFoldInjectionResult.m0ModelKeyPrev ?? null,
+        m0ModelKeyNew: preFoldInjectionResult.m0ModelKeyNew ?? null
       } : wireInjectionResult;
       if (args.temporalAwareness && injectionResult.skippedVisibleMessages > 0) {
         const firstRetainedMessage = args.messages[injectionResult.syntheticLeadingCount];
@@ -25553,6 +25949,7 @@ async function runPipeline(args) {
     droppedCount,
     emergency,
     bustedThisPass,
+    agentDropsAppliedThisPass: pendingOpsDidMutate,
     targetCount: targets.size,
     reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags,
@@ -25845,6 +26242,7 @@ async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
     dumpLabel: `${args.dumpLabelBase}-initial`,
+    modelOverride: args.model,
     agentId: args.agentId
   });
   if (!firstRun.ok || !firstRun.result) {
@@ -25873,6 +26271,7 @@ async function runValidatedHistorianPass(args) {
     ...args,
     prompt: repairPrompt,
     dumpLabel: `${args.dumpLabelBase}-repair`,
+    modelOverride: args.model,
     agentId: args.agentId
   });
   if (!repairRun.ok || !repairRun.result) {
@@ -25913,7 +26312,8 @@ async function runEditorPassOrFallback(args) {
     timeoutMs: args.timeoutMs,
     dumpLabel: `${args.dumpLabelBase}-editor`,
     agentId: HISTORIAN_EDITOR_AGENT,
-    parentInvocationId: args.draftInvocationId ?? null
+    parentInvocationId: args.draftInvocationId ?? null,
+    modelOverride: args.model
   });
   if (!editorRun.ok || !editorRun.result) {
     sessionLog(args.parentSessionId, "historian two-pass: editor call failed", {
@@ -25966,7 +26366,7 @@ async function runHistorianPrompt(args) {
     });
   };
   try {
-    sessionLog(parentSessionId, `historian: creating child session (agent=${agentId}, model=${modelOverride ? `${modelOverride.providerID}/${modelOverride.modelID}` : `agent:${agentId}`})`);
+    sessionLog(parentSessionId, `historian: creating child session (agent=${toModelEntry(modelOverride)?.model ?? `agent:${agentId}`})`);
     const createResponse = await createChildSessionWithFence({
       client,
       db,
@@ -25990,7 +26390,7 @@ async function runHistorianPrompt(args) {
           query: { directory: sessionDirectory },
           body: {
             agent: agentId,
-            ...modelOverride ? { model: modelOverride } : {},
+            ...modelBodyField(modelOverride),
             parts: [{ type: "text", text: prompt, synthetic: true }]
           }
         }, {
@@ -26051,22 +26451,30 @@ async function runHistorianPrompt(args) {
       error: `Historian failed while processing this session: ${desc.brief}`
     };
   } finally {
-    if (agentSessionId && outcomeOk && !shouldKeepSubagents()) {
-      await client.session.delete({ path: { id: agentSessionId } }).catch((e) => {
-        sessionLog(parentSessionId, "compartment agent: session cleanup failed", getErrorMessage(e));
-      });
-    } else if (agentSessionId && (!outcomeOk || shouldKeepSubagents())) {
-      sessionLog(parentSessionId, `historian: KEEPING child session ${agentSessionId} (${outcomeOk ? "keep_subagents" : "failed"}) — not deleted`);
+    if (agentSessionId) {
+      const retentionReason = shouldKeepSubagents() ? "keep_subagents" : outcomeOk ? "prompt completed; cleanup deferred to the age-gated sweep" : "failed; cleanup deferred to the age-gated sweep";
+      sessionLog(parentSessionId, `historian: KEEPING child session ${agentSessionId} (${retentionReason}) — not deleted inline`);
     }
   }
 }
 async function runFallbackHistorianPass(args) {
   const seen = new Set;
   const chain = [];
-  for (const candidate of [...args.fallbackModels ?? [], args.fallbackModelId ?? ""]) {
-    if (!candidate || seen.has(candidate))
+  const primary = toModelEntry(args.model);
+  for (const candidateInput of [
+    ...args.fallbackModels ?? [],
+    ...args.fallbackModelId ? [{ model: args.fallbackModelId }] : []
+  ]) {
+    const candidate = toModelEntry(candidateInput);
+    if (!candidate)
       continue;
-    seen.add(candidate);
+    const key = `${candidate.model}\x00${candidate.qualifier ?? ""}`;
+    if (!candidate.model || seen.has(key))
+      continue;
+    if (primary?.model === candidate.model && primary.qualifier === candidate.qualifier) {
+      continue;
+    }
+    seen.add(key);
     chain.push(candidate);
   }
   if (chain.length === 0) {
@@ -26074,9 +26482,9 @@ async function runFallbackHistorianPass(args) {
   }
   let lastError = args.error;
   for (let i = 0;i < chain.length; i += 1) {
-    const modelId = chain[i];
-    const modelOverride = parseModelOverride(modelId);
-    if (!modelOverride)
+    const modelOverride = chain[i];
+    const modelId = modelOverride.model;
+    if (!parseModelOverride(modelId))
       continue;
     const isSessionModelLastResort = modelId === args.fallbackModelId && i === chain.length - 1;
     sessionLog(args.parentSessionId, `compartment agent: retrying historian with ${modelId} (${isSessionModelLastResort ? "session-model last resort" : "configured fallback"} ${i + 1}/${chain.length})`);
@@ -26405,6 +26813,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         sequenceOffset: candidateCompartments.length,
         dumpLabelBase: `recomp-${sessionId}-${chunk.startIndex}-${chunk.endIndex}-pass-${passCount + 1}`,
         timeoutMs: historianTimeoutMs,
+        model: deps.model,
         fallbackModelId: deps.fallbackModelId,
         fallbackModels: deps.fallbackModels,
         twoPass: deps.historianTwoPass,
@@ -26825,6 +27234,7 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         sequenceOffset: candidateCompartments.length,
         dumpLabelBase: `partial-recomp-${sessionId}-${chunk.startIndex}-${chunk.endIndex}-pass-${passCount + 1}`,
         timeoutMs: historianTimeoutMs,
+        model: deps.model,
         fallbackModelId: deps.fallbackModelId,
         fallbackModels: deps.fallbackModels,
         twoPass: deps.historianTwoPass,
@@ -27016,11 +27426,11 @@ function createPiHistorianClient(args) {
       agent: "magic-context-historian",
       systemPrompt: args.systemPrompt,
       userMessage: promptText,
-      model: modelOverride ?? args.model,
+      model: modelOverride?.model ?? args.model,
       fallbackModels: modelOverride ? undefined : args.fallbackModels,
       timeoutMs: args.timeoutMs,
       cwd: args.directory,
-      thinkingLevel: args.thinkingLevel,
+      thinkingLevel: modelOverride ? modelOverride.qualifier : args.thinkingLevel,
       accountingSessionId: args.accountingSessionId,
       accountingSubagent: "recomp"
     });
@@ -27068,7 +27478,8 @@ function readBodyModel(body) {
     return;
   const { providerID, modelID } = model;
   if (typeof providerID === "string" && providerID.length > 0 && typeof modelID === "string" && modelID.length > 0) {
-    return `${providerID}/${modelID}`;
+    const qualifier = typeof body.variant === "string" && body.variant.length > 0 ? body.variant : undefined;
+    return qualifier ? { model: `${providerID}/${modelID}`, qualifier } : { model: `${providerID}/${modelID}` };
   }
   return;
 }
@@ -27678,13 +28089,17 @@ async function runPiMemoryMigration(deps) {
   const prompt = buildMemoryMigrationPrompt(memories);
   const modelChain = [];
   const seenModels = new Set;
-  for (const m of [
-    deps.primaryModel ?? deps.model,
-    ...deps.fallbackModels ?? []
+  for (const candidate of [
+    {
+      model: deps.primaryModel ?? deps.model,
+      ...deps.primaryModel ? {} : deps.thinkingLevel ? { qualifier: deps.thinkingLevel } : {}
+    },
+    ...(deps.fallbackModels ?? []).map((fallback) => typeof fallback === "string" ? { model: fallback } : fallback)
   ]) {
-    if (m && !seenModels.has(m)) {
-      seenModels.add(m);
-      modelChain.push(m);
+    const key = `${candidate.model}\x00${candidate.qualifier ?? ""}`;
+    if (candidate.model && !seenModels.has(key)) {
+      seenModels.add(key);
+      modelChain.push(candidate);
     }
   }
   let parsed = null;
@@ -27692,17 +28107,17 @@ async function runPiMemoryMigration(deps) {
   for (let i = 0;i < modelChain.length; i += 1) {
     const model = modelChain[i];
     if (i > 0) {
-      sessionLog(deps.sessionId, `memory-migration: escalating to configured fallback model ${model} (${i}/${modelChain.length - 1})`);
+      sessionLog(deps.sessionId, `memory-migration: escalating to configured fallback model ${model.model} (${i}/${modelChain.length - 1})`);
     }
     const result = await deps.runner.run({
       agent: "magic-context-historian",
       systemPrompt: withMigrationLanguageDirective(MIGRATION_SYSTEM_PROMPT2, deps.language),
       userMessage: prompt,
-      model,
+      model: model.model,
       fallbackModels: undefined,
       timeoutMs: deps.timeoutMs ?? 5 * 60 * 1000,
       cwd: deps.directory,
-      thinkingLevel: deps.thinkingLevel,
+      thinkingLevel: model.qualifier,
       accountingSessionId: deps.sessionId,
       accountingSubagent: "recomp"
     });
@@ -28096,7 +28511,7 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       "### Cache TTL",
       `- Configured: ${meta.cacheTtl}`,
       `- Last response: ${meta.lastResponseTime > 0 ? `${Math.round(elapsed / 1000)}s ago` : "never"}`,
-      `- Remaining: ${cacheExpired ? "expired" : ttlMs === Number.POSITIVE_INFINITY ? "never expires (always-warm lane)" : `${Math.round(remainingMs / 1000)}s`}`,
+      `- Remaining: ${cacheExpired ? "expired" : ttlMs === Number.POSITIVE_INFINITY ? "never (MC never assumes expiry — external cache-keep)" : `${Math.round(remainingMs / 1000)}s`}`,
       `- Queue will auto-execute: ${cacheExpired ? "yes (cache expired)" : ttlMs === Number.POSITIVE_INFINITY ? `when context >= ${executeThresholdPercentage}%` : `when TTL expires or context >= ${executeThresholdPercentage}%`}`,
       "",
       "### Execute Threshold",
@@ -28216,7 +28631,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.38.0",
+  version: "0.39.0",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -28247,7 +28662,7 @@ var package_default = {
     build: "tsc -p ../retina-local-fs/tsconfig.build.json && rm -f dist/index.js dist/subagent-entry.js dist/*-*.js && bun build src/index.ts src/subagent-entry.ts --outdir dist --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external @huggingface/transformers --external node:sqlite",
     "build:e2e-argv": "bun build src/subagent-runner.ts --outfile ../../tests/docker/.generated/subagent-runner-e2e.mjs --target node --format esm --external node:sqlite",
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit",
-    test: "bun test",
+    test: "bun install --frozen-lockfile && bun test",
     lint: "biome check src",
     "lint:fix": "biome check --write src",
     format: "biome format --write src",
@@ -28411,7 +28826,7 @@ function renderInner(s, theme, innerWidth) {
     lines.push(`Upgrade: ${theme.fg("accent", "up to date")}`);
   }
   lines.push(`Pending drops: ${s.pendingOpsCount}`);
-  lines.push(`Cache TTL: ${s.cacheTtl} · last response ${s.lastResponseTime > 0 ? `${Math.round((Date.now() - s.lastResponseTime) / 1000)}s ago` : "never"} · ${s.cacheExpired ? theme.fg("warning", "expired") : s.cacheRemainingMs === Number.POSITIVE_INFINITY ? "never expires (always-warm lane)" : `${Math.round(s.cacheRemainingMs / 1000)}s remaining`}`);
+  lines.push(`Cache TTL: ${s.cacheTtl} · last response ${s.lastResponseTime > 0 ? `${Math.round((Date.now() - s.lastResponseTime) / 1000)}s ago` : "never"} · ${s.cacheExpired ? theme.fg("warning", "expired") : s.cacheRemainingMs === Number.POSITIVE_INFINITY ? "never (MC never assumes expiry — external cache-keep)" : `${Math.round(s.cacheRemainingMs / 1000)}s remaining`}`);
   lines.push("");
   lines.push(theme.fg("muted", "Tags"));
   lines.push(`Active ${s.activeTags} (~${formatBytes(s.activeBytes)}) · Dropped ${s.droppedTags} · Total ${s.totalTags}`);
@@ -29566,12 +29981,13 @@ function resolveHistorianFromConfig(config) {
   const historian = config.historian;
   if (historian?.disable === true)
     return;
-  const model = historian?.model?.trim();
-  if (!model || model.length === 0)
+  const resolved = resolveHistorianModel(config, "pi");
+  const model = resolved.primary?.model;
+  if (!model)
     return;
   const historianContextLimit = resolveHistorianContextLimit(model);
   const historianChunkTokens = deriveHistorianChunkTokens(historianContextLimit);
-  const fallbackModels = resolveFallbackChain(historian?.fallback_models);
+  const fallbackModels = resolved.fallbacks;
   return {
     runner: new PiSubagentRunner,
     model,
@@ -29579,7 +29995,7 @@ function resolveHistorianFromConfig(config) {
     historianChunkTokens,
     timeoutMs: config.historian_timeout_ms,
     twoPass: historian?.two_pass === true,
-    thinkingLevel: historian?.thinking_level,
+    thinkingLevel: resolved.primary?.qualifier,
     executeThresholdPercentage: config.execute_threshold_percentage,
     executeThresholdTokens: config.execute_threshold_tokens,
     commitClusterTrigger: config.commit_cluster_trigger,
@@ -30069,6 +30485,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       embeddingConfig: bootProjectDeps.config.embedding,
       memoryEnabled: bootProjectDeps.config.memory.enabled,
       retinaHandoff: bootProjectDeps.config.smart_notes.retina_handoff,
+      mural: bootProjectDeps.config.mural,
       language: bootProjectDeps.config.language,
       gitCommitIndexing: bootProjectDeps.config.memory.git_commit_indexing,
       onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
@@ -30447,16 +30864,16 @@ function formatExecuteThresholdForLog(value) {
   return overrides.length > 0 ? `${base} (${overrides.join(", ")})` : base;
 }
 export {
-  signalPiDeferredCompactionMarkerDrain,
-  resolveSidekickFromConfig,
-  resolveHistorianFromConfig,
-  resolveDreamerFromConfig,
-  persistPiPressureFromMessageEnd,
-  persistPiMessageEndModelMeta,
-  handlePiSessionBeforeCompact,
-  src_default as default,
-  capturePiTodowriteMessageIfCompatible,
-  capturePiTodowriteArgsIfCompatible,
+  __test,
   canonicalPiModelKey,
-  __test
+  capturePiTodowriteArgsIfCompatible,
+  capturePiTodowriteMessageIfCompatible,
+  src_default as default,
+  handlePiSessionBeforeCompact,
+  persistPiMessageEndModelMeta,
+  persistPiPressureFromMessageEnd,
+  resolveDreamerFromConfig,
+  resolveHistorianFromConfig,
+  resolveSidekickFromConfig,
+  signalPiDeferredCompactionMarkerDrain
 };