@cortexkit/pi-magic-context 0.38.1 → 0.40.0

package/dist/index.js

@@ -13,6 +13,7 @@ import {
   DEFAULT_MEMORY_BUDGET_TOKENS,
   DEFAULT_USER_PROFILE_BUDGET_TOKENS,
   Database,
+  FAIL_CLOSED_DOCTOR_COMMAND,
   GIT_SWEEP_LEASE_RENEWAL_MS,
   GLOBAL_USER_PROFILE_PROJECT_PATH,
   LATEST_SUPPORTED_VERSION,
@@ -86,6 +87,8 @@ import {
   copySessionStateForClone,
   cosineSimilarity,
   countPrimerCandidatesForProject,
+  createFailClosedBlockingError,
+  createFailClosedController,
   createPrimer,
   createPromptSurfaceGuidanceEpochCache,
   createPromptSurfaceRuntime,
@@ -125,6 +128,7 @@ import {
   findAdoptableFallbackTags,
   findLastModelKeyFromBranch,
   findPiFallbackToolOwnerTags,
+  formatFailClosedBlockingMessage,
   formatWindowDerivationLine,
   getActivePrimers,
   getActiveTagsBySession,
@@ -134,6 +138,7 @@ import {
   getAllStatusTagTokenTotalsFlat,
   getAutoSearchHintDecisions,
   getCachedAbsoluteMessageCount,
+  getChannel1NudgeState,
   getChannel2NudgeClaim,
   getChannel2NudgeState,
   getCompactionModeRecord,
@@ -149,7 +154,6 @@ import {
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
   getLastIndexedOrdinal,
-  getLastNudgeLevel,
   getLastNudgeUndropped,
   getLatestHistorianInvocationId,
   getLegacyProtectedTailStartOrdinal,
@@ -226,6 +230,7 @@ import {
   hasMuralCueColumns,
   hasPiFallbackMessageTags,
   hasPiFallbackToolOwnerTags,
+  hasShareabilitySensitiveText,
   incrementHistorianFailure,
   indexCommitsForProject,
   indexMessagesAfterOrdinal,
@@ -241,6 +246,7 @@ import {
   isCompartmentLeaseHeld,
   isDreamerRunnable,
   isEditTool,
+  isFailClosedBlockingError,
   isMessageIndexReconciledThrough,
   isMessageIndexSourceCurrent,
   isMidTurn,
@@ -343,11 +349,11 @@ import {
   saveRecompStagingPass,
   saveSourceContent,
   scheduleAfterBootQuiet,
+  setChannel1NudgeState,
   setChannel2NudgeState,
   setCompactionModeRecord,
   setDeferredExecutePendingIfAbsent,
   setEmergencyDropSample,
-  setLastNudgeLevel,
   setLastNudgeUndropped,
   setMemoryClassification,
   setMuralCue,
@@ -361,6 +367,8 @@ import {
   setSqlitePragmaConfig,
   setStoragePrivatePermissionEnforcement,
   setTodoSnapshot,
+  shouldBypassFailClosedBlock,
+  shouldUseStickyChannel1Reminder,
   sourceNameForMemory,
   stripChannel1ReminderSpans,
   stripMemoryMuralBlock,
@@ -395,7 +403,7 @@ import {
   withMigrationLanguageDirective,
   withRawMessageProvider,
   withRawSessionMessageCache
-} from "./index-8e0zezh7.js";
+} from "./index-kamc8t8p.js";
 import {
   pushNotification
 } from "./index-hw34xmzk.js";
@@ -417,49 +425,104 @@ import {
 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 +591,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
     };
   });
 }
@@ -566,170 +627,6 @@ function summarizeDreamSchedule(dreamer) {
   return enabled.map((t) => `${t} ${dreamer?.tasks[t]?.schedule}`).join(", ");
 }
 
-// ../plugin/src/features/magic-context/fail-closed-block.ts
-var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
-var FAIL_CLOSED_REPROBE_EVERY_N = 5;
-
-class FailClosedBlockingError extends Error {
-  code = "FAIL_CLOSED_BLOCKING";
-  reason;
-  constructor(message, reason, options) {
-    super(message, options);
-    this.name = "FailClosedBlockingError";
-    this.reason = reason;
-  }
-}
-var OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
-function isMagicContextHiddenAgentName(agent) {
-  if (agent === "sidekick" || agent === "smart-note-compiler" || agent.startsWith("smart-note-")) {
-    return true;
-  }
-  if (agent === "historian" || agent.startsWith("historian-"))
-    return true;
-  if (agent === "dreamer" || agent.startsWith("dreamer-"))
-    return true;
-  return false;
-}
-var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
-function normalizeFailClosedProcessKind(process2) {
-  switch (process2.kind) {
-    case "OpenCode server":
-    case "OpenCode instance (TUI/CLI)":
-    case "Pi":
-    case "process":
-      return process2.kind;
-  }
-  switch (process2.harness?.trim().toLowerCase()) {
-    case "opencode server":
-      return "OpenCode server";
-    case "opencode instance (tui/cli)":
-    case "opencode instance":
-      return "OpenCode instance (TUI/CLI)";
-    case "pi":
-    case "pi harness":
-    case "omp":
-      return "Pi";
-    default:
-      return "process";
-  }
-}
-function formatFailClosedBlockingProcesses(processes) {
-  const uniqueProcesses = new Map;
-  for (const process2 of processes) {
-    if (!Number.isInteger(process2.pid) || process2.pid <= 0)
-      continue;
-    const kind = normalizeFailClosedProcessKind(process2);
-    uniqueProcesses.set(`${kind}\x00${process2.pid}`, { kind, pid: process2.pid });
-  }
-  const entries = [...uniqueProcesses.values()];
-  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
-  const rendered = visible.map(({ kind, pid }) => `${kind} (PID ${pid})`);
-  const omitted = entries.length - visible.length;
-  if (omitted > 0)
-    rendered.push(`${omitted} more blocking process(es)`);
-  if (rendered.length === 0)
-    return "a live process";
-  if (rendered.length === 1)
-    return rendered[0];
-  const last = rendered.pop();
-  return `${rendered.join(", ")}, and ${last}`;
-}
-function formatFailClosedBlockingMessage(reason) {
-  if (reason.kind === "migration_guard") {
-    if (reason.unreadableFile) {
-      const arm = reason.unreadableArm ?? "io";
-      const recovery = arm === "io" ? `If none of these processes are running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop the relevant process before deleting it.`;
-      return [
-        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live process cannot be proven.`,
-        recovery,
-        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-      ].join(" ");
-    }
-    return [
-      `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
-      "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  if (reason.kind === "schema_fence") {
-    return [
-      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
-  return [
-    `Magic Context cannot operate: persistent storage failed (${cause}).`,
-    "The plugin will not silently degrade to native compaction while enabled.",
-    `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-  ].join(" ");
-}
-function createFailClosedBlockingError(reason, options) {
-  return new FailClosedBlockingError(formatFailClosedBlockingMessage(reason), reason, options);
-}
-function isFailClosedBlockingError(error) {
-  return error instanceof FailClosedBlockingError || typeof error === "object" && error !== null && error.name === "FailClosedBlockingError" && error.code === "FAIL_CLOSED_BLOCKING";
-}
-function shouldBypassFailClosedBlock(input) {
-  if (input.isPiSubagentEnv === true)
-    return true;
-  if (input.isInternalChildSession === true)
-    return true;
-  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
-  if (agent.length === 0)
-    return false;
-  if (OPENCODE_INTERNAL_AGENT_NAMES.has(agent))
-    return true;
-  if (isMagicContextHiddenAgentName(agent))
-    return true;
-  return false;
-}
-function createFailClosedController(options) {
-  const reprobeEveryN = Math.max(1, options?.reprobeEveryN ?? FAIL_CLOSED_REPROBE_EVERY_N);
-  let reason = null;
-  let blockedPassCount = 0;
-  return {
-    arm(next) {
-      reason = next;
-      blockedPassCount = 0;
-    },
-    clear() {
-      reason = null;
-      blockedPassCount = 0;
-    },
-    isArmed() {
-      return reason !== null;
-    },
-    getReason() {
-      return reason;
-    },
-    async enforce(input) {
-      if (!reason)
-        return;
-      if (!input.blockingEnabled)
-        return;
-      if (input.exempt)
-        return;
-      blockedPassCount += 1;
-      const shouldReprobe = typeof input.tryReopen === "function" && (blockedPassCount === 1 || blockedPassCount % reprobeEveryN === 0);
-      if (shouldReprobe) {
-        try {
-          const healed = await input.tryReopen?.();
-          if (healed) {
-            reason = null;
-            blockedPassCount = 0;
-            return;
-          }
-        } catch {}
-      }
-      const blockedReason = reason;
-      if (!blockedReason)
-        return;
-      throw createFailClosedBlockingError(blockedReason);
-    }
-  };
-}
-
 // ../plugin/src/features/magic-context/message-index-async.ts
 function isDatabaseLockedError(error) {
   if (!error || typeof error !== "object")
@@ -1951,6 +1848,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 +2480,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);
@@ -4091,15 +4062,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 +4089,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 +4127,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 +4163,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
@@ -5694,153 +5671,6 @@ function isRustAuthorityDrainingError(error) {
   return error instanceof Error && error.message.includes("authority_draining");
 }
 
-// ../plugin/src/shared/redaction.ts
-import { homedir as homedir2, userInfo } from "node:os";
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var SECRET_WORDS = [
-  "key",
-  "token",
-  "secret",
-  "password",
-  "auth",
-  "authorization",
-  "bearer",
-  "credential"
-];
-var SECRET_SEGMENT_PATTERN = new RegExp(`^(?:${SECRET_WORDS.map((w) => `${w}s?`).join("|")})$`, "i");
-var TRAILING_DESCRIPTORS = new Set(["id", "ids", "value", "values", "header", "headers"]);
-function redactionTypeForKey(key) {
-  const normalized = key.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "_");
-  const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
-  return suffix || "secret";
-}
-function isNonSecretScalarValue(value) {
-  const v = value.trim();
-  if (v === "true" || v === "false" || v === "null" || v === "undefined")
-    return true;
-  return /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v);
-}
-var SECRET_QUALIFIERS = new Set([
-  "api",
-  "access",
-  "private",
-  "client",
-  "auth",
-  "authorization",
-  "secret",
-  "bearer",
-  "session",
-  "refresh",
-  "service",
-  "x",
-  "openai",
-  "anthropic",
-  "google",
-  "github",
-  "huggingface",
-  "aws",
-  "azure"
-]);
-function sanitizePathString(value) {
-  const home = homedir2();
-  const username = userInfo().username;
-  let sanitized = value;
-  if (home) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex(home), "g"), "~");
-  }
-  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
-  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
-  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
-  if (username) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
-  }
-  return sanitized;
-}
-var SECRET_TEXT_PATTERNS = [
-  {
-    pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
-    replacement: "<ANTHROPIC_API_KEY_REDACTED>"
-  },
-  {
-    pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
-    replacement: "<OPENAI_API_KEY_REDACTED>"
-  },
-  {
-    pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
-    replacement: "<GITHUB_PAT_REDACTED>"
-  },
-  {
-    pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
-    replacement: "<GITHUB_TOKEN_REDACTED>"
-  },
-  {
-    pattern: /\bhf_[A-Za-z0-9]{30,}/g,
-    replacement: "<HUGGINGFACE_TOKEN_REDACTED>"
-  },
-  {
-    pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
-    replacement: "<AWS_ACCESS_KEY_ID_REDACTED>"
-  },
-  {
-    pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
-    replacement: "<SLACK_TOKEN_REDACTED>"
-  },
-  {
-    pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
-    replacement: "<GOOGLE_API_KEY_REDACTED>"
-  },
-  {
-    pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
-    replacement: (_full, prefix) => `${prefix}<REDACTED:bearer>`
-  },
-  {
-    pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
-    replacement: "<JWT_REDACTED>"
-  },
-  {
-    pattern: /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
-    replacement: (full, quote, key, separator, valueQuote, value) => isNonSecretScalarValue(value) ? full : `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`
-  },
-  {
-    pattern: /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
-    replacement: (full, key, value) => isNonSecretScalarValue(value) ? full : `${key}=<REDACTED:${redactionTypeForKey(key)}>`
-  }
-];
-function redactSecretText(value) {
-  let redacted = value;
-  for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
-    if (typeof replacement === "string") {
-      redacted = redacted.replace(pattern, replacement);
-    } else {
-      redacted = redacted.replace(pattern, replacement);
-    }
-  }
-  return redacted;
-}
-function sanitizeDiagnosticText(value) {
-  return redactSecretText(sanitizePathString(value));
-}
-var SHAREABILITY_SENSITIVE_PATTERNS = [
-  /\bC:\/Users\/[^/\s]+/i,
-  /(?:^|\s)~\/[^\s]+/,
-  /\b(?:api[_-]?key|secret|token|password|passwd|pwd|client[_-]?secret|access[_-]?key)\b\s*[:=]\s*\S+/i,
-  /\b(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?\b/i,
-  /\b(?:10|127)\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/,
-  /\b192\.168\.\d{1,3}\.\d{1,3}\b/,
-  /\b172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}\b/
-];
-function hasShareabilitySensitiveText(text) {
-  try {
-    if (sanitizeDiagnosticText(text) !== text)
-      return true;
-    return SHAREABILITY_SENSITIVE_PATTERNS.some((pattern) => pattern.test(text));
-  } catch {
-    return true;
-  }
-}
-
 // ../plugin/src/features/magic-context/dreamer/classify-prompt.ts
 var SCORING_GUIDANCE = `### How to score importance (1-100)
 Importance decides which memories survive when the injected memory block is over budget: high scores stay in context, low scores drop first. So the score is only useful if it **discriminates** — if most memories land in the same band, you have not classified them, you have just labelled them.
@@ -6889,15 +6719,60 @@ function getAsyncModule() {
   })();
   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 +6799,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 +6829,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 +7433,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 +7958,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 +8025,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 +8136,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 +8154,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 +8173,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 +9492,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 +9651,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 +9678,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 +9718,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 +10025,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 +10074,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 };
@@ -11235,7 +11197,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,
@@ -11245,7 +11207,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,
@@ -11631,11 +11592,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()
@@ -11649,7 +11612,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,
@@ -11661,7 +11624,8 @@ function registerPiDreamerProject(opts) {
       userMemoryCollectionEnabled: userMemoryCollectionEnabled(opts.config),
       ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
       language: opts.language,
-      retinaHandoff: opts.retinaHandoff
+      retinaHandoff: opts.retinaHandoff,
+      mural: opts.mural
     }),
     task
   });
@@ -11697,7 +11661,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}`;
@@ -11718,7 +11681,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,
@@ -11729,7 +11692,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 {
@@ -11820,6 +11783,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)
@@ -12019,6 +11989,28 @@ var embedPauseBySession = new Set;
 var embedRunStateBySession = new Map;
 var autoEmbedAttemptedBySession = new Set;
 
+// ../plugin/src/hooks/magic-context/format-embed-failure.ts
+function formatEmbedFailureSummary(embedded, remaining, failure) {
+  const compartment = `compartment${embedded === 1 ? "" : "s"}`;
+  if (!failure) {
+    return `Embedded ${embedded} ${compartment}; ${remaining} could not be embedded (the provider returned no result). Run /ctx-embed start again to retry them.`;
+  }
+  const retry = " Run /ctx-embed start again to retry them.";
+  switch (failure.class) {
+    case "substitution_rejected":
+      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: set embedding.model to the served spelling.`;
+    case "http_error": {
+      const fix = failure.reason.startsWith("HTTP 401") || failure.reason.startsWith("HTTP 403") ? " Fix: check embedding.api_key." : failure.reason.startsWith("HTTP 402") ? " Fix: check provider quota or billing." : failure.reason.startsWith("HTTP 404") ? " Fix: check embedding.endpoint and embedding.model." : failure.retryable ? retry : " Fix: check embedding.endpoint, embedding.model, and credentials.";
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${fix}`;
+    }
+    case "invalid_envelope":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: configure an OpenAI-compatible embedding endpoint that returns data[].embedding.`;
+    case "empty_result":
+    case "transport_error":
+      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${failure.retryable ? retry : ""}`;
+  }
+}
+
 // ../plugin/src/hooks/magic-context/format-embed-status.ts
 function formatEmbedStatusText(coverage, drain) {
   if (!coverage.enabled) {
@@ -12168,7 +12160,7 @@ Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
       return {
         text: `## /ctx-embed
 
-Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"}; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed start again to retry them.`,
+${formatEmbedFailureSummary(outcome.embedded, outcome.remaining, outcome.failure)}`,
         level: "info"
       };
     default:
@@ -12961,12 +12953,15 @@ function writeTransformDecisionRowOnDatabase(db, row, configureBusyTimeout) {
   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, 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, 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)));
+            ) 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 (
@@ -16022,6 +16017,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";
@@ -16215,7 +16221,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)
@@ -16230,7 +16236,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 {
@@ -16241,7 +16248,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);
@@ -16383,29 +16391,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);
@@ -16437,7 +16450,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;
@@ -16531,20 +16544,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) {
@@ -16575,7 +16606,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" }
     };
@@ -21017,19 +21048,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;
 }
@@ -21348,11 +21384,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,
@@ -21362,11 +21398,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"
@@ -24475,11 +24511,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,
@@ -24490,7 +24528,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);
@@ -24515,6 +24563,7 @@ function registerPiContextHandler(pi, baseOptions) {
             messages: outputMessages,
             tags,
             protectedTags,
+            pendingDropTagNumbers,
             stableId,
             syntheticLeadingCount: result.syntheticLeadingCount,
             expectedSignature: baseline.contentSignature
@@ -25044,6 +25093,7 @@ async function runCompactionOffPipeline(args) {
     droppedCount: 0,
     emergency: false,
     bustedThisPass: injectionResult?.m0Materialized === true,
+    agentDropsAppliedThisPass: false,
     targetCount: 0,
     reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags: [],
@@ -25617,6 +25667,7 @@ async function runPipeline(args) {
     droppedCount,
     emergency,
     bustedThisPass,
+    agentDropsAppliedThisPass: pendingOpsDidMutate,
     targetCount: targets.size,
     reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags,
@@ -25909,6 +25960,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) {
@@ -25937,6 +25989,7 @@ async function runValidatedHistorianPass(args) {
     ...args,
     prompt: repairPrompt,
     dumpLabel: `${args.dumpLabelBase}-repair`,
+    modelOverride: args.model,
     agentId: args.agentId
   });
   if (!repairRun.ok || !repairRun.result) {
@@ -25977,7 +26030,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", {
@@ -26030,7 +26084,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,
@@ -26054,7 +26108,7 @@ async function runHistorianPrompt(args) {
           query: { directory: sessionDirectory },
           body: {
             agent: agentId,
-            ...modelOverride ? { model: modelOverride } : {},
+            ...modelBodyField(modelOverride),
             parts: [{ type: "text", text: prompt, synthetic: true }]
           }
         }, {
@@ -26124,10 +26178,21 @@ async function runHistorianPrompt(args) {
 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) {
@@ -26135,9 +26200,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})`);
@@ -26466,6 +26531,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,
@@ -26886,6 +26952,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,
@@ -27077,11 +27144,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"
     });
@@ -27129,7 +27196,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;
 }
@@ -27739,13 +27807,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;
@@ -27753,17 +27825,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"
     });
