@wrongstack/cli 0.313.1 → 0.316.2

package/dist/{execution-L4CXQEND.js → execution-TZUGCKFU.js}

@@ -1,15 +1,17 @@
 import {
-  deriveFsAccessPair,
-  filterSafeForProject,
   getSuggestions,
   normalizeTuiThinkingWord,
-  resolveActualTarget,
-  resolvePersistPath,
   runGit,
   setAutoSuggestions,
   setSuggestions
-} from "./chunk-X3N5TS2S.js";
-import "./chunk-WHOIR577.js";
+} from "./chunk-SXJTVNWF.js";
+import {
+  deriveFsAccessPair,
+  filterSafeForProject,
+  resolveActualTarget,
+  resolvePersistPath
+} from "./chunk-JACOMTIH.js";
+import "./chunk-ALE5KHCA.js";
 import {
   advanceToNextTask,
   autoDetectTaskCompletion,
@@ -22,10 +24,10 @@ import {
   trySaveImplementationPlan,
   trySaveSpecFromAIOutput,
   trySaveTasksFromAIOutput
-} from "./chunk-DGXNL7OT.js";
+} from "./chunk-JHUJUIOH.js";
 import {
   startCliHqConnection
-} from "./chunk-FKWHSFX4.js";
+} from "./chunk-XYKYXFEE.js";
 import {
   theme
 } from "./chunk-QD544J2B.js";
@@ -36,11 +38,11 @@ import {
   WEBUI_SESSION_CHILD_CAPABILITIES,
   writeWebuiSessionChildError,
   writeWebuiSessionChildReady
-} from "./chunk-3JPTNADJ.js";
+} from "./chunk-GPPRNAKW.js";
 import {
   terminalLink,
   terminalText
-} from "./chunk-KE7E7DPX.js";
+} from "./chunk-HXJYHAR4.js";
 import {
   CLI_VERSION
 } from "./chunk-XJXDOF63.js";
