@cortexkit/pi-magic-context 0.41.3 → 0.41.4

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  sanitizeDiagnosticText,
   hasShareabilitySensitiveText,
   setHarness,
   getHarness,
@@ -83,6 +84,7 @@ import {
   releaseCompartmentLease,
   releaseCompartmentLeaseBestEffort,
   isCompartmentLeaseHeld,
+  canonicalModelIdentity,
   piModelRefToCanonical,
   resolveModelRefForPi,
   modelRefLookupOrder,
@@ -116,6 +118,7 @@ import {
   copySessionStateForClone,
   getErrorMessage,
   describeError,
+  piHarnessKindFromExecutable,
   setStoragePrivatePermissionEnforcement,
   getSchemaFenceRejection,
   getMigrationOnOpenRefusal,
@@ -309,7 +312,11 @@ import {
   isSaneLimit,
   resolveOutputReserve,
   getSdkContextLimit,
+  resolveModelConfigValue,
   resolveModelConfigOrDefault,
+  formatConfigParseStatusLine,
+  formatConfigParseNotice,
+  claimConfigParseFailuresOnce,
   promptSurfaceHashMaterial,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
@@ -323,6 +330,7 @@ import {
   withContentLanguageDirective,
   withMigrationLanguageDirective,
   buildPrimaryLanguageDirective,
+  resolvePiHarnessDetection,
   resolvePiHarnessKind,
   computeCueContentHash,
   hasMuralCueColumns,
@@ -437,7 +445,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-s0zw9ddk.js";
+} from "./index-jc59f2q7.js";
 import {
   pushNotification2
 } from "./index-b3eqj1g6.js";
@@ -1508,16 +1516,20 @@ function deriveHistorianChunkTokens(historianContextLimit) {
   const derived = Math.round(historianContextLimit * HISTORIAN_CHUNK_PERCENTAGE);
   return Math.max(HISTORIAN_CHUNK_MIN, Math.min(HISTORIAN_CHUNK_MAX, derived));
 }
+function resolveKnownHistorianContextLimit(historianModelOverride) {
+  if (typeof historianModelOverride !== "string" || !historianModelOverride.includes("/")) {
+    return;
+  }
+  const [providerID, ...rest] = historianModelOverride.split("/");
+  const modelID = rest.join("/");
+  if (!providerID || !modelID)
+    return;
+  const limit = getSdkContextLimit(providerID, modelID, undefined, { reservation: "none" });
+  return typeof limit === "number" && limit > 0 ? limit : undefined;
+}
 function resolveHistorianContextLimit(historianModelOverride) {
   if (typeof historianModelOverride === "string" && historianModelOverride.includes("/")) {
-    const [providerID, ...rest] = historianModelOverride.split("/");
-    const modelID = rest.join("/");
-    if (providerID && modelID) {
-      const limit = getSdkContextLimit(providerID, modelID);
-      if (typeof limit === "number" && limit > 0)
-        return limit;
-    }
-    return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
+    return resolveKnownHistorianContextLimit(historianModelOverride) ?? DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
   }
   if (typeof historianModelOverride === "string" && historianModelOverride.trim() !== "") {
     console.warn(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
@@ -1933,6 +1945,16 @@ function shouldShowAnnouncement() {
   return ordering > 0;
 }
 
+// ../plugin/src/shared/cache-ttl-seed.ts
+function seedSessionCacheTtlIfUnsynced(args) {
+  const meta = getOrCreateSessionMeta(args.db, args.sessionId);
+  if (meta.lastResponseTime !== 0 || meta.lastObservedModelKey !== null)
+    return false;
+  const cacheTtl = typeof args.configured === "string" ? args.configured : resolveModelConfigValue(args.configured, args.modelKey)?.value ?? args.configured.default ?? "5m";
+  updateSessionMeta(args.db, args.sessionId, { cacheTtl });
+  return true;
+}
+
 // ../plugin/src/shared/keep-subagents.ts
 var keepSubagents = false;
 function setKeepSubagents(value) {
@@ -2357,6 +2379,11 @@ var DEFAULT_PI_RESOLUTION_FS = {
   realpathSync: realpathSync2,
   readFileSync: readFileSync2
 };
+function packageHarnessKind(packageName) {
+  if (packageName === "@oh-my-pi/pi-coding-agent")
+    return "omp";
+  return typeof packageName === "string" && PI_CODING_AGENT_PACKAGE_NAMES.has(packageName) ? "pi" : undefined;
+}
 function readPiManifest(packageJsonPath, fs) {
   try {
     const manifest = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
@@ -2422,32 +2449,38 @@ function resolvePiBin(found, fs, checkedPaths) {
 function resolvePiCliFromPackageJson(packageJsonPath, fs, checkedPaths) {
   checkedPaths.push(packageJsonPath);
   const manifest = readPiManifest(packageJsonPath, fs);
-  if (typeof manifest?.name !== "string" || !PI_CODING_AGENT_PACKAGE_NAMES.has(manifest.name)) {
-    return null;
+  const targetHarness = packageHarnessKind(manifest?.name);
+  if (!manifest || targetHarness === undefined) {
+    return { cliPath: null, targetHarness: null, checkedPaths };
   }
-  return resolvePiBin({ dir: dirname(packageJsonPath), manifest }, fs, checkedPaths);
+  return {
+    cliPath: resolvePiBin({ dir: dirname(packageJsonPath), manifest }, fs, checkedPaths),
+    targetHarness,
+    checkedPaths
+  };
 }
 function resolvePiCliFromRunningEntry(entry, fs) {
   const checkedPaths = [entry ?? "process.argv[1] (missing)"];
   if (!entry || entry.startsWith(BUN_VIRTUAL_SCRIPT_PREFIX)) {
-    return { cliPath: null, checkedPaths };
+    return { cliPath: null, targetHarness: null, checkedPaths };
   }
   try {
     if (!fs.existsSync(entry) || !fs.statSync(entry).isFile()) {
-      return { cliPath: null, checkedPaths };
+      return { cliPath: null, targetHarness: null, checkedPaths };
     }
     const realEntry = fs.realpathSync(entry);
     if (realEntry !== entry)
       checkedPaths.push(realEntry);
     const found = findPiPackageRoot(dirname(realEntry), fs);
     if (!found)
-      return { cliPath: null, checkedPaths };
+      return { cliPath: null, targetHarness: null, checkedPaths };
     return {
       cliPath: resolvePiBin(found, fs, checkedPaths),
+      targetHarness: packageHarnessKind(found.manifest.name) ?? null,
       checkedPaths
     };
   } catch {
-    return { cliPath: null, checkedPaths };
+    return { cliPath: null, targetHarness: null, checkedPaths };
   }
 }
 function defaultResolvePiPackageJson(from) {
@@ -2464,7 +2497,7 @@ function resolveBundledPiCli(from, fs, resolvePackageJson, checkedPaths) {
   const packageJsonPath = resolvePackageJson(from);
   if (!packageJsonPath) {
     checkedPaths.push(`${PI_CODING_AGENT_MODULE}/package.json (unresolvable from running module paths)`);
-    return null;
+    return { cliPath: null, targetHarness: null, checkedPaths };
   }
   return resolvePiCliFromPackageJson(packageJsonPath, fs, checkedPaths);
 }
@@ -2519,14 +2552,26 @@ function resolvePiInvocation(options = {}) {
   const running = resolvePiCliFromRunningEntry(currentScript, fs);
   const checkedPaths = [...running.checkedPaths];
   if (running.cliPath) {
-    return { command: execPath, prefixArgs: [running.cliPath] };
+    return {
+      command: execPath,
+      prefixArgs: [running.cliPath],
+      targetHarness: running.targetHarness ?? piHarnessKindFromExecutable(running.cliPath) ?? resolvePiHarnessKind()
+    };
   }
   if (!isGenericRuntimeExecutable(execPath)) {
-    return { command: execPath, prefixArgs: [] };
+    return {
+      command: execPath,
+      prefixArgs: [],
+      targetHarness: piHarnessKindFromExecutable(execPath) ?? resolvePiHarnessKind()
+    };
   }
   const bundled = resolveBundledPiCli(currentScript, fs, resolvePackageJson, checkedPaths);
-  if (bundled) {
-    return { command: execPath, prefixArgs: [bundled] };
+  if (bundled.cliPath) {
+    return {
+      command: execPath,
+      prefixArgs: [bundled.cliPath],
+      targetHarness: bundled.targetHarness ?? piHarnessKindFromExecutable(bundled.cliPath) ?? resolvePiHarnessKind()
+    };
   }
   const detectionMiss = `script-detection miss on ${formatCheckedPaths(checkedPaths)}`;
   if (platform === "win32") {
@@ -2538,6 +2583,7 @@ function resolvePiInvocation(options = {}) {
         return {
           command,
           prefixArgs: ["/d", "/s", "/c", resolved.path],
+          targetHarness: piHarnessKindFromExecutable(resolved.path) ?? "pi",
           fallbackDiagnostic: diagnostic
         };
       }
@@ -2552,12 +2598,14 @@ function resolvePiInvocation(options = {}) {
             "-File",
             resolved.path
           ],
+          targetHarness: piHarnessKindFromExecutable(resolved.path) ?? "pi",
           fallbackDiagnostic: diagnostic
         };
       }
       return {
         command: resolved.path,
         prefixArgs: [],
+        targetHarness: piHarnessKindFromExecutable(resolved.path) ?? "pi",
         fallbackDiagnostic: diagnostic
       };
     }
@@ -2566,6 +2614,7 @@ function resolvePiInvocation(options = {}) {
   return {
     command: "pi",
     prefixArgs: [],
+    targetHarness: "pi",
     fallbackDiagnostic: `script-detection miss on ${formatCheckedPaths(checkedPaths)}`
   };
 }
@@ -2593,8 +2642,8 @@ function normalizedOmpProfile() {
   const raw = (process.env.OMP_PROFILE ?? process.env.PI_PROFILE)?.trim();
   return raw && raw !== "default" && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(raw) ? raw : undefined;
 }
-function getHostAgentSettingsDir() {
-  if (!isOmpHostProcess())
+function getHostAgentSettingsDir(targetHarness) {
+  if (targetHarness !== "omp")
     return join2(homedir(), ".pi", "agent");
   const configRoot = join2(homedir(), process.env.PI_CONFIG_DIR?.trim() || ".omp");
   const profile = normalizedOmpProfile();
@@ -2603,20 +2652,20 @@ function getHostAgentSettingsDir() {
   const configured = process.env.PI_CODING_AGENT_DIR?.trim();
   return configured ? resolvePath(configured) : join2(configRoot, "agent");
 }
-function modelRefToCanonicalForHost(ref) {
-  return isOmpHostProcess() ? ompModelRefToCanonical(ref) : piModelRefToCanonical(ref);
+function modelRefToCanonicalForTarget(ref, targetHarness) {
+  return targetHarness === "omp" ? ompModelRefToCanonical(ref) : piModelRefToCanonical(ref);
 }
-function resolveModelRefForHost(ref) {
-  return isOmpHostProcess() ? resolveModelRefForOmp(ref) : resolveModelRefForPi(ref);
+function resolveModelRefForTarget(ref, targetHarness) {
+  return targetHarness === "omp" ? resolveModelRefForOmp(ref) : resolveModelRefForPi(ref);
 }
 var configuredSubagentExtensions;
 function configurePiSubagentExtensions(extensions) {
   configuredSubagentExtensions = extensions?.slice();
 }
-function resolveSubagentExtensionEntry(entry) {
+function resolveSubagentExtensionEntry(entry, targetHarness) {
   const trimmed = entry.trim();
   const isNpmSource = trimmed.startsWith("npm:");
-  return !isNpmSource && !isAbsolute(trimmed) ? resolvePath(getHostAgentSettingsDir(), trimmed) : trimmed;
+  return !isNpmSource && !isAbsolute(trimmed) ? resolvePath(getHostAgentSettingsDir(targetHarness), trimmed) : trimmed;
 }
 var PI_READ_ONLY_BUILTINS = ["read", "grep", "find", "ls"];
 var PI_AFT_READ_TOOLS = ["aft_outline", "aft_zoom", "aft_search"];
@@ -2722,14 +2771,18 @@ class PiSubagentRunner {
   extraArgs;
   subagentExtensions;
   constructor(options = {}) {
-    this.invocation = options.invocation ?? (options.piBinary ? { command: options.piBinary, prefixArgs: [] } : resolvePiInvocation({ platform: options.platform }));
+    this.invocation = options.invocation ?? (options.piBinary ? {
+      command: options.piBinary,
+      prefixArgs: [],
+      targetHarness: piHarnessKindFromExecutable(options.piBinary) ?? resolvePiHarnessKind()
+    } : resolvePiInvocation({ platform: options.platform }));
     this.spawnImpl = options.spawnImpl ?? childProcess.spawn;
     this.platform = options.platform ?? process.platform;
     this.extraArgs = options.extraArgs ?? [];
     this.subagentExtensions = options.subagentExtensions ?? configuredSubagentExtensions;
   }
   async run(options) {
-    const providerAttempt = resolveProviderModelAttempt(options.model);
+    const providerAttempt = resolveProviderModelAttempt(options.model, this.invocation.targetHarness);
     const firstOptions = providerAttempt ? { ...options, model: providerAttempt.canonicalRef } : options;
     const firstRun = await this.runWithExtensionRetry(firstOptions, providerAttempt?.modelRef);
     if (!providerAttempt)
@@ -2903,6 +2956,7 @@ class PiSubagentRunner {
       }
     }
     const args = buildArgs(options, {
+      targetHarness: this.invocation.targetHarness,
       disableDiscoveredExtensions: runMode.disableDiscoveredExtensions,
       subagentExtensions: this.subagentExtensions,
       omitPositionalMessage: deliverViaStdin,
@@ -3284,14 +3338,14 @@ function replaceProviderPrefix(ref, provider) {
   const slash = ref.indexOf("/");
   return slash > 0 ? `${provider}${ref.slice(slash)}` : ref;
 }
-function resolveProviderModelAttempt(model) {
+function resolveProviderModelAttempt(model, targetHarness) {
   if (typeof model !== "string" || model.length === 0)
     return;
-  const canonicalRef = modelRefToCanonicalForHost(model);
+  const canonicalRef = modelRefToCanonicalForTarget(model, targetHarness);
   const canonicalProvider = providerPrefix(canonicalRef);
   if (!canonicalProvider)
     return;
-  const translatedRef = resolveModelRefForHost(canonicalRef);
+  const translatedRef = resolveModelRefForTarget(canonicalRef, targetHarness);
   const translatedProvider = providerPrefix(translatedRef);
   const cachedProvider = PI_PROVIDER_FORM_CACHE.get(canonicalProvider);
   if (!translatedProvider || translatedProvider === canonicalProvider && cachedProvider === undefined) {
@@ -3311,21 +3365,22 @@ function isProviderCredentialFailure(result, attempt) {
 }
 var PROMPT_ARGV_MAX_BYTES = 96 * 1024;
 function buildArgs(options, opts) {
-  const ompHost = isOmpHostProcess();
+  const targetHarness = opts?.targetHarness ?? resolvePiHarnessKind();
+  const ompTarget = targetHarness === "omp";
   const args = [
     "--print",
     "--mode",
     "json",
     "--no-session",
     "--no-skills",
-    ...ompHost ? ["--no-rules"] : ["--no-prompt-templates", "--no-context-files"]
+    ...ompTarget ? ["--no-rules"] : ["--no-prompt-templates", "--no-context-files"]
   ];
   if (opts?.disableDiscoveredExtensions || opts?.subagentExtensions !== undefined) {
     args.push("--no-extensions");
   }
   if (opts?.subagentExtensions !== undefined) {
     for (const extension of opts.subagentExtensions) {
-      args.push("--extension", resolveSubagentExtensionEntry(extension));
+      args.push("--extension", resolveSubagentExtensionEntry(extension, targetHarness));
     }
   }
   const subagentEntryPath = opts?.subagentEntryPath ?? SUBAGENT_ENTRY_PATH;
@@ -3345,7 +3400,7 @@ function buildArgs(options, opts) {
     sessionLog(options.accountingSessionId ?? "pi-subagent", `Pi subagent agent "${options.agent}" has no strict tool allow-list; forcing --no-tools`);
     args.push("--no-tools");
   } else {
-    const hostTools = resolveHostToolAllowlist(strictTools, ompHost);
+    const hostTools = resolveHostToolAllowlist(strictTools, ompTarget);
     if (hostTools.length > 0) {
       args.push("--tools", hostTools.join(","));
     } else {
@@ -3356,7 +3411,7 @@ function buildArgs(options, opts) {
     args.push("--system-prompt", opts.systemPromptPath);
   }
   if (typeof options.model === "string" && options.model.length > 0) {
-    args.push("--model", opts?.modelRef ?? resolveModelRefForHost(options.model));
+    args.push("--model", opts?.modelRef ?? resolveModelRefForTarget(options.model, targetHarness));
   }
   if (options.thinkingLevel) {
     args.push("--thinking", options.thinkingLevel);
@@ -4301,6 +4356,10 @@ var ABORT_CALL_TIMEOUT_MS = 3000;
 function copyPromptArgs(args, body) {
   return { ...args, body: { ...body } };
 }
+var promptFailureDetails = new WeakMap;
+function getPromptFailureDetail(error) {
+  return error !== null && typeof error === "object" ? promptFailureDetails.get(error) ?? null : null;
+}
 function extractMessage(error) {
   if (typeof error === "string")
     return error;
@@ -4413,6 +4472,39 @@ function shortErr(error) {
   }
   return extractMessage(error);
 }
+function classifyPromptFailure(error, phase, externalSignal) {
+  const message = extractMessage(error);
+  if (externalSignal?.aborted || message === "prompt aborted by external signal") {
+    return "child_aborted";
+  }
+  if (/^prompt timed out after \d+ms$/.test(message))
+    return "provider_timeout";
+  if (phase === "validation") {
+    if (/returned no (?:assistant )?output|no assistant output/i.test(message)) {
+      return "empty_completion";
+    }
+    if (error instanceof Error && error.name === "DreamerProviderOutputFailureError") {
+      return "provider_error";
+    }
+    return "parse_failed";
+  }
+  return phase === "prompt" || phase === "output" ? "provider_error" : "unknown";
+}
+function throwWithPromptFailure(legacyError, failedAttempts, args, timeoutMs) {
+  const error = legacyError instanceof Error ? legacyError : new Error(extractMessage(legacyError));
+  const last = failedAttempts.at(-1);
+  const failureClass = last?.failureClass ?? "unknown";
+  const providerError = failureClass === "provider_error" ? sanitizeDiagnosticText(shortErr(last?.error ?? legacyError)).slice(0, 500) : null;
+  promptFailureDetails.set(error, {
+    failureClass,
+    modelAttempted: last?.attempt.label ?? null,
+    modelsTried: failedAttempts.map((failure) => failure.attempt.label),
+    providerError,
+    timeoutMs: failureClass === "provider_timeout" ? timeoutMs : null,
+    childSessionId: args.path.id || null
+  });
+  throw error;
+}
 async function attemptOnce(client, args, timeoutMs, signal, callContext, label) {
   const originalBody = { ...args.body };
   const attemptArgs = copyPromptArgs(args, originalBody);
@@ -4491,10 +4583,35 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
   throw lastError ?? new Error("All fallback models failed");
 }
 async function attemptAndValidate(client, args, timeoutMs, signal, callContext, attempt, options) {
-  await attemptOnce(client, args, timeoutMs, signal, callContext, attempt.label);
-  const output = await options.fetchOutput(args, attempt);
-  const validated = await options.validateOutput(output, attempt);
-  return { output, validated, attempt };
+  try {
+    await attemptOnce(client, args, timeoutMs, signal, callContext, attempt.label);
+  } catch (error) {
+    throw {
+      error,
+      failureClass: classifyPromptFailure(error, "prompt", signal),
+      attempt
+    };
+  }
+  let output;
+  try {
+    output = await options.fetchOutput(args, attempt);
+  } catch (error) {
+    throw {
+      error,
+      failureClass: classifyPromptFailure(error, "output", signal),
+      attempt
+    };
+  }
+  try {
+    const validated = await options.validateOutput(output, attempt);
+    return { output, validated, attempt };
+  } catch (error) {
+    throw {
+      error,
+      failureClass: classifyPromptFailure(error, "validation", signal),
+      attempt
+    };
+  }
 }
 async function promptSyncWithValidatedOutputRetry(client, args, options) {
   const timeoutMs = options.timeoutMs ?? 300000;
@@ -4504,6 +4621,7 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
   const baseArgs = copyPromptArgs(args, baseBody);
   const explicitPrimaryLabel = baseBody.model?.providerID && baseBody.model.modelID ? `${baseBody.model.providerID}/${baseBody.model.modelID}` : "primary";
   const totalAttempts = fallbacks.length + 1;
+  const failedAttempts = [];
   let firstError = null;
   let lastError = null;
   try {
@@ -4514,15 +4632,18 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
       totalAttempts,
       model: baseBody.model
     }, options);
-  } catch (error) {
-    firstError = error;
-    lastError = error;
-    if (isNonRetryable(error, options.signal))
-      throw error;
+  } catch (caught) {
+    const failure = caught;
+    failedAttempts.push(failure);
+    firstError = failure.error;
+    lastError = failure.error;
+    if (isNonRetryable(failure.error, options.signal)) {
+      throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
+    }
     if (fallbacks.length === 0) {
-      throw error;
+      throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
     }
-    log(`[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(error)}; trying ${fallbacks.length} fallback(s)`);
+    log(`[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`);
   }
   for (let i = 0;i < fallbacks.length; i += 1) {
     const fallback = toModelEntry(fallbacks[i]);
@@ -4549,20 +4670,21 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
       const result = await attemptAndValidate(client, attemptArgs, timeoutMs, options.signal, callContext, attempt, options);
       log(`[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`);
       return result;
-    } catch (error) {
-      if (firstError === null)
-        firstError = error;
-      lastError = error;
-      if (isNonRetryable(error, options.signal))
-        throw error;
+    } catch (caught) {
+      const failure = caught;
+      failedAttempts.push(failure);
+      lastError = failure.error;
+      if (isNonRetryable(failure.error, options.signal)) {
+        throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
+      }
       const remaining = fallbacks.length - i - 1;
       if (remaining > 0) {
-        log(`[${callContext}] ${label} failed validation/prompt: ${shortErr(error)}; ${remaining} fallback(s) left`);
+        log(`[${callContext}] ${label} failed validation/prompt: ${shortErr(failure.error)}; ${remaining} fallback(s) left`);
       }
     }
   }
-  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");
+  log(`[${callContext}] all models exhausted; tried: ${failedAttempts.map((failure) => failure.attempt.label).join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`);
+  throwWithPromptFailure(firstError ?? lastError ?? new Error("All fallback models failed validation"), failedAttempts, args, timeoutMs);
 }
 // ../plugin/src/shared/normalize-sdk-response.ts
 function normalizeSDKResponse(response, fallback, options) {
@@ -6401,7 +6523,7 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
     const desc = describeError(failure);
     log(`[dreamer] classify chunk failed: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation(args, startedAt, { status: "failed", error: failure });
-    if (moduleRoute || signal.aborted || failure instanceof DreamerProviderOutputFailureError)
+    if (moduleRoute || signal.aborted || failure instanceof DreamerProviderOutputFailureError || getPromptFailureDetail(failure)?.failureClass !== "parse_failed" && getPromptFailureDetail(failure) !== null)
       throw failure;
     return { classified: 0, changed: 0 };
   } finally {
@@ -9702,6 +9824,16 @@ function parseJsonRecord(value) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/storage-dream-runs.ts
+function formatDreamRunFailure(failure) {
+  const parts = [failure.failure_class];
+  if (failure.model_attempted)
+    parts.push(`model: ${failure.model_attempted}`);
+  if (failure.provider_error)
+    parts.push(failure.provider_error.split(/\r?\n/, 1)[0].trim());
+  else if (failure.timeout_ms !== null)
+    parts.push(`timeout: ${failure.timeout_ms}ms`);
+  return parts.join(" · ");
+}
 var insertDreamRunStatements = new WeakMap;
 var getDreamRunsByProjectStatements = new Map;
 function getInsertDreamRunStatement(db) {
@@ -10111,9 +10243,10 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
+    const promptFailure = getPromptFailureDetail(error);
     log(`[dreamer] verify batch ${providerFailure ? "provider failure" : "failed"}: ${desc.brief}`, desc.stackHead ? { stackHead: desc.stackHead } : undefined);
     recordInvocation4(args, startedAt, { status: "failed", error });
-    if (error instanceof DreamerModuleFailureError || signal.aborted)
+    if (error instanceof DreamerModuleFailureError || signal.aborted || promptFailure !== null && promptFailure.failureClass !== "parse_failed" && !providerFailure)
       throw error;
     return {
       verified: 0,
@@ -10337,6 +10470,30 @@ function recordInvocation4(args, startedAt, params) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-executor.ts
+function dreamRunFailureDetail(error) {
+  const prompt = getPromptFailureDetail(error);
+  if (prompt) {
+    return {
+      failure_class: prompt.failureClass,
+      model_attempted: prompt.modelAttempted,
+      models_tried: prompt.modelsTried,
+      provider_error: prompt.providerError,
+      timeout_ms: prompt.timeoutMs,
+      child_session_id: prompt.childSessionId
+    };
+  }
+  const described = describeError(error);
+  const message = described.brief;
+  const providerFailure = error instanceof Error && error.name === "DreamerProviderOutputFailureError";
+  return {
+    failure_class: providerFailure ? "provider_error" : /no models?|model chain is empty/i.test(message) ? "no_models" : "unknown",
+    model_attempted: null,
+    models_tried: [],
+    provider_error: providerFailure ? sanitizeDiagnosticText(message).slice(0, 500) : null,
+    timeout_ms: null,
+    child_session_id: null
+  };
+}
 function classifyFailure(error) {
   const described = describeError(error);
   const brief = described.brief;
@@ -10453,6 +10610,9 @@ function createDreamTaskExecutor(deps) {
               durationMs: Date.now() - startedAt,
               resultChars: 0,
               ...status === "failed" && error ? { error } : {},
+              ...status === "failed" ? {
+                failure: extra?.failure ?? dreamRunFailureDetail(error ?? "unknown dreamer failure")
+              } : {},
               ...extra?.progress ? { progress: extra.progress } : {},
               backlog: (() => {
                 const end = extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task);
@@ -10753,9 +10913,15 @@ function createDreamTaskExecutor(deps) {
       });
     } catch (error) {
       const { transient, brief } = classifyFailure(error);
-      recordRun("failed", brief);
+      const failure = dreamRunFailureDetail(error);
+      recordRun("failed", brief, { failure });
       log(`[dreamer] task ${config.task} failed (transient=${transient}): ${brief}`);
-      return { status: "failed", transient, error: brief };
+      return {
+        status: "failed",
+        transient,
+        error: brief,
+        failureDetail: formatDreamRunFailure(failure)
+      };
     } finally {
       deps.onProgress?.(null, config.task);
     }
@@ -11292,10 +11458,10 @@ async function runDomainGroup(deps, group, cb) {
         cb?.onRan?.(due.config.task);
       } else if (outcome.transient) {
         recordTransientFailure(db, projectIdentity, due, finishedAt, outcome.error ?? null);
-        cb?.onFailed?.(due.config.task, outcome.error);
+        cb?.onFailed?.(due.config.task, outcome.failureDetail ?? outcome.error);
       } else {
         advanceAfterRun(db, projectIdentity, due, finishedAt, "failed", outcome.error ?? null);
-        cb?.onFailed?.(due.config.task, outcome.error);
+        cb?.onFailed?.(due.config.task, outcome.failureDetail ?? outcome.error);
       }
     }
   } finally {
@@ -14371,6 +14537,16 @@ function rearmChannel2AfterMeasuredCollapse(input) {
 }
 
 // ../plugin/src/hooks/magic-context/protected-tail-boundary.ts
+function describeBoundaryDiagnostics(snapshot) {
+  return `boundaryDiagnostics=${JSON.stringify(snapshot.diagnostics ?? { unavailable: true, boundaryReason: snapshot.boundaryReason })}`;
+}
+function boundaryDiagnostics(args) {
+  return {
+    ...args,
+    capTier: args.usagePercentage >= 95 ? "95" : args.usagePercentage >= 80 ? "80" : "normal",
+    drainBudget: "not-reserved; does-not-size-cap"
+  };
+}
 var ALPHA = 0.3;
 var FLOOR_RATIO = 0.08;
 var FLOOR_MIN = 2000;
@@ -14510,11 +14686,40 @@ function applyHeadCap(args) {
     capTokens,
     recentOpenArcCutoff
   } = args;
-  if (offset >= protectedTailStart)
+  const diagnostics = {
+    offset,
+    capEnd: offset,
+    capTokenSum: 0,
+    completedFence: { from: offset, to: offset, arcs: [], tokenMass: 0 },
+    oversizeAdmission: { from: offset, to: offset },
+    openArcClamp: { from: offset, to: offset },
+    completedRefence: { from: offset, to: offset, arcs: [], tokenMass: 0 },
+    eligibleEnd: offset
+  };
+  if (offset >= protectedTailStart) {
+    args.observeDiagnostics?.(diagnostics);
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit: false };
+  }
   let end = index.findHeadEndForCap(offset, protectedTailStart, capTokens);
+  diagnostics.capEnd = end;
+  diagnostics.capTokenSum = index.rangeTokens(offset, end);
   let oversizeAtomicUnit = end === offset + 1 && index.tokenForOrdinal(offset) > capTokens;
-  const completedFence = fenceBoundaryForCompletedToolArcs(end, arcs, lastCompartmentEndOrdinal + 1);
+  let completedFence = fenceBoundaryForCompletedToolArcs(end, arcs, lastCompartmentEndOrdinal + 1, (component) => {
+    diagnostics.completedFence.arcs = component.map((arc) => ({
+      assistant: arc.invocation,
+      result: arc.result
+    }));
+    diagnostics.completedFence.tokenMass = index.rangeTokens(Math.min(...component.map((arc) => arc.invocation)), Math.max(...component.map((arc) => arc.result)) + 1);
+  });
+  diagnostics.completedFence.from = end;
+  diagnostics.completedFence.to = completedFence;
+  diagnostics.oversizeAdmission.from = completedFence;
+  if (completedFence <= offset && end > offset) {
+    const afterFirstArc = fenceBoundaryForCompletedToolArcs(end, arcs, offset + 1);
+    if (afterFirstArc <= protectedTailStart)
+      completedFence = afterFirstArc;
+  }
+  diagnostics.oversizeAdmission.to = completedFence;
   if (completedFence > end) {
     end = Math.min(protectedTailStart, completedFence);
     if (index.rangeTokens(offset, end) > capTokens)
@@ -14522,6 +14727,7 @@ function applyHeadCap(args) {
   } else {
     end = completedFence;
   }
+  diagnostics.openArcClamp.from = end;
   for (const arc of arcs) {
     const resOrdinal = arc.resOrdinal;
     if (resOrdinal === null) {
@@ -14530,6 +14736,18 @@ function applyHeadCap(args) {
       }
     }
   }
+  diagnostics.openArcClamp.to = end;
+  diagnostics.completedRefence.from = end;
+  end = fenceBoundaryForCompletedToolArcs(end, arcs, lastCompartmentEndOrdinal + 1, (component) => {
+    diagnostics.completedRefence.arcs = component.map((arc) => ({
+      assistant: arc.invocation,
+      result: arc.result
+    }));
+    diagnostics.completedRefence.tokenMass = index.rangeTokens(Math.min(...component.map((arc) => arc.invocation)), Math.max(...component.map((arc) => arc.result)) + 1);
+  });
+  diagnostics.completedRefence.to = end;
+  diagnostics.eligibleEnd = end <= offset ? offset : Math.min(end, protectedTailStart);
+  args.observeDiagnostics?.(diagnostics);
   if (end <= offset && offset < protectedTailStart) {
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit };
   }
@@ -14658,6 +14876,11 @@ function resolveProtectedTailBoundary(ctx) {
     runtimeFloor = Math.max(runtimeFloor, ctx.priorBoundaryOrdinal);
   let protectedTailStart = Math.max(boundary, runtimeFloor);
   const forceMaterializationPercentage = escalationBands(ctx.executeThresholdPercentage).forceMaterializationPercentage;
+  const livePromptFloor = {
+    ordinal: null,
+    from: protectedTailStart,
+    to: protectedTailStart
+  };
   if (!ctx.emergencyTailScale && usagePercentage < forceMaterializationPercentage) {
     let lastMeaningfulUserOrdinal = 0;
     for (let i = messages.length - 1;i >= 0; i--) {
@@ -14669,10 +14892,12 @@ function resolveProtectedTailBoundary(ctx) {
       lastMeaningfulUserOrdinal = message.ordinal;
       break;
     }
+    livePromptFloor.ordinal = lastMeaningfulUserOrdinal || null;
     if (lastMeaningfulUserOrdinal >= offset) {
       protectedTailStart = Math.min(protectedTailStart, lastMeaningfulUserOrdinal);
     }
   }
+  livePromptFloor.to = protectedTailStart;
   if (protectedTailStart > offset && index.rangeTokens(offset, protectedTailStart) <= NORMAL_HYSTERESIS_TOKENS) {
     protectedTailStart = offset;
   }
@@ -14683,7 +14908,11 @@ function resolveProtectedTailBoundary(ctx) {
     contextLimit: ctx.contextLimit,
     executeThresholdPercentage: ctx.executeThresholdPercentage
   });
+  let headDiagnostics;
   const head = applyHeadCap({
+    observeDiagnostics: (value) => {
+      headDiagnostics = value;
+    },
     index,
     protectedTailStart,
     offset,
@@ -14720,7 +14949,19 @@ function resolveProtectedTailBoundary(ctx) {
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, protectedTailStart),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
-    boundaryReason
+    boundaryReason,
+    diagnostics: boundaryDiagnostics({
+      tailTarget: target,
+      usable: target.usable,
+      usagePercentage,
+      N: scaledN,
+      triggerBudget: ctx.triggerBudget,
+      capTokens: perRunCap,
+      sizeWalkStart: recentOpenArcCutoff,
+      protectedTailStart,
+      livePromptFloor,
+      head: headDiagnostics
+    })
   };
 }
 function resolveBoundaryContext(args) {
@@ -14836,7 +15077,11 @@ function resolveWrapupProtectedTailBoundary(args) {
     contextLimit: ctx.contextLimit,
     executeThresholdPercentage: ctx.executeThresholdPercentage
   });
+  let headDiagnostics;
   const head = applyHeadCap({
+    observeDiagnostics: (value) => {
+      headDiagnostics = value;
+    },
     index,
     protectedTailStart: targetProtectedTailStart,
     offset,
@@ -14874,7 +15119,23 @@ function resolveWrapupProtectedTailBoundary(args) {
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, targetProtectedTailStart),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
-    boundaryReason
+    boundaryReason,
+    diagnostics: boundaryDiagnostics({
+      tailTarget: target,
+      usable: target.usable,
+      usagePercentage,
+      N: target.N,
+      triggerBudget: ctx.triggerBudget,
+      capTokens: perRunCap,
+      sizeWalkStart: Math.max(offset, anchorRawMessageCount - keep + 1),
+      protectedTailStart: targetProtectedTailStart,
+      livePromptFloor: {
+        ordinal: null,
+        from: targetProtectedTailStart,
+        to: targetProtectedTailStart
+      },
+      head: headDiagnostics
+    })
   };
   return {
     snapshot,
@@ -14974,6 +15235,27 @@ function recordHighPressureNoEligibleHead(db, snapshot) {
 function modelAcceptsEmptyContent(providerID) {
   return providerID === "anthropic";
 }
+var VARIANT_CACHE_PRESERVING_MODELS = {
+  "anthropic/claude-fable-5-1": "2026-09-02",
+  "openai/gpt-6-astra": "2026-09-05"
+};
+function canonicalVariantModelIdentity(providerID, modelID) {
+  const normalizedProviderID = providerID.toLowerCase();
+  const isAnthropicFamily = normalizedProviderID === "anthropic" || normalizedProviderID === "google-vertex-anthropic" || normalizedProviderID.includes("bedrock");
+  if (isAnthropicFamily && isFable51ThinkingBindingModel("anthropic", modelID)) {
+    return "anthropic/claude-fable-5-1";
+  }
+  return canonicalModelIdentity(`${providerID}/${modelID}`).toLowerCase();
+}
+function variantChangeBustsProviderCache(providerID, modelID) {
+  if (!providerID || !modelID)
+    return false;
+  const identity = canonicalVariantModelIdentity(providerID, modelID);
+  if (Object.hasOwn(VARIANT_CACHE_PRESERVING_MODELS, identity))
+    return false;
+  const normalizedProviderID = providerID.toLowerCase();
+  return normalizedProviderID === "anthropic" || normalizedProviderID === "google-vertex-anthropic" || normalizedProviderID.includes("bedrock");
+}
 
 // ../plugin/src/hooks/magic-context/compartment-trigger.ts
 var PROACTIVE_TRIGGER_OFFSET_PERCENTAGE = 2;
@@ -15451,6 +15733,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
     let textOrdinal = 0;
     let toolResultOrdinal = 0;
     const parts = message.parts;
+    const messageHasNativeReasoning = message.info.role === "assistant" && parts.some((part) => part.kind === "thinking");
     const contentDerivedTextIds = messageId !== undefined && options.textIdentityDriftMessageIds?.has(messageId) === true ? buildContentDerivedTextIds(messageId, parts) : undefined;
     for (let partIndex = 0;partIndex < parts.length; partIndex += 1) {
       const part = parts[partIndex];
@@ -15525,6 +15808,7 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
         const existing = toolAggregates.get(aggregateKey);
         if (existing) {
           existing.occurrences.push({ message, part, kind: part.kind });
+          existing.requiresToolArcSkeleton ||= messageHasNativeReasoning;
           const canReuseIdentity = reuseIdentity && existing.identityReusable;
           let text = "";
           if (canReuseIdentity) {
@@ -15606,7 +15890,8 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             maxTokenCount: reusableAccounting.tokenCount ?? 0,
             toolName: null,
             inputByteSize: reusableAccounting.inputByteSize,
-            inputTokenCount: reusableAccounting.inputTokenCount
+            inputTokenCount: reusableAccounting.inputTokenCount,
+            requiresToolArcSkeleton: messageHasNativeReasoning
           };
           if (part.kind === "tool_result") {
             text = part.getText() ?? "";
@@ -15646,7 +15931,8 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
             maxTokenCount: persistedAccounting?.tokenCount ?? outputTokenCount,
             toolName: accounting.toolName,
             inputByteSize: persistedAccounting?.inputByteSize ?? (part.kind === "tool_use" ? accounting.inputByteSize : 0),
-            inputTokenCount: persistedAccounting?.inputTokenCount ?? (part.kind === "tool_use" ? firstInputTokenCount : null)
+            inputTokenCount: persistedAccounting?.inputTokenCount ?? (part.kind === "tool_use" ? firstInputTokenCount : null),
+            requiresToolArcSkeleton: messageHasNativeReasoning
           };
           if (part.kind === "tool_result") {
             applyGrownToolResultAccounting({
@@ -15748,7 +16034,7 @@ function applyToolPrefixAndTarget(args) {
       args.timing.prefix += performance.now() - prefixStart;
   }
   const targetStart = args.timing ? performance.now() : 0;
-  args.targets.set(args.tagId, buildAggregateTarget(args.tagId, args.aggregate.occurrences));
+  args.targets.set(args.tagId, buildAggregateTarget(args.tagId, args.aggregate.occurrences, args.aggregate.requiresToolArcSkeleton));
   if (args.timing)
     args.timing.targets += performance.now() - targetStart;
 }
@@ -15936,7 +16222,7 @@ function setToolContentOrText(part, content) {
   } catch {}
   return part.setText(content);
 }
-function buildAggregateTarget(tagId, occurrences) {
+function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton) {
   const role = occurrences[0]?.message.info.role ?? "user";
   const messageId = occurrences[0]?.message.info.id;
   return {
@@ -15997,6 +16283,7 @@ function buildAggregateTarget(tagId, occurrences) {
     canDrop() {
       return occurrences.length > 0;
     },
+    requiresToolArcSkeleton,
     readInput() {
       for (const occ of occurrences) {
         const input = occ.part.getToolInput?.();
@@ -17635,6 +17922,20 @@ function getReducedRecompTokenBudget(currentBudget) {
   return reducedBudget < currentBudget ? reducedBudget : null;
 }
 
+// ../plugin/src/hooks/magic-context/producer-window-guard.ts
+var PRODUCER_WINDOW_REFUSAL_MARGIN = 0.15;
+function producerWindowFailureReason(input) {
+  const { producerSourceTokens, contextLimitTokens, maxOutputTokens } = input;
+  if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0 || !Number.isFinite(producerSourceTokens) || producerSourceTokens <= 0 || !Number.isFinite(maxOutputTokens) || maxOutputTokens < 0) {
+    return null;
+  }
+  const usableInputTokens = Math.max(0, Math.floor(contextLimitTokens - maxOutputTokens));
+  const refusalThreshold = usableInputTokens * (1 + PRODUCER_WINDOW_REFUSAL_MARGIN);
+  if (producerSourceTokens < refusalThreshold)
+    return null;
+  return `producer_source_exceeds_window producer_source_tokens=${Math.round(producerSourceTokens)} usable_input_tokens=${usableInputTokens} context_limit_tokens=${Math.round(contextLimitTokens)} max_output_tokens=${Math.round(maxOutputTokens)} refusal_margin=${PRODUCER_WINDOW_REFUSAL_MARGIN}`;
+}
+
 // ../plugin/src/hooks/magic-context/reference-seeds.generated.ts
 var REFERENCE_SEEDS = [
   {
@@ -19601,6 +19902,7 @@ async function runPiHistorian(deps) {
     fallbackModels,
     fallbackModelId,
     historianChunkTokens,
+    historianContextLimit,
     boundarySnapshot: providedBoundarySnapshot,
     refreshBoundarySnapshot,
     currentContextLimit,
@@ -19696,7 +19998,7 @@ async function runPiHistorian(deps) {
       const protectedTailStart = boundarySnapshot.protectedTailStart;
       const eligibleEndOrdinal = Math.min(boundarySnapshot.eligibleEndOrdinal, protectedTailStart);
       if (protectedTailStart <= offset || eligibleEndOrdinal <= offset) {
-        sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} eligibleEnd=${eligibleEndOrdinal} <= offset=${offset} — nothing to compact`);
+        sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} eligibleEnd=${eligibleEndOrdinal} <= offset=${offset} — nothing to compact; ${describeBoundaryDiagnostics(boundarySnapshot)}`);
         if (boundarySnapshot.usagePercentage < 80) {
           if (!isWrapupInProgress(db, sessionId))
             clearEmergencyRecovery(db, sessionId);
@@ -19767,7 +20069,23 @@ async function runPiHistorian(deps) {
         chunkStart: chunk.startIndex,
         sessionCompartments: priorCompartments
       });
-      const chunkText = truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
+      const chunkText = chunk.oversizeAtomicUnit ? chunk.text : truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
+      const producerSourceTokens = estimateTokens(chunkText);
+      if (boundarySnapshot.oversizeAtomicUnit || chunk.oversizeAtomicUnit) {
+        sessionLog(sessionId, `historian oversize admission: range=${chunk.startIndex}-${chunk.endIndex} rawComponentTokens=${boundarySnapshot.diagnostics?.head.completedFence.tokenMass ?? "unknown"} perRunCap=${perRunCap} producerSourceTokens=${producerSourceTokens} historianChunkTokens=${historianChunkTokens}; ${describeBoundaryDiagnostics(boundarySnapshot)}`);
+      }
+      const producerWindowFailure = producerWindowFailureReason({
+        producerSourceTokens,
+        contextLimitTokens: historianContextLimit,
+        maxOutputTokens
+      });
+      if (producerWindowFailure) {
+        telemetry.failureReason = producerWindowFailure;
+        retainDrainReservationForRetryThrottle = true;
+        incrementHistorianFailure(db, sessionId, producerWindowFailure);
+        sessionLog(sessionId, `historian oversize admission refused before spawn: ${producerWindowFailure}`);
+        return;
+      }
       if (chunkText !== chunk.text) {
         sessionLog(sessionId, `historian pre-flight: truncated formatted input for ${chunk.startIndex}-${chunk.endIndex} to fit ${historianChunkTokens} tokens`);
       }
@@ -20530,6 +20848,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
       protectedTags: config.protectedTags,
       currentTotalInputTokens: emergency.currentTotalInputTokens,
       ceilingTokens: emergency.ceilingTokens,
+      usagePercentage: emergency.usagePercentage,
       priorInputSample,
       hasPriorDrop: priorInputSample > 0
     });
@@ -20543,11 +20862,13 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           if (tag.status !== "active" || tag.type !== "tool")
             continue;
           const target = targets.get(tag.tagNumber);
-          const recent = newestEmergencyTags.has(tag.tagNumber);
-          const result = recent ? target?.truncate?.() ?? target?.drop?.() ?? "absent" : target?.drop?.() ?? "absent";
+          const recent = (emergency.usagePercentage ?? 0) < 95 && newestEmergencyTags.has(tag.tagNumber);
+          const reasoningSafeSkeleton = target?.requiresToolArcSkeleton === true;
+          const skeleton = recent || reasoningSafeSkeleton;
+          const result = reasoningSafeSkeleton ? target?.truncate?.() ?? "absent" : recent ? target?.truncate?.() ?? target?.drop?.() ?? "absent" : target?.drop?.() ?? "absent";
           if (result === "removed" || result === "truncated") {
             updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-            updateTagDropMode(db, sessionId, tag.tagNumber, recent ? "truncated" : "full");
+            updateTagDropMode(db, sessionId, tag.tagNumber, skeleton ? "truncated" : "full");
             droppedTools++;
             emergencyDroppedTools++;
           }
@@ -20557,7 +20878,9 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     } else {
       sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
     }
-    setEmergencyDropSample(db, sessionId, emergency.currentTotalInputTokens);
+    if (emergencyDroppedTools > 0) {
+      setEmergencyDropSample(db, sessionId, emergency.currentTotalInputTokens);
+    }
   }
   const staleReduce = routine && config.staleReduceStripEnabled ? collectStaleReduceCallIds(piMessages, buildMessageIdToMaxTagFromTargets(targets), buildCtxReduceTagNumbers(tags), toolAgeCutoff, resolveStableId) : { composite: new Set, bareCallIds: new Set };
   if (routine && config.staleReduceStripEnabled && (staleReduce.composite.size > 0 || staleReduce.bareCallIds.size > 0)) {
@@ -25535,6 +25858,7 @@ var afterFallbackAdoptionForTests;
 var pendingDecisionLogObserverForTests;
 var mutationGateObserverForTests;
 var lkgRecoveryLogObserverForTests;
+var variantChangeLogObserverForTests;
 function logPiLkgRecovery(sessionId, message) {
   lkgRecoveryLogObserverForTests?.(message);
   sessionLog(sessionId, message);
@@ -25644,6 +25968,9 @@ function logTransformTiming(sessionId, stage, start, extra) {
   recordPiTransformTiming({ sessionId, stage, elapsedMs, extra });
   sessionLog(sessionId, `transform stage: stage=${stage} elapsed=${elapsed}ms${suffix}`);
 }
+function piVariantChangeBustsProviderCache(providerID, modelID) {
+  return variantChangeBustsProviderCache(providerID, modelID);
+}
 function resolvePiContextModelKey(ctx) {
   const model = ctx.model;
   if (!model)
@@ -26287,6 +26614,26 @@ function registerPiContextHandler(pi, baseOptions) {
     }
     return s;
   };
+  pi.on("thinking_level_select", async (event, ctx) => {
+    if (event.previousLevel === event.level)
+      return;
+    const sessionId = resolveSessionId2(ctx);
+    if (!sessionId)
+      return;
+    const providerID = ctx.model?.provider;
+    const modelID = ctx.model?.id;
+    if (piVariantChangeBustsProviderCache(providerID, modelID)) {
+      sessionLog(sessionId, `variant changed (${event.previousLevel} -> ${event.level}), triggering flush`);
+      historyRefreshSessions.add(sessionId);
+      systemPromptRefreshSessions.add(sessionId);
+      pendingMaterializationSessions.add(sessionId);
+      lastHeuristicsTurnIdBySession.delete(sessionId);
+      return;
+    }
+    const message = `variant changed (${event.previousLevel} -> ${event.level}) on ${providerID ?? "unknown"}/${modelID ?? "unknown"} without a proven natural cache bust; deferring flush to next natural bust`;
+    variantChangeLogObserverForTests?.(message);
+    sessionLog(sessionId, message);
+  });
   pi.on("context", async (event, ctx) => {
     const transformStartTime = performance.now();
     let rawMessageCount = 0;
@@ -26593,7 +26940,7 @@ function registerPiContextHandler(pi, baseOptions) {
         if (now - lastNotifiedAt >= EMERGENCY_NOTIFICATION_COOLDOWN_MS) {
           lastEmergencyNotificationAtMs.set(sessionId, now);
           sendPiIgnoredNotification(ctx, "Context full — /ctx-flush or /clear to continue.");
-          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, awaiting in-flight historian + applying drop-all-tools`);
+          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, awaiting in-flight historian + evaluating tiered emergency reclaim`);
         }
         const histPromise = inFlightHistorian.get(sessionId);
         if (histPromise) {
@@ -27077,6 +27424,7 @@ function spawnPiHistorianRun(args) {
         fallbackModels: historian.fallbackModels,
         fallbackModelId,
         historianChunkTokens: historian.historianChunkTokens,
+        historianContextLimit: historian.historianContextLimit,
         boundarySnapshot,
         refreshBoundarySnapshot,
         currentContextLimit,
@@ -27710,7 +28058,8 @@ async function runPipeline(args) {
         staleReduceStripEnabled: args.canUseEmptySentinels,
         emergency: args.forceMaterialization === true && args.emergencyCeilingTokens !== undefined && args.emergencyCeilingTokens > 0 ? {
           currentTotalInputTokens: args.contextUsage.inputTokens,
-          ceilingTokens: args.emergencyCeilingTokens
+          ceilingTokens: args.emergencyCeilingTokens,
+          usagePercentage: args.contextUsage.percentage
         } : undefined,
         caveman: args.isSubagent ? undefined : args.heuristics.caveman
       }, activeTags, stableIdResolver);
@@ -30530,6 +30879,41 @@ ${migrationSummary}` : "",
   });
 }
 
+// ../plugin/src/shared/cache-ttl-display.ts
+function resolveCacheTtlDisplay(args) {
+  if (args.sessionModelKey && (!args.modelKey || args.sessionModelKey === args.modelKey) || !args.modelKey && !args.sessionModelKey && args.sessionValue !== "5m") {
+    return {
+      value: args.sessionValue || "5m",
+      source: "session",
+      modelKey: args.modelKey ?? args.sessionModelKey ?? undefined
+    };
+  }
+  if (typeof args.configured === "string") {
+    return {
+      value: args.configured,
+      source: args.configuredExplicitly ? "config" : "default",
+      modelKey: args.modelKey
+    };
+  }
+  const matched = resolveModelConfigValue(args.configured, args.modelKey);
+  if (matched) {
+    return { value: matched.value, source: "config", modelKey: args.modelKey };
+  }
+  return {
+    value: args.configured.default ?? "5m",
+    source: "default",
+    modelKey: args.modelKey
+  };
+}
+function formatCacheTtlDisplay(display) {
+  if (display.source === "session")
+    return `Cache TTL: ${display.value} (session)`;
+  if (display.source === "config") {
+    return `Cache TTL: ${display.value} (config for ${display.modelKey ?? "current model"})`;
+  }
+  return `Cache TTL: ${display.value} (default — no cache_ttl for ${display.modelKey ?? "unknown model"})`;
+}
+
 // ../plugin/src/shared/format-threshold.ts
 function formatThresholdPercent(value) {
   if (typeof value !== "number" || !Number.isFinite(value))
@@ -30617,7 +31001,7 @@ function formatExecuteThreshold(detail, contextLimit) {
   }
   return `${percentage}%${clampNote}`;
 }
-function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer, windowGeometry, tailHygiene, contextUsage, rustMode = false) {
+function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer, windowGeometry, tailHygiene, contextUsage, rustMode = false, display) {
   const thresholdDetail = resolveExecuteThresholdDetail(executeThresholdPercentageConfig, liveModelKey, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, {
     tokensConfig: executeThresholdTokens,
     contextLimit,
@@ -30631,11 +31015,18 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
     const activeTags = tags.filter((t) => t.status === "active");
     const droppedTags = tags.filter((t) => t.status === "dropped");
     const totalBytes = activeTags.reduce((sum, t) => sum + t.byteSize, 0);
+    const ttlDisplay = resolveCacheTtlDisplay({
+      configured: display?.cacheTtlConfig ?? "5m",
+      configuredExplicitly: display?.cacheTtlConfigured === true,
+      modelKey: liveModelKey,
+      sessionValue: meta.cacheTtl,
+      sessionModelKey: meta.lastObservedModelKey
+    });
     let ttlMs;
     try {
-      ttlMs = parseCacheTtl(meta.cacheTtl);
+      ttlMs = parseCacheTtl(ttlDisplay.value);
     } catch (error) {
-      sessionLog(sessionId, `invalid cache_ttl "${meta.cacheTtl}" in ctx-status; falling back to default 5m`, error);
+      sessionLog(sessionId, `invalid cache_ttl "${ttlDisplay.value}" in ctx-status; falling back to default 5m`, error);
       ttlMs = parseCacheTtl("5m");
     }
     const elapsed = Date.now() - meta.lastResponseTime;
@@ -30645,7 +31036,10 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
     const displayInputTokens = contextUsage?.inputTokens ?? meta.lastInputTokens;
     const displayPercentage = contextUsage?.percentage ?? meta.lastContextPercentage;
     const displayContextLimit = contextLimit && contextLimit > 0 ? contextLimit : displayPercentage > 0 ? Math.round(displayInputTokens / (displayPercentage / 100)) : 0;
+    const parseFailureLines = (display?.configParseFailures ?? []).map(formatConfigParseStatusLine);
     const lines = [
+      ...parseFailureLines,
+      ...parseFailureLines.length > 0 ? [""] : [],
       "## Magic Status",
       "",
       `**Session:** ${sessionId}`,
@@ -30662,7 +31056,7 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
       "",
       ...meta.lastTransformError ? ["### Last Transform Error", `- ${meta.lastTransformError}`, ""] : [],
       "### Cache TTL",
-      `- Configured: ${meta.cacheTtl}`,
+      `- ${formatCacheTtlDisplay(ttlDisplay)}`,
       `- Last response: ${meta.lastResponseTime > 0 ? `${Math.round(elapsed / 1000)}s ago` : "never"}`,
       `- 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}%`}`,
@@ -30788,7 +31182,7 @@ ${c.content}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.41.3",
+  version: "0.41.4",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -30961,6 +31355,11 @@ function renderInner(s, theme, innerWidth) {
   const lines = [];
   lines.push(`${theme.fg("accent", theme.bold("⚡ Magic Context Status"))}   ${theme.fg("muted", `v${package_default.version}`)}`);
   lines.push("");
+  for (const failure of s.configParseFailures) {
+    lines.push(theme.fg("error", formatConfigParseStatusLine(failure)));
+  }
+  if (s.configParseFailures.length > 0)
+    lines.push("");
   lines.push(`Context  ${theme.fg(pctColor, theme.bold(`${s.usagePercentage.toFixed(1)}%`))} · ${fmt2(s.inputTokens)} / ${s.contextLimit > 0 ? fmt2(s.contextLimit) : "?"} tokens`);
   if (s.windowGeometry) {
     lines.push(formatWindowDerivationLine(s.inputTokens, s.windowGeometry).replace(/^Context:.* — window /, "Window "));
@@ -30989,7 +31388,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 (MC never assumes expiry — external cache-keep)" : `${Math.round(s.cacheRemainingMs / 1000)}s remaining`}`);
+  lines.push(`${formatCacheTtlDisplay({ value: s.cacheTtl, source: s.cacheTtlSource, modelKey: s.cacheTtlModelKey })} · 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}`);
@@ -31099,7 +31498,14 @@ ${safeStringify(tool.parameters)}`);
     contextLimit: contextLimit || undefined,
     sessionId
   });
-  const cacheTtl = meta.cacheTtl || "5m";
+  const cacheTtlDisplay = resolveCacheTtlDisplay({
+    configured: deps.cacheTtlConfig ?? "5m",
+    configuredExplicitly: deps.cacheTtlConfigured === true,
+    modelKey,
+    sessionValue: meta.cacheTtl,
+    sessionModelKey: meta.lastObservedModelKey
+  });
+  const cacheTtl = cacheTtlDisplay.value;
   let cacheTtlMs;
   try {
     cacheTtlMs = parseCacheTtl(cacheTtl);
@@ -31138,6 +31544,9 @@ ${safeStringify(tool.parameters)}`);
     historianLastFailureAt: typeof metaRow?.historian_last_failure_at === "number" ? metaRow.historian_last_failure_at : null,
     historianLastError: metaRow?.historian_last_error ?? null,
     cacheTtl,
+    cacheTtlSource: cacheTtlDisplay.source,
+    cacheTtlModelKey: cacheTtlDisplay.modelKey,
+    configParseFailures: deps.configParseFailures ?? [],
     lastResponseTime: meta.lastResponseTime,
     cacheRemainingMs,
     cacheExpired,
@@ -31353,7 +31762,11 @@ No active Pi session is available.`,
         });
         const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit, {
           backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
-        }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)), pressure);
+        }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)), pressure, false, {
+          cacheTtlConfig: currentDeps.cacheTtlConfig ?? "5m",
+          cacheTtlConfigured: currentDeps.cacheTtlConfigured === true,
+          configParseFailures: currentDeps.configParseFailures ?? []
+        });
         const details = buildStatusDetails(currentDeps, sessionId);
         const profileStatus = currentDeps.activeProfile ?? "none";
         const storage = getMagicContextStorageResolution();
@@ -31642,6 +32055,7 @@ Eligible history is about ${initialPlan.snapshot.trueRawEligibleTokens.toLocaleS
         if (lastEnd + 1 >= targetEligibleEndOrdinal)
           break;
         if (!hasRunnableCompartmentWindow(plan.snapshot)) {
+          sessionLog(sessionId, `wrapup no-op: ${describeBoundaryDiagnostics(plan.snapshot)}`);
           failure = `No runnable wrapup boundary is available yet; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
           break;
         }
@@ -31659,7 +32073,7 @@ Eligible history is about ${initialPlan.snapshot.trueRawEligibleTokens.toLocaleS
           title: "/ctx-wrapup",
           text: `## Magic Wrapup
 
-Chunk ${chunkIndex}: wrapping messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1} (~${plan.snapshot.trueRawEligibleTokens.toLocaleString()} eligible tokens remain).`,
+Chunk ${chunkIndex}: wrapping messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1} (~${plan.snapshot.trueRawEligibleTokens.toLocaleString()} eligible tokens remain). ${describeBoundaryDiagnostics(plan.snapshot)}`,
           level: "info"
         });
         const leaseResult = await acquireCompartmentLeaseEventually(deps.db, sessionId, renewWrapupMarker, resolveWrapupLeaseWaitTimeout(deps));
@@ -31978,7 +32392,8 @@ function stripTagPrefixFromAssistantMessage(message) {
 }
 
 // src/index.ts
-var PI_HARNESS_KIND = resolvePiHarnessKind();
+var PI_HARNESS_DETECTION = await resolvePiHarnessDetection();
+var PI_HARNESS_KIND = PI_HARNESS_DETECTION.kind;
 var PREFIX2 = `[magic-context][${PI_HARNESS_KIND}]`;
 var PI_BOOT_DEADLINE_MS = 15000;
 var PI_CHILD_INIT_CONTEXT = Symbol.for("magic-context.pi.child-init-context");
@@ -32057,9 +32472,10 @@ function persistPiMessageEndModelMeta(args) {
     return;
   const cacheTtl = resolveCacheTtl(args.cacheTtlConfig, modelKey);
   const currentMeta = getOrCreateSessionMeta(args.db, args.sessionId);
-  if (currentMeta.cacheTtl !== cacheTtl) {
-    updateSessionMeta(args.db, args.sessionId, { cacheTtl });
-  }
+  updateSessionMeta(args.db, args.sessionId, {
+    ...currentMeta.cacheTtl === cacheTtl ? {} : { cacheTtl },
+    lastObservedModelKey: modelKey
+  });
 }
 function getCompatiblePiTodoCapture(todos) {
   if (!Array.isArray(todos))
@@ -32266,6 +32682,7 @@ function resolveHistorianFromConfig(config, harness = PI_HARNESS_KIND) {
     model,
     fallbackModels,
     historianChunkTokens,
+    historianContextLimit: resolveKnownHistorianContextLimit(model),
     timeoutMs: config.historian_timeout_ms,
     temperature: historian?.temperature,
     maxOutputTokens: historian?.maxTokens ?? 32000,
@@ -32432,7 +32849,14 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   registerCtxStatusLifecycleSignal(pi, commandLifecycleController.signal);
   let sessionShuttingDown = false;
   ensureConfigLocationsMigrated(projectDir);
-  const { config, warnings, loadedFromPaths, registrationPromptSurface } = loadPiConfig({
+  const {
+    config,
+    warnings,
+    loadedFromPaths,
+    registrationPromptSurface,
+    configParseFailures,
+    cacheTtlConfigured
+  } = loadPiConfig({
     cwd: projectDir
   });
   const promptSurfaceRuntime = createPromptSurfaceRuntime({
@@ -32444,7 +32868,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   const projectIdentity = resolveProjectIdentityForSession(projectDir, config.allow_home_project) ?? "";
   if (projectIdentity)
     seenDreamerProjectIdentities.add(projectIdentity);
-  info(`loaded v${PLUGIN_VERSION} | harness=${PI_HARNESS_KIND} | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
+  info(`loaded v${PLUGIN_VERSION} | harness=${PI_HARNESS_KIND} (via ${PI_HARNESS_DETECTION.via}) | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
   const compactionOff = !isCompactionEnabled(config);
   setCtxReduceRegisteredGlobally(!compactionOff);
   if (!compactionOff) {
@@ -32524,7 +32948,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       });
     }
   });
-  function buildProjectDeps(dir, identity, cfg) {
+  function buildProjectDeps(dir, identity, cfg, loadMetadata) {
     const hist = resolveHistorianFromConfig(cfg);
     if (hist) {
       hist.onStatusChange = (ctx) => {
@@ -32544,7 +32968,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       contextOptions: buildContextOptions(cfg, hist, auto),
       sidekickConfig: resolveSidekickFromConfig(cfg),
       dreamerConfig: resolveDreamerFromConfig(cfg),
-      dreamerEnabled: isDreamerRunnable(cfg)
+      dreamerEnabled: isDreamerRunnable(cfg),
+      configParseFailures: loadMetadata.configParseFailures,
+      cacheTtlConfigured: loadMetadata.cacheTtlConfigured
     };
   }
   function resolveProjectDepsForDir(dir, identityOverride) {
@@ -32561,7 +32987,10 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     });
     const switchedConfig = switchedLoad.config;
     const switchedIdentity = identityOverride ?? resolveProjectIdentityForSession(dir, switchedConfig.allow_home_project) ?? "";
-    const built = buildProjectDeps(dir, switchedIdentity, switchedConfig);
+    const built = buildProjectDeps(dir, switchedIdentity, switchedConfig, {
+      configParseFailures: switchedLoad.configParseFailures,
+      cacheTtlConfigured: switchedLoad.cacheTtlConfigured
+    });
     projectDepsByDir.set(dir, built);
     return built;
   }
@@ -32571,7 +33000,10 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
   function resolveContextOptionsForProject(dir) {
     return resolveProjectDepsForDir(dir).contextOptions;
   }
-  const bootProjectDeps = buildProjectDeps(projectDir, projectIdentity, config);
+  const bootProjectDeps = buildProjectDeps(projectDir, projectIdentity, config, {
+    configParseFailures,
+    cacheTtlConfigured
+  });
   projectDepsByDir.set(projectDir, bootProjectDeps);
   function syncDreamerProjectRegistration(current) {
     if (sessionShuttingDown)
@@ -32622,6 +33054,20 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     projectDepsByDir.delete(ctx.cwd);
     const current = resolveCurrentProjectDeps(ctx);
     syncCtxMemoryToolEnabled(pi, current.config.memory.enabled);
+    const failuresToShow = claimConfigParseFailuresOnce("pi", current.configParseFailures);
+    if (ctx.hasUI && failuresToShow.length > 0) {
+      ctx.ui.notify(formatConfigParseNotice(failuresToShow), "error");
+    }
+    const sessionId = resolveSessionId(ctx);
+    const model = ctx.model;
+    if (sessionId && model?.provider && model.id) {
+      seedSessionCacheTtlIfUnsynced({
+        db,
+        sessionId,
+        configured: current.config.cache_ttl,
+        modelKey: canonicalPiModelKey(model.provider, model.id)
+      });
+    }
     await handlePiCloneSessionStart(event, ctx, {
       db,
       signalPendingMarker: signalPiDeferredCompactionMarkerDrain
@@ -32660,6 +33106,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       scheduleSummary: summarizeDreamSchedule(bootProjectDeps.config.dreamer)
     },
     activeProfile: bootProjectDeps.config.profile,
+    cacheTtlConfig: bootProjectDeps.config.cache_ttl,
+    cacheTtlConfigured: bootProjectDeps.cacheTtlConfigured,
+    configParseFailures: bootProjectDeps.configParseFailures,
     resolveStatusDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       return {
@@ -32675,7 +33124,10 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
           runnable: current.dreamerEnabled,
           scheduleSummary: summarizeDreamSchedule(current.config.dreamer)
         },
-        activeProfile: current.config.profile
+        activeProfile: current.config.profile,
+        cacheTtlConfig: current.config.cache_ttl,
+        cacheTtlConfigured: current.cacheTtlConfigured,
+        configParseFailures: current.configParseFailures
       };
     }
   });