@@ -28277,7 +28349,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.38.1",
+  version: "0.40.0",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -28308,7 +28380,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",
@@ -28463,6 +28535,7 @@ function renderInner(s, theme, innerWidth) {
   lines.push("* Conversation includes model Reasoning; hygiene excludes it.");
   lines.push("");
   lines.push(`Counts: ${s.compartmentCount} compartments · ${s.memoryCount} memories (${s.memoryBlockCount} injected) · ${s.sessionNoteCount + s.readySmartNoteCount} notes`);
+  lines.push(`Active profile: ${s.activeProfile ?? "none"}`);
   lines.push(`Historian: ${s.historianRunning ? theme.fg("warning", "running") : theme.fg("accent", "idle")}${s.historianFailureCount > 0 ? ` · ${theme.fg("error", `last failure ${s.historianLastFailureAt ? relTime(s.historianLastFailureAt) : "unknown"}`)}` : ""}`);
   if (s.recompInFlight) {
     lines.push(`Upgrade: ${theme.fg("warning", "recomp/upgrade running…")}`);
@@ -28593,6 +28666,7 @@ ${safeStringify(tool.parameters)}`);
   const compressionBudget = contextLimit > 0 ? Math.floor(contextLimit * (Math.min(threshold.percentage, 80) / 100) * historyBudgetPercentage) : null;
   return {
     sessionId,
+    activeProfile: deps.activeProfile ?? null,
     usagePercentage,
     inputTokens,
     systemPromptTokens,
@@ -28825,7 +28899,14 @@ No active Pi session is available.`,
           backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
         }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)));
         const details = buildStatusDetails(currentDeps, sessionId);
