@cortexkit/opencode-magic-context 0.49.33 → 0.49.35

package/dist/index-wh9fxds5.js

@@ -0,0 +1,265 @@
+import {
+  sanitizeDiagnosticText
+} from "./index-z4p0ry94.js";
+
+// 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;
+function attachFailClosedBlockingProcessEvidence(process, evidence) {
+  Object.defineProperties(process, {
+    startTime: { configurable: true, value: evidence.startTime },
+    commandLine: { configurable: true, value: evidence.commandLine }
+  });
+  return process;
+}
+
+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 === "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;
+var MAX_FORMATTED_COMMAND_LINE_LENGTH = 80;
+function normalizeFailClosedProcessKind(process) {
+  switch (process.kind) {
+    case "OpenCode server":
+    case "OpenCode instance (TUI/CLI)":
+    case "Pi":
+    case "process":
+      return process.kind;
+  }
+  switch (process.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 formatFailClosedProcessStartTime(startTime) {
+  if (!Number.isFinite(startTime) || startTime <= 0)
+    return "unverified";
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      month: "short",
+      hour12: false
+    }).formatToParts(new Date(startTime));
+    const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+    if (!values.month || !values.day || !values.hour || !values.minute)
+      return "unverified";
+    return `${values.month} ${values.day} ${values.hour}:${values.minute}`;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedCommandLine(commandLine) {
+  if (typeof commandLine !== "string" || commandLine.trim().length === 0)
+    return "unverified";
+  try {
+    const normalized = commandLine.replaceAll("\x00", " ").replace(/\s+/g, " ").trim();
+    if (normalized.length === 0)
+      return "unverified";
+    const sanitized = sanitizeDiagnosticText(normalized).trim();
+    if (sanitized.length === 0)
+      return "unverified";
+    return sanitized.length > MAX_FORMATTED_COMMAND_LINE_LENGTH ? `${sanitized.slice(0, MAX_FORMATTED_COMMAND_LINE_LENGTH - 3)}...` : sanitized;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedBlockingProcesses(processes) {
+  const uniqueProcesses = new Map;
+  for (const process of processes) {
+    if (!Number.isInteger(process.pid) || process.pid <= 0)
+      continue;
+    const candidate = {
+      kind: normalizeFailClosedProcessKind(process),
+      pid: process.pid,
+      startTime: process.startTime,
+      commandLine: process.commandLine
+    };
+    const previous = uniqueProcesses.get(process.pid);
+    if (!previous || previous.kind === "process" && candidate.kind !== "process") {
+      uniqueProcesses.set(process.pid, candidate);
+    } else {
+      uniqueProcesses.set(process.pid, {
+        ...previous,
+        startTime: previous.startTime ?? candidate.startTime,
+        commandLine: previous.commandLine ?? candidate.commandLine
+      });
+    }
+  }
+  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";
+  const summary = rendered.length === 1 ? rendered[0] : `${rendered.slice(0, -1).join(", ")}, and ${rendered.at(-1)}`;
+  const evidence = entries.map(({ kind, pid, startTime, commandLine }) => `- PID ${pid}: ${kind}, started ${formatFailClosedProcessStartTime(startTime)}, cmd: ${formatFailClosedCommandLine(commandLine)}`).join(`
+`);
+  return `${summary}
+Blocking process evidence:
+${evidence}`;
+}
+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 (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      `The database is at upstream migration v${reason.persistedVersion}; this build needs v${reason.supportedVersion}.`,
+      "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
+      "If that host loads a pinned or cached older Magic Context build, a restart alone is not enough: stop it or update its Magic Context build, then start this host once so it migrates the database with nothing older attached.",
+      `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 formatFailClosedBlockingSummary(reason) {
+  if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion}: RPC discovery file ${reason.unreadableFile} could not be read, so an older host may still be attached.`;
+    }
+    const blockers = reason.blockingProcesses.filter((process) => Number.isInteger(process.pid) && process.pid > 0).map((process) => `${normalizeFailClosedProcessKind(process)} (PID ${process.pid})`);
+    const named = blockers.length > 0 ? blockers.join(", ") : "a live process";
+    return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion} while ${named} may still run an older Magic Context build. Stop or update that host, then start this one once.`;
+  }
+  if (reason.kind === "schema_fence") {
+    return `Magic Context cannot operate: the shared database is at v${reason.persistedVersion}, newer than this build supports (v${reason.supportedVersion}). Update and restart this host.`;
+  }
+  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
+  return `Magic Context cannot operate: persistent storage failed (${cause}).`;
+}
+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 resolveAgentNameFromMessages(messages) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const info = messages[i]?.info;
+    if (!info || typeof info !== "object")
+      continue;
+    const agent = info.agent;
+    if (typeof agent === "string" && agent.length > 0)
+      return agent;
+  }
+  return;
+}
+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);
+    }
+  };
+}
+var lastHookInitFailure = null;
+function recordHookInitFailure(failure) {
+  lastHookInitFailure = failure;
+}
+function clearHookInitFailure() {
+  lastHookInitFailure = null;
+}
+function getLastHookInitFailure() {
+  return lastHookInitFailure;
+}
+
+export { FAIL_CLOSED_DOCTOR_COMMAND, attachFailClosedBlockingProcessEvidence, formatFailClosedBlockingMessage, formatFailClosedBlockingSummary, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, resolveAgentNameFromMessages, createFailClosedController, recordHookInitFailure, clearHookInitFailure, getLastHookInitFailure };

package/dist/{index-b7w46fp2.js → index-x2mrq5xv.js}

@@ -7,7 +7,7 @@ import {
   getTemporalDecisions,
   freezeTemporalDecisions,
   stableStringify
-} from "./index-xrnsygfq.js";
+} from "./index-9wnbnx8f.js";
 import {
   protectedToolTagNumbers,
   stripPersistedAssistantText,
@@ -74,19 +74,19 @@ import {
   adoptNullOwnerToolTag2,
   getCandidateToolOwners2,
   pickNearestPriorOwner2
-} from "./index-np3rgfw4.js";
+} from "./index-ksv0a31x.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
   estimateTokens
-} from "./index-b88dwwrh.js";
+} from "./index-4xyjr62e.js";
 import {
   getMagicContextStorageDir
 } from "./index-g2q4htwp.js";
 import {
   log2,
   sessionLog2
-} from "./index-h7tgn49j.js";
+} from "./index-jrfre9ah.js";
 import {
   inRootAsyncContext2,
   getTagIdentityWriteGeneration2,
@@ -94,17 +94,12 @@ import {
   assertTransformWrite2,
   isTransientSqliteError2
 } from "./index-gzy5w8ya.js";
-import {
-  getProjectEmbeddingSnapshot2,
-  embedTextForProject2,
-  embedBatchForProject2
-} from "./index-2743x98y.js";
 import {
   createWorkerShutdown
 } from "./index-cpjk5jd2.js";
 import {
   runSessionWarmupWorker
-} from "./index-rverk2vz.js";
+} from "./index-qncw9hey.js";
 import {
   getMaxM0MutationId,
   getLastCompartmentEndMessage,
@@ -121,30 +116,12 @@ import {
   clearPendingMaterialization,
   saveSourceContent,
   replaceSourceContent,
-  getSourceContents,
-  compareOpenCodeMessagesByCanonicalOrder,
-  prepareCompactionMarkerCandidates,
-  MARKER_SUMMARY_TEXT,
-  applyDeferredCompactionMarker,
-  injectTemporalMarkers,
-  clearInjectionCache,
-  getVisibleMemoryIds,
-  renderCompartmentInjection,
-  MaterializeContentionError,
-  mustMaterialize,
-  hydrateCachedM0Mural,
-  prepareCachedM0M1Replay,
-  hasCompleteCachedM0M1,
-  injectM0M1,
-  observeNoteNudgeServe,
-  peekNoteNudgeText,
-  markNoteNudgeDelivered,
-  getActiveCompartmentRun
-} from "./index-2xh37qn5.js";
+  getSourceContents
+} from "./index-f297z1n8.js";
 import {
   cleanSearchText,
   matchedSearchSnippet
-} from "./index-4s4zq97n.js";
+} from "./index-pq0dpwrc.js";
 import {
   stripSystemInjection,
   isTextPart,
@@ -242,10 +219,15 @@ import {
   extractToolCallObservation,
   ToolMutationBatch,
   createToolDropTarget
-} from "./index-0fe4q77z.js";
+} from "./index-brg2w6qc.js";
 import {
   isValidLanguageCode
 } from "./index-nxrsns5x.js";
+import {
+  getProjectEmbeddingSnapshot2,
+  embedTextForProject2,
+  embedBatchForProject2
+} from "./index-jn0ddrhp.js";
 import {
   isEmbeddingHostBusy2
 } from "./index-qt1qqasc.js";
@@ -253,17 +235,38 @@ import {
   openCodeDbExists,
   withReadOnlySessionDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-y1qwzvxn.js";
+} from "./index-pztqab6k.js";
 import {
   BoundedSessionMap
-} from "./index-s1n8dd2n.js";
+} from "./index-jkanybgq.js";
 import {
   getMessageIndexEpoch,
-  isMessageIndexSearchable
-} from "./index-94ef0qe2.js";
+  isMessageIndexSearchable,
+  createAutoSearchDiagnostics
+} from "./index-87ctnzz9.js";
+import {
+  compareOpenCodeMessagesByCanonicalOrder,
+  prepareCompactionMarkerCandidates,
+  MARKER_SUMMARY_TEXT,
+  applyDeferredCompactionMarker,
+  injectTemporalMarkers,
+  clearInjectionCache,
+  getVisibleMemoryIds,
+  renderCompartmentInjection,
+  MaterializeContentionError,
+  mustMaterialize,
+  hydrateCachedM0Mural,
+  prepareCachedM0M1Replay,
+  hasCompleteCachedM0M1,
+  injectM0M1,
+  observeNoteNudgeServe,
+  peekNoteNudgeText,
+  markNoteNudgeDelivered,
+  getActiveCompartmentRun
+} from "./index-4bgk5ztz.js";
 import {
   userFacingFailureCode
-} from "./index-as2amvn3.js";
+} from "./index-0c7p8mq5.js";
 import {
   normalizeProtectedToolName,
   mergeProtectedTools
@@ -273,7 +276,7 @@ import {
 } from "./index-y8v6yerm.js";
 import {
   logSlowWriteTransaction
-} from "./index-t5pck3ss.js";
+} from "./index-fxbk7gk3.js";
 
 // src/features/magic-context/tagger.ts
 var TOOL_COMPOSITE_KEY_SEP = "\x00";
@@ -1262,6 +1265,32 @@ function selectAutoSearchResults(results, threshold) {
   return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
+// src/hooks/magic-context/auto-search-observation.ts
+var disabledTurns = new WeakMap;
+function logDisabledAutoSearch(db, sessionId, messageId, threshold, startedAt) {
+  const sessions = disabledTurns.get(db) ?? new Map;
+  disabledTurns.set(db, sessions);
+  if (sessions.get(sessionId) === messageId)
+    return;
+  sessions.set(sessionId, messageId);
+  observeAutoSearch(sessionId, threshold, startedAt).finish("disabled");
+}
+function observeAutoSearch(sessionId, threshold, startedAt) {
+  const diagnostics = createAutoSearchDiagnostics(threshold);
+  let logged = false;
+  return {
+    diagnostics,
+    finish(outcome, reason) {
+      if (logged)
+        return;
+      logged = true;
+      const lanes = Object.entries(diagnostics.lanes).map(([lane, value]) => `${lane}:${value.top?.toFixed(3) ?? "none"}`).join(",");
+      const nearMisses = Object.values(diagnostics.lanes).reduce((sum, lane) => sum + lane.nearMisses, 0);
+      sessionLog2(sessionId, `auto-search: decision outcome=${outcome}${reason ? ` reason=${reason}` : ""} lanes=${lanes || "none"} nearMisses=${nearMisses} threshold=${threshold} pool=${diagnostics.pool} rows=${diagnostics.poolRows ?? "unknown"} workerStarted=${diagnostics.workerStarted ?? "unknown"} peek=${diagnostics.peek} elapsedMs=${Math.round(performance.now() - startedAt)}`);
+    }
+  };
+}
+
 // src/hooks/magic-context/auto-search-worker-client.ts
 import { Worker } from "node:worker_threads";
 var pendingRegistrations = new WeakMap;
@@ -1499,6 +1528,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
     stepTimings: _stepTimings,
+    onAutoSearchDiagnostics: _onAutoSearchDiagnostics,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
@@ -1540,6 +1570,11 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     throw new AutoSearchBusyError;
   }
   const { slot, fresh } = lease;
+  if (options.autoSearchDiagnostics) {
+    options.autoSearchDiagnostics.workerStarted = fresh;
+    if (fresh)
+      options.autoSearchDiagnostics.pool = "cold";
+  }
   const worker = slot.worker;
   const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
   const startedAt = performance.now();
@@ -1619,6 +1654,15 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const onMessage = async (reply) => {
       if (released)
         return;
+      if (reply.kind === "diagnostics") {
+        if (!settled && options.autoSearchDiagnostics) {
+          const workerStarted = options.autoSearchDiagnostics.workerStarted;
+          Object.assign(options.autoSearchDiagnostics, reply.diagnostics, {
+            workerStarted
+          });
+        }
+        return;
+      }
       if (reply.kind === "result" || reply.kind === "error") {
         if (detachedAt !== undefined) {
           logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
@@ -1954,8 +1998,12 @@ function findLatestMeaningfulUserMessage(messages) {
 async function runAutoSearchHint(args) {
   const startedAt = performance.now();
   const { sessionId, db, messages, options } = args;
-  if (!options.enabled)
+  if (!options.enabled) {
+    const tail = findLatestMeaningfulUserMessage(messages);
+    if (tail && typeof tail.info.id === "string" && messages.at(-1) === tail)
+      logDisabledAutoSearch(db, sessionId, tail.info.id, options.scoreThreshold, startedAt);
     return AUTO_SEARCH_OK;
+  }
   const userMsg = findLatestMeaningfulUserMessage(messages);
   if (!userMsg || typeof userMsg.info.id !== "string")
     return AUTO_SEARCH_OK;
@@ -1979,10 +2027,12 @@ async function runAutoSearchHint(args) {
     if (messages.length === 0 || messages[messages.length - 1].info.id !== userMsgId) {
       return AUTO_SEARCH_OK;
     }
+    const observation = observeAutoSearch(sessionId, options.scoreThreshold, startedAt);
     const embeddingSnapshot = getProjectEmbeddingSnapshot2(options.projectPath);
     if (!embeddingSnapshot) {
       queueAutoSearchRegistration(db, options.projectPath, options.directory && options.ensureProjectRegistered ? () => options.ensureProjectRegistered?.(options.directory, db) ?? Promise.resolve() : undefined);
       persistAutoSearchSkip(db, sessionId, userMsgId, "empty");
+      observation.finish("no-candidates", "unregistered");
       return AUTO_SEARCH_OK;
     }
     const writeNoHintAndReconcile = async (reason) => {
@@ -1993,21 +2043,24 @@ async function runAutoSearchHint(args) {
       }, startedAt);
       if (outcome === null) {
         persistAutoSearchSkip(db, sessionId, userMsgId);
+        observation.finish("timeout");
         return { ok: false, kind: "timeout" };
       }
-      if (!outcome.ok)
+      if (!outcome.ok) {
+        observation.finish("error", outcome.kind);
         return {
           ok: false,
           kind: outcome.kind === "storage-busy" ? "storage-busy" : "cas-exhaustion"
         };
+      }
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
+      observation.finish(outcome.decision.decision === "hint" ? "attached" : reason === "below-threshold" ? "below-threshold" : reason === "error" ? "error" : "no-candidates", reason);
       return AUTO_SEARCH_OK;
     };
     const rawPartsText = collectUserPromptParts(userMsg);
     if (hasStackedAugmentation(rawPartsText)) {
-      sessionLog2(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
       return writeNoHintAndReconcile("stacked");
     }
     const rawPrompt = extractUserPromptText(userMsg);
@@ -2023,6 +2076,7 @@ async function runAutoSearchHint(args) {
         const embeddingEnabled = embeddingSnapshot ? embeddingSnapshot.historyEnabled : options.embeddingEnabled;
         const gitCommitsEnabled = embeddingSnapshot?.gitCommitEnabled ?? options.gitCommitsEnabled ?? false;
         const searchOptions = {
+          autoSearchDiagnostics: observation.diagnostics,
           limit: 10,
           maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
           excludeMessageId: userMsgId,
@@ -2049,11 +2103,10 @@ async function runAutoSearchHint(args) {
       if (lifecycleSignal.aborted)
         return AUTO_SEARCH_OK;
       if (error instanceof AutoSearchBusyError) {
-        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        observation.finish("timeout", "worker-busy");
         persistAutoSearchSkip(db, sessionId, userMsgId);
         return { ok: false, kind: "timeout" };
       }
-      log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       const outcome = await writeNoHintAndReconcile("error");
       return outcome.ok ? { ok: false, kind: "search-failure" } : outcome;
     }
@@ -2061,9 +2114,8 @@ async function runAutoSearchHint(args) {
       return AUTO_SEARCH_OK;
     try {
       if (results === null) {
-        sessionLog2(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn`);
+        observation.finish("timeout");
         persistAutoSearchSkip(db, sessionId, userMsgId);
-        sessionLog2(sessionId, "auto-search: skip frozen; retries for this turn are replay-only");
         return { ok: false, kind: "timeout" };
       }
       if (results.length === 0) {
@@ -2071,7 +2123,6 @@ async function runAutoSearchHint(args) {
       }
       results = selectAutoSearchResults(results, options.scoreThreshold);
       if (results.length === 0) {
-        sessionLog2(sessionId, `auto-search: no fragment meets relevance threshold ${options.scoreThreshold}`);
         return writeNoHintAndReconcile("below-threshold");
       }
       const hintText = buildAutoSearchHint(results, {
@@ -2091,18 +2142,19 @@ ${hintText}`;
       }, startedAt);
       if (outcome === null) {
         persistAutoSearchSkip(db, sessionId, userMsgId);
+        observation.finish("timeout");
         return { ok: false, kind: "timeout" };
       }
       if (!outcome.ok) {
+        observation.finish("error", outcome.kind);
         if (outcome.kind === "storage-busy")
           return { ok: false, kind: "storage-busy" };
-        sessionLog2(sessionId, `auto-search: CAS exhausted for ${userMsgId}; skipping wire append`);
         return { ok: false, kind: "cas-exhaustion" };
       }
       if (outcome.decision.decision === "hint") {
         appendReminderToUserMessageById(messages, userMsgId, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
+      observation.finish(outcome.decision.decision === "hint" ? "attached" : "no-candidates");
       return AUTO_SEARCH_OK;
     } finally {
       if (!lifecycleSignal.aborted && results !== null)
@@ -3473,6 +3525,50 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
+function prepareAgedToolSkeletonConversions(db, sessionId, targets, options = {}) {
+  const candidates = [...targets.keys()].sort((a, b) => a - b);
+  const readRows = (connection) => {
+    const window = getNewestToolTagNumbers2(connection, sessionId, RECENT_TOOL_SKELETON_WINDOW);
+    const recent = new Set(window);
+    const statement = connection.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
+             FROM tags WHERE session_id = ? AND tag_number = ?
+               AND type = 'tool' AND status = 'dropped'
+               AND drop_mode IN ('truncated', 'skeleton_real', 'skeleton_stripped')`);
+    const rows = candidates.filter((id) => !recent.has(id)).flatMap((id) => {
+      const row = statement.get(sessionId, id);
+      return row ? [row] : [];
+    });
+    return { window, rows };
+  };
+  const snapshot = readRows(db);
+  options.prepareRemovals?.(snapshot.rows);
+  const converted = new Map;
+  const plannedRemovals = new Set;
+  for (const row of snapshot.rows) {
+    const target = targets.get(row.tagNumber);
+    if (target?.thinkingDropProtected || target?.thinkingRewriteProtected || target?.identityRepairProtected)
+      continue;
+    if (target?.canDrop?.() !== true || target.prepareDrop?.() === false)
+      continue;
+    if (target.requiresToolArcSkeleton) {
+      const owners = target.mutationParts ? target.mutationParts.map(({ message }) => message).filter((message) => message.info.role === "assistant") : target.message ? [target.message] : [];
+      if (owners.length === 0 || owners.some((message) => !options.thinkingStrippedIds?.has(message.info.id ?? "")))
+        continue;
+    }
+    if (target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.(plannedRemovals) === true)
+      continue;
+    converted.set(row.tagNumber, "full");
+    target.notePlannedRemoval?.(plannedRemovals);
+  }
+  return {
+    converted,
+    isCurrent: (connection) => JSON.stringify(readRows(connection)) === JSON.stringify(snapshot),
+    persist: (connection) => {
+      for (const tagNumber of converted.keys())
+        updateTagDropMode2(connection, sessionId, tagNumber, "full");
+    }
+  };
+}
 var PENDING_OPERATION_CHUNK_SIZE = 64;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