@@ -58,9 +60,10 @@ import { effectiveFallbackChain as effectiveFallbackChain2, setQueuedMessagesSna
 import { updateReviewReportEvidence } from "@wrongstack/core/plugin";
 import { attachTodosCheckpoint as attachTodosCheckpoint2 } from "@wrongstack/core/storage";
 import { normalizeTokenSavingTier as normalizeTokenSavingTier2 } from "@wrongstack/core/types";
-import { mergeCustomModelDefs } from "@wrongstack/core/utils";
+import { hasOpenTodos as hasOpenTodos3, mergeCustomModelDefs } from "@wrongstack/core/utils";
 import { capabilitiesFor } from "@wrongstack/providers";
 import { createToolVisionAdapters } from "@wrongstack/runtime/vision";
+import { parseNextSteps as parseNextSteps2 } from "@wrongstack/tools/next-steps";
 
 // src/boot/dispatch-singleshot.ts
 import { color, writeOut } from "@wrongstack/core/utils";
@@ -201,13 +204,15 @@ async function runWebUIDispatch(ctx) {
     sddSubagentFactory,
     onKanbanDispatch,
     getFleetBudget,
+    stopSessionFleet,
+    onSessionRetired,
     webuiSessionChild
   } = ctx;
   const isSessionChild = Boolean(webuiSessionChild);
   const isSimpleUi = !isSessionChild && flags["simpleui"] === true;
   agent.disableInteractiveConfirmation();
   renderer.setSilent(true);
-  const { runWebUI } = await import("./webui-server-I53IYBW4.js");
+  const { runWebUI } = await import("./webui-server-LZOEH7O6.js");
   const flagValue = (names) => {
     for (const name of names) {
       if (!Object.hasOwn(flags, name)) continue;
@@ -262,7 +267,7 @@ async function runWebUIDispatch(ctx) {
     webuiPublicWsUrl = webuiSessionChild?.publicWsUrl ?? flagValue(["webui-public-ws-url", "public-ws-url"]) ?? process.env["WEBUI_PUBLIC_WS_URL"];
     webuiRequireToken = webuiSessionChild?.requireToken ?? flagBoolean(["webui-require-token", "require-token"]) ?? envFlag("WEBUI_REQUIRE_TOKEN");
     if (isSimpleUi) {
-      const { ensureSimpleUiDistDir } = await import("./simpleui-dist-33VO3QHF.js");
+      const { ensureSimpleUiDistDir } = await import("./simpleui-dist-JKNRCRRK.js");
       frontendDistDir = await ensureSimpleUiDistDir();
     }
   } catch (err) {
@@ -307,6 +312,8 @@ async function runWebUIDispatch(ctx) {
     subscribeEternalIteration,
     sessionStore,
     ...getFleetBudget ? { getFleetBudget } : {},
+    ...stopSessionFleet ? { stopSessionFleet } : {},
+    ...onSessionRetired ? { onSessionRetired } : {},
     sessionsDir: projectSessionsDir,
     claimSession: activateSessionIdentity ? async (sessionId) => {
       const previousSessionId = agent.ctx.session?.id ?? session.id;
@@ -397,16 +404,18 @@ async function runWebUIDispatch(ctx) {
     },
     // Make autonomy.switch from the browser flip the CLI's real
     // autonomy mode — context.meta alone never reaches the run loop.
-    onAutonomySwitch: (mode) => {
+    onAutonomySwitch: (mode, sessionId) => {
+      if (sessionId !== void 0 && sessionId !== agent.ctx.session?.id) return;
       if (mode === "off" || mode === "suggest" || mode === "auto" || mode === "eternal" || mode === "eternal-parallel") {
         onAutonomy?.(mode);
       }
     },
-    onYoloSwitch: (enabled) => {
+    onYoloSwitch: (enabled, sessionId) => {
+      if (sessionId !== void 0 && sessionId !== agent.ctx.session?.id) return;
       applyLiveSettings?.({ yolo: enabled });
     },
     onWrongProxyPrefsChange: (payload) => {
-      void import("./proxy-wiring-G26YGP7S.js").then(
+      void import("./proxy-wiring-EQB5X5YH.js").then(
         ({ applyWrongProxyPrefs }) => applyWrongProxyPrefs(payload)
       );
     }
@@ -858,6 +867,11 @@ async function getLiveSessions(ctx) {
     gitBranch: s.gitBranch,
     status: s.status,
     pid: s.pid,
+    // Which surface owns it — 'tui' | 'webui' | 'cli' | 'repl'. The /resume
+    // picker names it when it refuses a live session, because "open
+    // somewhere else" is not actionable and "open in the WebUI (pid 1234)"
+    // is. Optional on the registry entry for back-compat with older rows.
+    clientType: s.clientType,
     startedAt: s.startedAt,
     agentCount: s.agentCount,
     agents: s.agents.map((a) => ({
@@ -1198,7 +1212,7 @@ async function switchProjectInPlace(ctx, targetRoot, displayName) {
 
 // src/boot/tui-sdd-callback.ts
 async function getSDDContext() {
-  const { getActiveSDDContext: getActiveSDDContext2 } = await import("./sdd-runtime-GFZ3NJKS.js");
+  const { getActiveSDDContext: getActiveSDDContext2 } = await import("./sdd-runtime-FLKCSTYV.js");
   return getActiveSDDContext2();
 }
 async function onSDDOutput(output) {
@@ -1209,7 +1223,7 @@ async function onSDDOutput(output) {
     autoDetectTaskCompletion: autoDetectTaskCompletion2,
     getTaskProgress: getTaskProgress2,
     getActiveSDDPhase: getActiveSDDPhase2
-  } = await import("./sdd-runtime-GFZ3NJKS.js");
+  } = await import("./sdd-runtime-FLKCSTYV.js");
   const messages = [];
   const specSaved = await trySaveSpecFromAIOutput2(output);
   if (specSaved) messages.push("\u2713 Spec detected and saved! Use /sdd approve to continue.");
@@ -1239,11 +1253,61 @@ async function onSDDOutput(output) {
 // src/boot/tui-session-resume.ts
 import * as path7 from "node:path";
 import { attachTodosCheckpoint, loadTodosCheckpoint } from "@wrongstack/core/storage";
+import { projectLastRequestTokens } from "@wrongstack/core/types/session-timeline";
 import { sessionScopedPath as sessionScopedPath2 } from "@wrongstack/core/utils";
+var RESERVATION_WINDOW_MS = 6e4;
+var RESERVATION_RENEW_MS = 2e4;
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map(
+    (block) => block && typeof block === "object" && "text" in block && typeof block.text === "string" ? block.text : ""
+  ).filter(Boolean).join("\n");
+}
+function lastAssistantTextOf(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant") continue;
+    const text = messageText(message.content).trim();
+    if (text) return text;
+  }
+  return void 0;
+}
 async function resumeSession(ctx, sessionId) {
-  const { state, agent, tokenCounter, switchProviderAndModel, events } = ctx;
-  if (!state.activeSessionStore) return null;
-  const { replaySessionMessages } = await import("@wrongstack/tui");
+  const { state, agent, tokenCounter, switchProviderAndModel, events, onLoadProgress } = ctx;
+  const fail = (stage2, message) => {
+    try {
+      ctx.onFailure?.({ stage: stage2, message: message || "unknown error" });
+    } catch {
+    }
+    return null;
+  };
+  const warnings = [];
+  const warn = (label, err) => {
+    warnings.push(`${label}: ${err instanceof Error ? err.message : String(err)}`);
+  };
+  let stage = "start";
+  const setStage = (next) => {
+    stage = next;
+    try {
+      ctx.onStage?.(next);
+    } catch {
+    }
+  };
+  if (!state.activeSessionStore) {
+    return fail("no_session_store", "No session store is bound to this project.");
+  }
+  setStage("load_replay_module");
+  let replaySessionMessages;
+  try {
+    ({ replaySessionMessages } = await import("@wrongstack/tui"));
+    if (typeof replaySessionMessages !== "function") {
+      throw new TypeError("@wrongstack/tui does not export replaySessionMessages");
+    }
+  } catch (err) {
+    return fail(stage, err instanceof Error ? err.message : String(err));
+  }
+  setStage("resolve_id");
   let canonicalSessionId = sessionId;
   try {
     if (state.activeSessionStore.resolveId) {
@@ -1259,34 +1323,66 @@ async function resumeSession(ctx, sessionId) {
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
-    return null;
+    return fail(stage, err instanceof Error ? err.message : String(err));
   }
   const previousSessionId = agent.ctx.session?.id;
+  let hydrated;
   let identityClaimed = false;
   let resumeClaim;
   let writerSwapped = false;
   let openedWriter;
   let oldWriter;
   let oldMessages;
+  let oldSessionRefCurrent;
   let previousDetachFn;
   let oldTodos = [];
   let oldPlanPath;
   let oldTaskPath;
   try {
+    setStage("reserve_ownership");
     if (state.wpaths.projectSlug && state.wpaths.globalRoot) {
       const { getSessionRegistry } = await import("@wrongstack/core/storage");
       const registry = getSessionRegistry(state.wpaths.globalRoot);
       resumeClaim = await registry.reserveResume({
         sessionId: canonicalSessionId,
         projectSlug: state.wpaths.projectSlug,
-        projectRoot: state.projectRoot
+        projectRoot: state.projectRoot,
+        reservationMs: RESERVATION_WINDOW_MS
       });
     } else if (state.activateSessionIdentity) {
       await state.activateSessionIdentity(canonicalSessionId);
       identityClaimed = true;
     }
-    const resumed = await state.activeSessionStore.resume(canonicalSessionId);
+    setStage("open_journal");
+    const claimToRenew = resumeClaim;
+    let renewFailures = 0;
+    const renew = () => {
+      if (!claimToRenew) return;
+      void claimToRenew.renew(RESERVATION_WINDOW_MS).catch((err) => {
+        if (renewFailures++ > 0) return;
+        console.error(
+          JSON.stringify({
+            level: "warn",
+            event: "execution.resume_reservation_renew_failed",
+            sessionId: canonicalSessionId,
+            message: err instanceof Error ? err.message : String(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      });
+    };
+    const renewTimer = setInterval(renew, RESERVATION_RENEW_MS);
+    renewTimer.unref?.();
+    let resumed;
+    try {
+      resumed = await state.activeSessionStore.resume(canonicalSessionId, onLoadProgress);
+    } finally {
+      clearInterval(renewTimer);
+    }
     openedWriter = resumed.writer;
+    hydrated = resumed.data;
+    setStage("activate_ownership");
+    await Promise.resolve(resumeClaim?.renew(RESERVATION_WINDOW_MS)).catch(() => void 0);
     if (resumeClaim) {
       await resumeClaim.activate({
         sessionId: canonicalSessionId,
@@ -1301,6 +1397,7 @@ async function resumeSession(ctx, sessionId) {
       identityClaimed = true;
       await state.activateSessionIdentity?.(canonicalSessionId);
     }
+    setStage("replay_history");
     const meta = resumed.data.metadata;
     const entries = replaySessionMessages(
       resumed.data.messages,
@@ -1308,6 +1405,7 @@ async function resumeSession(ctx, sessionId) {
       /* startId */
       1
     );
+    setStage("read_sidecars");
     const sessionsDir = state.wpaths.projectSessions;
     const resumedTodosPath = sessionScopedPath2(sessionsDir, resumed.writer.id, ".todos.json");
     const restoredTodos = await loadTodosCheckpoint(
@@ -1316,6 +1414,7 @@ async function resumeSession(ctx, sessionId) {
       agent.ctx.traceId,
       resumed.writer.id
     ).catch(() => null);
+    setStage("swap_writer");
     oldWriter = agent.ctx.session;
     oldMessages = [...agent.ctx.messages];
     agent.ctx.session = resumed.writer;
@@ -1327,7 +1426,11 @@ async function resumeSession(ctx, sessionId) {
       throw err;
     }
     writerSwapped = true;
-    if (state.sessionRef) state.sessionRef.current = resumed.writer;
+    if (state.sessionRef) {
+      oldSessionRefCurrent = state.sessionRef.current;
+      state.sessionRef.current = resumed.writer;
+    }
+    setStage("flush_journal");
     await agent.ctx.flushConversationJournal().catch((err) => {
       console.error(
         JSON.stringify({
@@ -1337,32 +1440,46 @@ async function resumeSession(ctx, sessionId) {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
+      warn("conversation journal did not flush", err);
     });
+    setStage("repoint_sidecars");
     previousDetachFn = state.detachActiveTodosCheckpoint;
     oldTodos = agent.ctx.state.todos ? [...agent.ctx.state.todos] : [];
     oldPlanPath = agent.ctx.state.meta?.["plan.path"];
     oldTaskPath = agent.ctx.state.meta?.["task.path"];
-    await Promise.resolve(previousDetachFn?.()).catch(() => void 0);
-    agent.ctx.state.setMeta(
-      "plan.path",
-      sessionScopedPath2(sessionsDir, resumed.writer.id, ".plan.json")
-    );
-    agent.ctx.state.setMeta(
-      "task.path",
-      sessionScopedPath2(sessionsDir, resumed.writer.id, ".tasks.json")
-    );
-    agent.ctx.state.replaceTodos(restoredTodos ?? []);
     try {
-      state.detachActiveTodosCheckpoint = attachTodosCheckpoint(
-        agent.ctx.state,
-        resumedTodosPath,
-        resumed.writer.id,
-        events,
-        agent.ctx.traceId
+      await Promise.resolve(previousDetachFn?.()).catch(() => void 0);
+      agent.ctx.state.setMeta(
+        "plan.path",
+        sessionScopedPath2(sessionsDir, resumed.writer.id, ".plan.json")
       );
-    } catch {
-      state.detachActiveTodosCheckpoint = void 0;
+      agent.ctx.state.setMeta(
+        "task.path",
+        sessionScopedPath2(sessionsDir, resumed.writer.id, ".tasks.json")
+      );
+      agent.ctx.state.replaceTodos(restoredTodos ?? []);
+      try {
+        state.detachActiveTodosCheckpoint = attachTodosCheckpoint(
+          agent.ctx.state,
+          resumedTodosPath,
+          resumed.writer.id,
+          events,
+          agent.ctx.traceId
+        );
+      } catch {
+        state.detachActiveTodosCheckpoint = void 0;
+      }
+    } catch (err) {
+      warn("todo/plan sidecars were not re-pointed", err);
+      try {
+        state.detachActiveTodosCheckpoint = previousDetachFn;
+        agent.ctx.state.replaceTodos([...oldTodos]);
+        if (oldPlanPath !== void 0) agent.ctx.state.setMeta("plan.path", oldPlanPath);
+        if (oldTaskPath !== void 0) agent.ctx.state.setMeta("task.path", oldTaskPath);
+      } catch {
+      }
     }
+    setStage("restore_model");
     const currentProviderId = agent.ctx.provider.id;
     const targetProviderId = typeof meta.provider === "string" && meta.provider.length > 0 ? meta.provider : currentProviderId;
     const targetModel = typeof meta.model === "string" && meta.model.length > 0 ? meta.model : agent.ctx.model;
@@ -1380,10 +1497,12 @@ async function resumeSession(ctx, sessionId) {
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           })
         );
+        warn(`could not restore ${targetProviderId}/${targetModel}`, err);
       }
     } else if (targetModel !== agent.ctx.model) {
       agent.ctx.model = targetModel;
     }
+    setStage("finalize_previous_session");
     let finalizeOldWriter;
     if (oldWriter && oldWriter !== resumed.writer) {
       const staleWriter = oldWriter;
@@ -1423,19 +1542,27 @@ async function resumeSession(ctx, sessionId) {
         }
       };
     }
-    tokenCounter.reset();
-    tokenCounter.account(resumed.data.usage, targetModel, targetProviderId);
-    if (typeof resumed.data.usage?.input === "number" && resumed.data.usage.input > 0) {
-      agent.ctx.lastRequestTokens = resumed.data.usage.input;
+    setStage("token_accounting");
+    try {
+      tokenCounter.reset();
+      tokenCounter.account(resumed.data.usage, targetModel, targetProviderId);
+    } catch (err) {
+      warn("token accounting for the resumed session failed", err);
     }
-    const reqTokens = tokenCounter.currentRequestTokens?.();
-    const tokens = (typeof reqTokens === "number" ? reqTokens : 0) + (typeof reqTokens?.input === "number" ? reqTokens.input : 0) + (typeof reqTokens?.cacheRead === "number" ? reqTokens.cacheRead : 0) + (typeof reqTokens?.cacheWrite === "number" ? reqTokens.cacheWrite : 0);
+    const resumedRequestTokens = projectLastRequestTokens(resumed.data.events);
+    agent.ctx.lastRequestTokens = resumedRequestTokens;
+    tokenCounter.setCurrentRequestTokens?.(resumedRequestTokens ?? 0);
+    const tokens = resumedRequestTokens ?? 0;
     const maxContext = agent.ctx.provider?.capabilities?.maxContext ?? 0;
+    const finalText = lastAssistantTextOf(resumed.data.messages);
     const result = {
       entries,
       nextId: entries.length + 1,
       sessionId: resumed.writer.id,
-      contextSnapshot: { tokens, maxContext }
+      contextSnapshot: { tokens, maxContext },
+      attached: true,
+      warnings,
+      ...finalText !== void 0 ? { lastAssistantText: finalText } : {}
     };
     if (finalizeOldWriter) void finalizeOldWriter();
     return result;
@@ -1459,6 +1586,7 @@ async function resumeSession(ctx, sessionId) {
     } else {
       try {
         if (oldWriter !== void 0) agent.ctx.session = oldWriter;
+        if (state.sessionRef) state.sessionRef.current = oldSessionRefCurrent;
         if (oldMessages !== void 0) agent.ctx.state.replaceMessages(oldMessages);
         if (previousDetachFn !== void 0) state.detachActiveTodosCheckpoint = previousDetachFn;
         agent.ctx.state.replaceTodos([...oldTodos]);
@@ -1474,16 +1602,76 @@ async function resumeSession(ctx, sessionId) {
           })
         );
       }
+      if (openedWriter && openedWriter !== oldWriter) {
+        await openedWriter.close().catch((closeErr) => {
+          console.error(
+            JSON.stringify({
+              level: "error",
+              event: "execution.resume_opened_writer_close_failed",
+              message: closeErr instanceof Error ? closeErr.message : String(closeErr),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        });
+      }
     }
+    const reason = err instanceof Error ? err.stack ?? err.message : String(err);
     console.error(
       JSON.stringify({
         level: "error",
         event: "execution.resume_session_failed",
-        message: err instanceof Error ? err.message : String(err),
+        sessionId: canonicalSessionId,
+        stage,
+        message: reason,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
-    return null;
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof Error && err.name === "SessionOwnershipConflictError") {
+      return fail(stage, message);
+    }
+    let data = hydrated;
+    if (!data) {
+      try {
+        data = await state.activeSessionStore.load(canonicalSessionId, onLoadProgress);
+      } catch {
+        data = void 0;
+      }
+    }
+    if (data) {
+      try {
+        const entries = replaySessionMessages(
+          data.messages,
+          data.events,
+          /* startId */
+          1
+        );
+        const finalText = lastAssistantTextOf(data.messages);
+        fail(stage, message);
+        return {
+          entries,
+          nextId: entries.length + 1,
+          sessionId: canonicalSessionId,
+          // Deliberately no contextSnapshot: the chip reports the LIVE
+          // window, and the live session is still the one we rolled back to.
+          // Painting the viewed session's fill over it would be a lie.
+          attached: false,
+          warnings: [...warnings, `not attached (at ${stage}): ${message}`],
+          ...finalText !== void 0 ? { lastAssistantText: finalText } : {}
+        };
+      } catch (renderErr) {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "execution.resume_readonly_render_failed",
+            sessionId: canonicalSessionId,
+            message: renderErr instanceof Error ? renderErr.message : String(renderErr),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+    }
+    return fail(stage, message);
   }
 }
 
@@ -1492,6 +1680,8 @@ import * as fs3 from "node:fs/promises";
 import * as path8 from "node:path";
 var SLICE_BYTES = 256 * 1024;
 var MAX_TITLE_CHARS = 80;
+var PICKER_POOL_CEILING = 1500;
+var ENRICH_CONCURRENCY = 16;
 function isStubSummary(s) {
   return !s.title && !s.endedAt;
 }
@@ -1502,7 +1692,10 @@ function containedJsonlPath(sessionsDir, id) {
   return file;
 }
 function stripControlChars(text) {
-  return text.replaceAll(/\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*(?:\x07|\x1b\\)|[\u0000-\u001f\u007f-\u009f]/g, "");
+  return text.replaceAll(
+    /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*(?:\x07|\x1b\\)|[\u0000-\u001f\u007f-\u009f]/g,
+    ""
+  );
 }
 function truncate(text) {
   const oneLine = stripControlChars(text).replaceAll(/\s+/g, " ").trim();
@@ -1574,32 +1767,48 @@ async function lastUserInput(file) {
 function effectiveLastActivity(s) {
   return s.lastActivityAt ?? s.endedAt ?? s.startedAt ?? "";
 }
+function hasActivity(s) {
+  return (s.messageCount ?? 0) > 0 || (s.iterationCount ?? 0) > 0 || (s.toolCallCount ?? 0) > 0 || (s.tokenTotal ?? 0) > 0 || Boolean(s.title?.trim()) || Boolean(s.lastUserMessage?.trim());
+}
 async function selectPickerSessions(storeList, sessionsDir, limit) {
-  const poolSize = Math.min(200, Math.max(limit, limit * 3));
+  const poolSize = Math.max(limit, Math.min(PICKER_POOL_CEILING, limit * 3));
   const enriched = await enrichStubSummaries(await storeList(poolSize), sessionsDir);
-  return enriched.sort((a, b) => effectiveLastActivity(b).localeCompare(effectiveLastActivity(a))).slice(0, limit);
+  return enriched.filter(hasActivity).sort((a, b) => effectiveLastActivity(b).localeCompare(effectiveLastActivity(a))).slice(0, limit);
 }
 async function enrichStubSummaries(summaries, sessionsDir) {
-  return Promise.all(
-    summaries.map(async (s) => {
-      if (!isStubSummary(s)) return s;
-      const file = containedJsonlPath(sessionsDir, s.id);
-      if (!file) return s;
+  const out = [...summaries];
+  const pending = summaries.reduce((indexes, summary, index) => {
+    if (isStubSummary(summary)) indexes.push(index);
+    return indexes;
+  }, []);
+  if (pending.length === 0) return out;
+  let cursor = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const slot = cursor++;
+      if (slot >= pending.length) return;
+      const index = pending[slot];
+      const summary = out[index];
+      const file = containedJsonlPath(sessionsDir, summary.id);
+      if (!file) continue;
       try {
         const stat3 = await fs3.stat(file);
         const [first, last] = await Promise.all([firstUserInput(file), lastUserInput(file)]);
         const title = truncate(first?.text ?? "");
-        return {
-          ...s,
+        out[index] = {
+          ...summary,
           ...title ? { title } : {},
           ...last ? { lastUserMessage: truncate(last.text) } : {},
           lastActivityAt: stat3.mtime.toISOString()
         };
       } catch {
-        return s;
       }
-    })
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(ENRICH_CONCURRENCY, pending.length) }, () => worker())
   );
+  return out;
 }
 
 // src/boot/tui-settings-adapter.ts
@@ -1695,6 +1904,7 @@ function createSettingsAdapter(ctx) {
       thinkingWord: normalizeTuiThinkingWord(autonomy?.thinkingWord),
       animationStyle: normalizeAnimationStyle(autonomy?.animationStyle),
       configScope: cfg.configScope ?? "global",
+      systemPromptVariant: cfg.systemPrompt?.variant === "lite" || cfg.systemPrompt?.variant === "pro" ? cfg.systemPrompt.variant : "default",
       enhanceDelayMs: cfg.autonomy?.enhanceDelayMs ?? 6e4,
       enhanceEnabled: cfg.autonomy?.enhance ?? true,
       enhanceLanguage: cfg.autonomy?.enhanceLanguage === "english" ? "english" : "original",
@@ -2451,7 +2661,7 @@ async function finalizeExecutionCleanup(input) {
         })
       );
     } else {
-      const { reportWrongTraceSessionTelemetry } = await import("./wrongtrace-telemetry-6M2CCBX5.js");
+      const { reportWrongTraceSessionTelemetry } = await import("./wrongtrace-telemetry-FNLANZ5I.js");
       const usage = tokenCounter.total();
       const report = reportWrongTraceSessionTelemetry({
         sessionId: activeSession.id,
@@ -2577,10 +2787,12 @@ import { stripFrontmatter } from "@wrongstack/core/skills";
 
 // src/kanban-dispatch-route.ts
 import { fallbackProfileChain, parseModelRef as parseModelRef2 } from "@wrongstack/core/agent";
+import { resolveTier } from "@wrongstack/core/coordination";
 function resolveKanbanDispatchRoute(config, spawnOpts) {
   let provider = spawnOpts?.provider;
   let model = spawnOpts?.model;
   let fallbackModels = spawnOpts?.fallbackModels;
+  let tier;
   if (spawnOpts?.fallbackProfile) {
     const chain = fallbackProfileChain(config, spawnOpts.fallbackProfile);
     const primary = chain[0] ? parseModelRef2(chain[0]) : void 0;
@@ -2589,8 +2801,19 @@ function resolveKanbanDispatchRoute(config, spawnOpts) {
       model = primary.model;
       fallbackModels = spawnOpts.fallbackModels ?? chain.slice(1);
     }
+  } else if (spawnOpts?.tier || spawnOpts?.role) {
+    const resolved = resolveTier(config, {
+      ...spawnOpts.tier ? { tier: spawnOpts.tier } : {},
+      ...spawnOpts.role ? { role: spawnOpts.role } : {}
+    });
+    if (resolved?.model) {
+      tier = resolved.tier;
+      provider = provider ?? resolved.provider ?? config.provider;
+      model = model ?? resolved.model;
+      fallbackModels = fallbackModels ?? (resolved.fallbackModels?.slice() ?? void 0);
+    }
   }
-  return { provider, model, fallbackModels };
+  return { provider, model, fallbackModels, ...tier ? { tier } : {} };
 }
 
 // src/execution-kanban-dispatch.ts
@@ -3156,7 +3379,14 @@ function buildChimeraReviewTaskDescription(p) {
       lines.push("```");
     } else if (f.status === "added") {
       lines.push("");
-      lines.push("(New file \u2014 full content provided)");
+      if (f.content && f.content.length <= 25e3) {
+        lines.push("(New file content:)");
+        lines.push("```");
+        lines.push(f.content);
+        lines.push("```");
+      } else {
+        lines.push("(New file \u2014 large content, use read tool only if needed)");
+      }
     }
     lines.push("");
   }
@@ -3218,10 +3448,11 @@ function buildChimeraReviewTaskDescription(p) {
   }
   lines.push("---");
   lines.push("");
-  lines.push("Read each file using the read tool. For modified files, focus on the");
-  lines.push("diff above \u2014 do not re-review unchanged pre-existing code.");
-  lines.push("Check for bugs, type issues, security problems, and produce a");
-  lines.push("structured review report.");
+  lines.push("**Review Instructions:**");
+  lines.push("- Review the diffs and new file contents carefully for real bugs, broken logic, null dereferences, and security gaps.");
+  lines.push("- Stay strictly within the scoped diffs. DO NOT audit unchanged files, pre-existing debt, or stylistic preferences.");
+  lines.push("- Use tools only when you need surrounding lines to verify a concrete issue.");
+  lines.push("- Once the diff is validated, output your report (findings or all-clear) promptly.");
   return lines.join("\n");
 }
 var CASCADE_EVIDENCE_INSTRUCTIONS = [
@@ -5317,12 +5548,15 @@ function createTuiNextStepCallbacks(input) {
 
 // src/tui-resource-menus.ts
 import { readdir } from "node:fs/promises";
+import { leaderTierPolicy, resolveTier as resolveTier2 } from "@wrongstack/core/coordination";
 import { readJsonObjectFile } from "@wrongstack/core/utils";
 function createTuiResourceMenuGetter(ctx) {
   return async (id) => {
     switch (id) {
       case "fallback":
         return fallbackMenu(ctx.configStore);
+      case "tier":
+        return tierMenu(ctx.configStore);
       case "profile":
         return profileMenu(ctx.configStore, ctx.paths);
       case "provider-status":
@@ -5425,6 +5659,95 @@ function fallbackMenu(store) {
     items
   };
 }
+function tierMenu(store) {
+  const config = store.get();
+  const tiers = config.modelTiers;
+  const enabled = tiers?.enabled === true;
+  const levels = tiers?.levels ?? {};
+  const routing = tiers?.routing ?? {};
+  const policy = leaderTierPolicy(config);
+  const levelIds = Object.keys(levels);
+  const items = [
+    {
+      id: "enabled",
+      label: "Model tiers",
+      status: enabled ? "good" : "muted",
+      summary: enabled ? "enabled" : "disabled",
+      details: [
+        { label: "levels", value: String(levelIds.length) },
+        { label: "routing rules", value: String(Object.keys(routing).length) },
+        { label: "default", value: tiers?.default ?? "standard" }
+      ],
+      body: "A tier binds a fallback profile, a spend budget and a runtime setting under one name, then routes work to it by role or phase. While disabled, spawns resolve exactly as they did before tiers existed.",
+      actions: [
+        { key: "t", label: enabled ? "turn off" : "turn on", command: `/tier ${enabled ? "off" : "on"}` }
+      ]
+    },
+    {
+      id: "leader",
+      label: "Leader self-switching",
+      status: policy.mode === "auto" ? "warn" : policy.mode === "propose" ? "good" : "muted",
+      summary: policy.mode,
+      details: [
+        { label: "mode", value: policy.mode },
+        { label: "dwell", value: `${policy.dwellTurns} turn(s)` },
+        { label: "min saving", value: `$${policy.minSavingsUsd}` },
+        { label: "context cap", value: `${Math.round(policy.maxContextFillForSwitch * 100)}%` },
+        { label: "ceiling", value: policy.maxTier ?? "none" }
+      ],
+      body: "propose (default): the leader asks before changing its own model. auto: it applies the switch itself, still bounded by dwell, context window, ceiling and a break-even test against the prompt-cache re-warm the switch costs. off: it never self-switches.",
+      actions: [
+        { key: "p", label: "propose", command: "/tier leader propose" },
+        { key: "a", label: "auto", command: "/tier leader auto", confirm: true },
+        { key: "o", label: "off", command: "/tier leader off" }
+      ]
+    },
+    ...levelIds.map((id, index) => {
+      const level = levels[id];
+      const resolved = enabled ? resolveTier2(config, { tier: id }) : void 0;
+      const routedBy = Object.entries(routing).filter(([, value]) => value === id).map(([key]) => key);
+      return {
+        id: `level:${id}`,
+        label: `${index + 1}. ${id}`,
+        status: level?.fallbackProfile ? "good" : "muted",
+        summary: resolved?.model ? `${resolved.provider ?? config.provider}/${resolved.model}` : level?.fallbackProfile ?? "(no profile)",
+        details: [
+          { label: "rung", value: `${index + 1} of ${levelIds.length}` },
+          { label: "profile", value: level?.fallbackProfile ?? "(none)" },
+          { label: "max cost", value: level?.maxCostUsd !== void 0 ? `$${level.maxCostUsd}` : "(role default)" },
+          { label: "max iterations", value: level?.maxIterations !== void 0 ? String(level.maxIterations) : "(role default)" },
+          { label: "routed by", value: routedBy.join(", ") || "(nothing)" }
+        ],
+        body: [
+          resolved?.fallbackModels?.length ? `Failover: ${resolved.fallbackModels.join(" \u2192 ")}` : "No failover chain \u2014 the profile has a single entry.",
+          "Declaration order is the ladder: rung 1 is the cheapest."
+        ].join("\n"),
+        actions: [
+          { key: "x", label: "delete", command: `/tier remove ${id}`, confirm: true },
+          { key: "d", label: "make default", command: `/tier default ${id}` }
+        ]
+      };
+    }),
+    ...Object.entries(routing).sort(([a], [b]) => a.localeCompare(b)).map(([key, tier]) => ({
+      id: `route:${key}`,
+      label: `${key} \u2192 ${tier}`,
+      status: levels[tier] ? "good" : "warn",
+      summary: levels[tier] ? "routing rule" : "points at a missing level",
+      details: [
+        { label: "key", value: key },
+        { label: "tier", value: tier },
+        { label: "kind", value: key === "*" ? "default" : "role or phase" }
+      ],
+      actions: [{ key: "x", label: "remove", command: `/tier unroute ${key}`, confirm: true }]
+    }))
+  ];
+  return {
+    id: "tier",
+    title: "Model cost tiers",
+    subtitle: enabled ? `${levelIds.length} level(s) \xB7 ${Object.keys(routing).length} rule(s) \xB7 leader: ${policy.mode}` : "disabled",
+    items
+  };
+}
 async function profileMenu(store, paths) {
   const active = store.get().activeProfile ?? paths.profileName ?? "default";
   let names = [];
@@ -5744,6 +6067,7 @@ async function execute(deps) {
     fleet: {
       director,
       getDirector,
+      releaseSessionHelpers,
       coordinatorController,
       fleetRoster,
       fleetStreamController,
@@ -5756,12 +6080,16 @@ async function execute(deps) {
       interruptController,
       enhanceController,
       getEnhancerReasoning,
+      getActiveModelReasoningEffortLevels,
       buildEnhancerProvider,
       getEnhanceFallbackRef,
       getConfiguredRefinerRef,
       statuslineHiddenItems,
       setStatuslineHiddenItems,
       saveStatuslineHiddenItems,
+      statuslineLines,
+      setStatuslineLines,
+      saveStatuslineLines,
       getYolo,
       onYolo,
       getAutonomy,
@@ -6054,12 +6382,16 @@ async function execute(deps) {
           interruptController,
           enhanceController,
           getEnhancerReasoning,
+          getActiveModelReasoningEffortLevels,
           buildEnhancerProvider,
           getEnhanceFallbackRef,
           getConfiguredRefinerRef,
           statuslineHiddenItems,
           setStatuslineHiddenItems,
           saveStatuslineHiddenItems,
+          statuslineLines,
+          setStatuslineLines,
+          saveStatuslineLines,
           getPluginItems,
           onPluginToggle,
           getMcpServers,
@@ -6121,6 +6453,17 @@ async function execute(deps) {
               wpaths.projectSessions,
               limit
             );
+            const liveBySession = /* @__PURE__ */ new Map();
+            try {
+              for (const entry of await getLiveSessions({ state })) {
+                if (entry.pid == null) continue;
+                liveBySession.set(entry.sessionId, {
+                  pid: entry.pid,
+                  ...entry.clientType ? { clientType: entry.clientType } : {}
+                });
+              }
+            } catch {
+            }
             const currentId = agent.ctx.session?.id ?? session.id;
             return summaries.map((s) => ({
               id: s.id,
@@ -6136,13 +6479,39 @@ async function execute(deps) {
               toolCallCount: s.toolCallCount ?? 0,
               toolErrorCount: s.toolErrorCount ?? 0,
               outcome: s.outcome,
-              isCurrent: s.id === currentId
+              isCurrent: s.id === currentId,
+              // The session this process owns is `isCurrent`, not "live
+              // elsewhere" — it holds its own lease and would otherwise be
+              // labelled as owned by another surface.
+              ...s.id !== currentId && liveBySession.has(s.id) ? { live: liveBySession.get(s.id) } : {}
             }));
           },
-          onResumeSession: (sessionId) => resumeSession(
-            { state, agent, tokenCounter, switchProviderAndModel, events },
-            sessionId
-          ),
+          onResumeSession: async (sessionId, onLoadProgress, onStage) => {
+            let failure;
+            const result = await resumeSession(
+              {
+                state,
+                agent,
+                tokenCounter,
+                switchProviderAndModel,
+                events,
+                onLoadProgress,
+                onStage,
+                onFailure: (info) => {
+                  failure = info;
+                }
+              },
+              sessionId
+            );
+            if (!result) {
+              throw new Error(
+                failure ? `${failure.message} (at ${failure.stage})` : `Session "${sessionId}" could not be resumed.`
+              );
+            }
+            setAutoSuggestions([]);
+            const resumedNextSteps = result.attached && !hasOpenTodos3(agent.ctx.todos) && result.lastAssistantText ? parseNextSteps2(result.lastAssistantText).texts : [];
+            return { ...result, nextSteps: resumedNextSteps };
+          },
           getProjectPickerItems: () => getProjectPickerItems(pickerCtx),
           onProjectSelect: (slug, kind) => onProjectSelect(pickerCtx, slug, kind),
           initialAgentsMonitorOpen: !!flags.quick,
@@ -6198,6 +6567,19 @@ async function execute(deps) {
         statusTracker,
         updateInfo: bootUpdateInfo,
         webuiSessionChild,
+        // Stopping a tab's run stops the work that tab started — its
+        // subagents included. Aborting the leader's controller only unwinds
+        // workers it is BLOCKED on; anything started with `spawn_subagent` +
+        // `assign_task` keeps going unless asked to stop. Scoped to the
+        // session so one tab's Stop never reaches another tab's fleet.
+        stopSessionFleet: async (sessionId) => {
+          await getDirector?.()?.terminateSession(sessionId);
+        },
+        // Closing a tab is not stopping it. The run keeps going and keeps its
+        // fleet; what goes is the background help pinned to that conversation
+        // — the explore companion's poll timer and the shadow reviewer's
+        // bookkeeping — which nobody is watching any more.
+        ...releaseSessionHelpers ? { onSessionRetired: releaseSessionHelpers } : {},
         getFleetBudget: () => {
           const d = getDirector?.() ?? null;
           if (!d) return null;
@@ -6305,4 +6687,4 @@ export {
   execute,
   resolveReviewerFallbackModels
 };
-//# sourceMappingURL=execution-L4CXQEND.js.map
+//# sourceMappingURL=execution-TZUGCKFU.js.map