-        sendCtxStatusMessage(pi, { title: "/ctx-status", text: statusText, level: "info" }, details);
+        const profileStatus = currentDeps.activeProfile ?? "none";
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-status",
+          text: `${statusText}
+
+Active profile: ${profileStatus}`,
+          level: "info"
+        }, details);
       } catch (error) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-status",
@@ -28849,6 +28930,7 @@ function buildStatusDetails(deps, sessionId) {
   return {
     sessionId,
     projectIdentity: deps.projectIdentity,
+    activeProfile: deps.activeProfile ?? null,
     activeTags: activeTags.length,
     droppedTags: droppedTags.length,
     totalBytes,
@@ -29627,12 +29709,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,
@@ -29640,7 +29723,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,
@@ -29966,6 +30049,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       runnable: bootProjectDeps.dreamerEnabled,
       scheduleSummary: summarizeDreamSchedule(bootProjectDeps.config.dreamer)
     },
+    activeProfile: bootProjectDeps.config.profile,
     resolveStatusDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       return {
@@ -29980,7 +30064,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         dreamer: {
           runnable: current.dreamerEnabled,
           scheduleSummary: summarizeDreamSchedule(current.config.dreamer)
-        }
+        },
+        activeProfile: current.config.profile
       };
     }
   });
@@ -30130,6 +30215,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