@@ -6771,6 +6867,20 @@ async function runPostTransformPhase2(args) {
         }
       }
     }
+    if (!args.fullFeatureMode && canEditWholePrefix && !compactionOff) {
+      const thinkingStrippedIds = new Set([...bindingThinking, ...removedReasoningIds]);
+      for (const id of getMergedReasoningStrippedIds(args.db, args.sessionId)) {
+        if (id.startsWith(THINKING_BINDING_RECOVERY_FROZEN_PREFIX))
+          thinkingStrippedIds.add(id.slice(THINKING_BINDING_RECOVERY_FROZEN_PREFIX.length));
+      }
+      const conversions = prepareAgedToolSkeletonConversions(args.db, args.sessionId, newTargets, { thinkingStrippedIds });
+      args.db.transaction(() => {
+        if (!conversions.isCurrent(args.db))
+          throw new Error("Subagent skeleton candidates changed before commit");
+        conversions.persist(args.db);
+      }).immediate();
+      convertedToolSkeletonsDidMutate = renderConvertedToolSkeletons(newTargets, conversions.converted) || convertedToolSkeletonsDidMutate;
+    }
     const tBatchFinalize = performance.now();
     args.batch?.finalize();
     if (toolReclaimApplicationOpportunity) {
@@ -7181,6 +7291,18 @@ async function runPostTransformPhase2(args) {
     }
     autoSearchHintAppendedThisPass = autoSearchCompletedThisPass && countAutoSearchHints(args.db, args.sessionId) !== autoSearchHintsBefore;
     logTransformTiming(args.sessionId, "pp.autoSearchHint", tAutoSearch);
+  } else if (args.fullFeatureMode && args.autoSearch && !args.autoSearch.enabled && args.projectPath) {
+    await runAutoSearchHint({
+      sessionId: args.sessionId,
+      db: args.db,
+      messages: args.messages,
+      options: {
+        enabled: false,
+        scoreThreshold: args.autoSearch.scoreThreshold,
+        minPromptChars: args.autoSearch.minPromptChars,
+        projectPath: args.projectPath
+      }
+    });
   }
   if (args.fullFeatureMode && canEditWholePrefix) {
     const visibleIds = new Set;