@turmind/halo 1.5.0-alpha → 1.5.2-alpha

package/dist/index.js

@@ -512,7 +512,6 @@ function generalSection() {
       { key: "compact.keep_messages", type: "int", globalOnly: true, description: "Recent messages kept intact during compaction", description_zh: "\u538B\u7F29\u65F6\u4FDD\u7559\u6700\u540E\u591A\u5C11\u6761\u6D88\u606F\u4E0D\u52A8", default: "5" },
       { key: "compact.max_summary_input", type: "int", globalOnly: true, description: "Max chars fed into local truncation fallback", description_zh: "\u672C\u5730\u622A\u65AD\u515C\u5E95\u65F6\u7684\u603B\u8F93\u5165\u5B57\u7B26\u4E0A\u9650", default: "15000" },
       { key: "compact.max_message_slice", type: "int", globalOnly: true, description: "Max chars kept per old message during local truncation", description_zh: "\u672C\u5730\u622A\u65AD\u515C\u5E95\u65F6\u6BCF\u6761\u65E7\u6D88\u606F\u4FDD\u7559\u7684\u6700\u5927\u5B57\u7B26\u6570", default: "800" },
-      { key: "compact.summarize_timeout_sec", type: "int", globalOnly: true, description: "LLM summarization timeout (seconds)", description_zh: "LLM \u6458\u8981\u8D85\u65F6\u65F6\u95F4\uFF08\u79D2\uFF09", default: "300" },
       // sandbox (Linux bwrap / macOS sandbox-exec) — global-only: these define the security
       // boundary agents run inside; a workspace overriding them could lift
       // its own sandbox constraints.
@@ -1149,9 +1148,10 @@ var init_config = __esm({
         // connection (server accepted but never sends bytes / sends no RST) hangs
         // the await indefinitely. Bounds each callModel; on expiry the request
         // aborts and the agent loop's retry takes over. Streaming providers reset
-        // the timer on every chunk, so for them it is an idle timeout — a long but
-        // live stream is never cut off.
-        modelRequest: systemInt("HALO_MODEL_TIMEOUT", "timeout.model_request", 30 * 6e4),
+        // the timer on any data the stream delivers (pings, tool-argument
+        // fragments, SSE comments included), so for them it is an idle timeout — a
+        // long but live stream is never cut off.
+        modelRequest: systemInt("HALO_MODEL_TIMEOUT", "timeout.model_request", 10 * 6e4),
         sessionGrace: systemInt("HALO_SESSION_GRACE", "timeout.session_grace", 5 * 6e4),
         terminalGrace: systemInt("HALO_TERMINAL_GRACE", "timeout.terminal_grace", 5 * 6e4)
       },
@@ -1188,8 +1188,7 @@ var init_config = __esm({
       compact: {
         keep_messages: settingsInt("general.compact.keep_messages", 5),
         max_summary_input: settingsInt("general.compact.max_summary_input", 15e3),
-        max_message_slice: settingsInt("general.compact.max_message_slice", 800),
-        summarize_timeout_sec: settingsInt("general.compact.summarize_timeout_sec", 300)
+        max_message_slice: settingsInt("general.compact.max_message_slice", 800)
       },
       auth: {
         tokenMaxAge: 14 * 24 * 60 * 60,
@@ -1431,8 +1430,10 @@ var init_model_error = __esm({
 });
 
 // ../server/dist/agents/compact.js
-function splitForCompact(messages2) {
+function compactCut(messages2) {
   const keepCount = config.compact.keep_messages;
+  if (messages2.length <= keepCount)
+    return 0;
   let cut = Math.max(0, messages2.length - keepCount);
   while (cut < messages2.length) {
     const m = messages2[cut];
@@ -1443,7 +1444,7 @@ function splitForCompact(messages2) {
     }
     break;
   }
-  return { recentMsgs: messages2.slice(cut), olderMsgs: messages2.slice(0, cut) };
+  return cut;
 }
 function messageText(m) {
   const content = m.content;
@@ -1453,12 +1454,11 @@ function messageText(m) {
   return String(content ?? "");
 }
 function localCompactMessages(messages2) {
-  if (!messages2 || messages2.length <= config.compact.keep_messages) {
-    return { compacted: false, messages: messages2 };
-  }
-  const { recentMsgs, olderMsgs } = splitForCompact(messages2);
-  if (olderMsgs.length === 0)
+  const cut = messages2 ? compactCut(messages2) : 0;
+  if (cut === 0)
     return { compacted: false, messages: messages2 };
+  const recentMsgs = messages2.slice(cut);
+  const olderMsgs = messages2.slice(0, cut);
   const maxSlice = config.compact.max_message_slice;
   const lines = [];
   for (const m of olderMsgs) {
@@ -1621,7 +1621,7 @@ function toolResultImages(content) {
   }
   return images.length > 0 ? [{ type: "text", text: "[Images from the tool results above]" }, ...images] : [];
 }
-var TOOL_ERROR_MARKER, TOOL_WARN_MARKER, MODEL_TIMEOUT_ERROR, INTERRUPTED_REPLY_MARKER, AgentLoop;
+var TOOL_ERROR_MARKER, TOOL_WARN_MARKER, MODEL_TIMEOUT_ERROR, INTERRUPTED_REPLY_MARKER, ACTIVITY_DELTA, AgentLoop;
 var init_agent_loop = __esm({
   "../server/dist/agents/agent-loop.js"() {
     "use strict";
@@ -1630,6 +1630,7 @@ var init_agent_loop = __esm({
     TOOL_WARN_MARKER = "__TOOL_WARN__";
     MODEL_TIMEOUT_ERROR = "Model request timed out";
     INTERRUPTED_REPLY_MARKER = "\n\n[reply interrupted by the user here \u2014 the text above is what was shown before the cut]";
+    ACTIVITY_DELTA = { type: "activity", text: "" };
     AgentLoop = class {
       tools;
       messages = [];
@@ -1676,8 +1677,10 @@ var init_agent_loop = __esm({
               }
             };
             const call = this.callModel(callSignal, (d) => {
-              deltas.push(d);
               timer.refresh();
+              if (d.type === "activity")
+                return;
+              deltas.push({ type: d.type, text: d.text });
               notify();
             });
             call.then(() => {
@@ -2618,7 +2621,7 @@ var init_init = __esm({
       path8.resolve(__dirname, "..", "bundled-docs"),
       path8.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 74;
+    TEMPLATE_VERSION = 76;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -3587,7 +3590,8 @@ async function deliverGoalRound(host, worker) {
     return;
   let report = worker.finalOutput || worker.output || "(no output)";
   if (worker.turnError) {
-    report = `[WORKER ABORTED: this round was terminated by an unrecoverable error, NOT a normal wrap-up. Error: ${worker.turnError}. The text below is a partial trace of the aborted turn \u2014 judge this as an interrupted round, do not score it as a completed result. Re-dispatch with query_session to let the worker resume.]
+    const next = worker.turnErrorKind === "account" ? `This is a model account / credential / balance / permission problem: retrying or re-dispatching will fail the same way. Fix the model configuration first (or tell the user to fix it), and do not resume the worker with query_session until then.` : `Re-dispatch with query_session to let the worker resume.`;
+    report = `[WORKER ABORTED: this round was terminated by an unrecoverable error, NOT a normal wrap-up. Error: ${worker.turnError}. The text below is a partial trace of the aborted turn \u2014 judge this as an interrupted round, do not score it as a completed result. ${next}]
 
 ${report}`;
   }
@@ -4907,6 +4911,10 @@ function execStop(ctx) {
   const active = findActiveSessionId(ctx.sm, ctx.userId, ctx.sessionPrefix, ctx.activeOverrides, ctx.accessLevel);
   if (!active)
     return { text: t("stop.no_session", ctx.lang) };
+  if (ctx.sm.isSessionCompacting(active) && !ctx.sm.isSessionRunning(active)) {
+    ctx.sm.cancelCompact(active);
+    return { text: t("stop.done", ctx.lang) };
+  }
   if (!ctx.sm.isSessionRunning(active))
     return { text: t("stop.already_idle", ctx.lang) };
   ctx.sm.stopSession(active).catch(() => {
@@ -4917,6 +4925,10 @@ function execInterrupt(ctx) {
   const active = findActiveSessionId(ctx.sm, ctx.userId, ctx.sessionPrefix, ctx.activeOverrides, ctx.accessLevel);
   if (!active)
     return { text: t("interrupt.no_session", ctx.lang) };
+  if (ctx.sm.isSessionCompacting(active) && !ctx.sm.isSessionRunning(active)) {
+    ctx.sm.cancelCompact(active);
+    return { text: t("interrupt.done", ctx.lang) };
+  }
   if (!ctx.sm.isSessionRunning(active))
     return { text: t("interrupt.already_idle", ctx.lang) };
   ctx.sm.interruptSession(active);
@@ -5617,6 +5629,14 @@ function writeReplyTo(db, sessionId, to) {
 function clearReplyTo(db, sessionId) {
   db.update(agentSessions).set({ replyTo: null }).where(eq3(agentSessions.id, sessionId)).run();
 }
+function listActiveChildren(db, sessionId) {
+  return db.select({
+    agentName: agentSessions.agentName,
+    description: agentSessions.description,
+    createdAt: agentSessions.createdAt,
+    updatedAt: agentSessions.updatedAt
+  }).from(agentSessions).where(and3(eq3(agentSessions.parentId, sessionId), isNull2(agentSessions.stoppedAt), isNull2(agentSessions.archivedAt))).all();
+}
 async function deliverRelayReport(host, session) {
   if (session.parentId !== null)
     return;
@@ -5624,8 +5644,7 @@ async function deliverRelayReport(host, session) {
   const to = readReplyTo(db, session.id);
   if (!to)
     return;
-  const activeChildren = db.select({ id: agentSessions.id }).from(agentSessions).where(and3(eq3(agentSessions.parentId, session.id), isNull2(agentSessions.stoppedAt), isNull2(agentSessions.archivedAt))).all();
-  if (activeChildren.length > 0 || session.messageQueue.length > 0)
+  if (listActiveChildren(db, session.id).length > 0 || session.messageQueue.length > 0)
     return;
   const registry2 = getRelayRegistry();
   if (!registry2) {
@@ -5634,7 +5653,8 @@ async function deliverRelayReport(host, session) {
   }
   let report = session.finalOutput || session.output || "(no output)";
   if (session.turnError) {
-    report = `[RELAY TARGET ABORTED: the last turn was terminated by an unrecoverable error, NOT completed. Error: ${session.turnError}. The text below is a partial trace \u2014 do not treat it as a finished result. Re-send with relay_send to let it resume.]
+    const next = session.turnErrorKind === "account" ? "This is a model account / credential / balance / permission problem in the target workspace: retrying or re-sending will fail the same way. Fix its model configuration first (or tell the user to fix it), and do not resume it with relay_send until then." : "Re-send with relay_send to let it resume.";
+    report = `[RELAY TARGET ABORTED: the last turn was terminated by an unrecoverable error, NOT completed. Error: ${session.turnError}. The text below is a partial trace \u2014 do not treat it as a finished result. ${next}]
 
 ${report}`;
   }
@@ -6027,6 +6047,14 @@ function claimWorkspaceRuntime(workspaceRoot) {
     return false;
   }
 }
+function releaseWorkspaceRuntime(workspaceRoot) {
+  const lockPath = path21.join(workspaceRoot, ".halo", RUNTIME_LOCK_FILE);
+  try {
+    if (parseInt(fs19.readFileSync(lockPath, "utf-8").trim(), 10) === process.pid)
+      fs19.unlinkSync(lockPath);
+  } catch {
+  }
+}
 var RUNTIME_LOCK_FILE;
 var init_workspace_runtime_lock = __esm({
   "../server/dist/agents/workspace-runtime-lock.js"() {
@@ -6750,7 +6778,7 @@ function createSaveSnapshot(state) {
     tempMsg.contentBlocks = [...state.turnContentBlocks];
   return [...state.messageLog, tempMsg];
 }
-function initSubSessionLog(state, taskId, agentId, agentName, text6) {
+function initSubSessionLog(state, taskId, agentId, agentName, text6, loadHistory2) {
   const existing = state.subSessionLogs.get(taskId);
   if (existing) {
     existing.agentId = agentId;
@@ -6762,12 +6790,15 @@ function initSubSessionLog(state, taskId, agentId, agentName, text6) {
     }
     return;
   }
+  const messageLog = loadHistory2?.(taskId) ?? [];
+  if (text6)
+    messageLog.push({ id: genId(), type: "user", role: "user", content: text6, timestamp: Date.now(), agentName });
   state.subSessionLogs.set(taskId, {
     agentId,
     agentName,
     description: text6,
     streamingAgent: agentName,
-    messageLog: text6 ? [{ id: genId(), type: "user", role: "user", content: text6, timestamp: Date.now(), agentName }] : [],
+    messageLog,
     streamBuffer: "",
     turnToolCalls: [],
     turnContentBlocks: [],
@@ -6800,12 +6831,12 @@ function buildUsageMsg(event, agentName, taskId, turnId) {
     turnId
   };
 }
-function applyEvent(state, event) {
+function applyEvent(state, event, loadHistory2) {
   const agentName = event.agentName ?? "default";
   const taskId = event.taskId;
-  const result = { shouldSave: false, isComplete: false };
+  const result = { taskId };
   if (taskId && event.type !== "agent_start" && event.type !== "agent_done" && !state.subSessionLogs.has(taskId)) {
-    initSubSessionLog(state, taskId, event.agentId ?? "", agentName, "");
+    initSubSessionLog(state, taskId, event.agentId ?? "", agentName, "", loadHistory2);
   }
   switch (event.type) {
     // Streaming chunks land in the turn blocks as they arrive; the whole
@@ -6841,7 +6872,7 @@ function applyEvent(state, event) {
         });
       }
       if (taskId)
-        initSubSessionLog(state, taskId, event.agentId ?? "", agentName, event.fullText ?? event.text ?? "");
+        initSubSessionLog(state, taskId, event.agentId ?? "", agentName, event.fullText ?? event.text ?? "", loadHistory2);
       break;
     case "agent_done":
       if (!taskId) {
@@ -6860,7 +6891,7 @@ function applyEvent(state, event) {
         const sub = state.subSessionLogs.get(taskId);
         if (sub)
           flushAssistantMessage(sub);
-        result.subSessionDone = taskId;
+        result.persist = "flush";
       }
       break;
     case "tool_call": {
@@ -6878,7 +6909,7 @@ function applyEvent(state, event) {
         toolInput: event.toolInput
       };
       addToolCall(getTarget(state, taskId), entry, msg);
-      result.shouldSave = true;
+      result.persist = "debounce";
       break;
     }
     case "tool_result": {
@@ -6896,7 +6927,7 @@ function applyEvent(state, event) {
         toolOutput: event.toolResult,
         durationMs: event.durationMs
       });
-      result.shouldSave = true;
+      result.persist = "debounce";
       break;
     }
     case "followup_start":
@@ -6914,10 +6945,9 @@ function applyEvent(state, event) {
         if (sub) {
           sub.messageLog.push(buildUsageMsg(event, agentName, taskId, sub.currentTurnId));
           sub.currentTurnId = randomUUID();
-          result.subSessionSave = taskId;
         }
       }
-      result.shouldSave = true;
+      result.persist = "debounce";
       break;
     }
     case "complete":
@@ -6925,8 +6955,7 @@ function applyEvent(state, event) {
       state.turnToolCalls = [];
       state.turnContentBlocks = [];
       state.currentTurnId = randomUUID();
-      result.shouldSave = true;
-      result.isComplete = true;
+      result.persist = "flush";
       break;
     case "context": {
       const ctxMsg = {
@@ -6943,12 +6972,11 @@ function applyEvent(state, event) {
         state.messageLog.push(ctxMsg);
       } else {
         if (!state.subSessionLogs.has(taskId)) {
-          initSubSessionLog(state, taskId, event.agentId ?? "", agentName, "");
+          initSubSessionLog(state, taskId, event.agentId ?? "", agentName, "", loadHistory2);
         }
         state.subSessionLogs.get(taskId).messageLog.push(ctxMsg);
-        result.subSessionSave = taskId;
       }
-      result.shouldSave = true;
+      result.persist = "debounce";
       break;
     }
     case "queued_message":
@@ -6965,8 +6993,7 @@ function applyEvent(state, event) {
         timestamp: Date.now(),
         agentName: "System"
       });
-      if (taskId)
-        result.subSessionSave = taskId;
+      result.persist = "debounce";
       break;
     }
     case "error":
@@ -6979,6 +7006,8 @@ function applyEvent(state, event) {
         agentName,
         taskId
       });
+      result.taskId = void 0;
+      result.persist = "debounce";
       break;
     case "compacted":
       if (!taskId)
@@ -6994,9 +7023,7 @@ function applyEvent(state, event) {
         content: event.text ?? "",
         timestamp: Date.now()
       });
-      if (taskId)
-        result.subSessionSave = taskId;
-      result.shouldSave = true;
+      result.persist = "debounce";
       break;
     }
   }
@@ -7042,14 +7069,16 @@ var init_session_ui_store = __esm({
       uiStates = /* @__PURE__ */ new Map();
       /** Project path for each root session, needed for disk persistence */
       uiStateProjectPaths = /* @__PURE__ */ new Map();
-      /** Debounced persist timers — prevents flooding disk with writes during rapid tool loops */
+      /** Debounced persist timers — prevents flooding disk with writes during rapid
+       *  tool loops. Keyed by root id for a root's log, by taskId (`root>…`) for a
+       *  sub-session's own file. */
       persistTimers = /* @__PURE__ */ new Map();
       /** Last activity (event reduced / view built) per uiStates key — the idle
        *  sweep's eviction clock. Invariant: every uiStates key has an entry. */
       uiStateTouched = /* @__PURE__ */ new Map();
       /** Roots whose in-memory UIState holds local mutations (event reduced in,
        *  notification appended, log replaced) **not yet persisted** — marked on
-       *  every mutation, cleared once persistUIState lands the snapshot. A state
+       *  every mutation, cleared once persistLog lands the snapshot. A state
        *  not in this set adds nothing to what's on disk: either it's a pure disk
        *  seed (built to *view* a session another process may be driving — a cron
        *  `halo cli` child shares the workspace's session files and keeps appending
@@ -7147,51 +7176,58 @@ var init_session_ui_store = __esm({
         this.eventHandler?.(event);
       }
       /**
-       * Fold an event into the root session's UIState and persist to disk if the
-       * reducer signals `shouldSave`. Builds the state lazily from disk if
-       * needed.
+       * Fold an event into the root session's UIState and persist the log it
+       * changed — the root's or a sub-session's, same rule (see applyEvent).
+       * Builds the state lazily from disk if needed.
        */
       reduceIntoUIState(rootId, event) {
         try {
           const state = this.ensureUIState(rootId);
-          this.uiStateDirty.add(rootId);
-          const result = applyEvent(state, event);
-          if (result.subSessionSave) {
-            this.persistSubSession(state, rootId, result.subSessionSave);
-          }
-          if (result.subSessionDone) {
-            this.persistSubSession(state, rootId, result.subSessionDone);
-            state.subSessionLogs.delete(result.subSessionDone);
-          }
-          if (result.shouldSave) {
-            if (result.isComplete) {
-              this.flushPersist(rootId, state);
-            } else {
-              this.debouncedPersist(rootId, state);
-            }
-          }
+          const { taskId, persist } = applyEvent(state, event, this.loadSubHistory);
+          if (!taskId)
+            this.uiStateDirty.add(rootId);
+          const id = taskId ?? rootId;
+          if (persist === "flush")
+            this.flushPersist(id, state);
+          else if (persist === "debounce")
+            this.debouncedPersist(id, state);
+          if (taskId && event.type === "agent_done")
+            state.subSessionLogs.delete(taskId);
         } catch (err) {
           console.error(`[SessionUIStore] reduceIntoUIState failed for ${rootId}: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
-      /** Debounced persist — coalesces rapid tool_call/tool_result saves into one write */
-      debouncedPersist(rootId, state) {
-        const existing = this.persistTimers.get(rootId);
+      /** A new sub-session log starts from the sub's own file, the way
+       *  ensureUIState seeds a root — so persistLog can overwrite it whole. */
+      loadSubHistory = (taskId) => {
+        const projectPath = this.uiStateProjectPaths.get(this.findRootSessionId(taskId)) ?? this.host.workspaceRoot;
+        return loadSessionMessages(taskId, projectPath, this.resolveAgentId(taskId));
+      };
+      /** Debounced persist — coalesces rapid tool_call/tool_result saves into one
+       *  write. `id` is the log's own session id (root, or a sub's `root>…`
+       *  taskId), which keys the timer and names the file. */
+      debouncedPersist(id, state) {
+        const existing = this.persistTimers.get(id);
         if (existing)
           clearTimeout(existing);
-        this.persistTimers.set(rootId, setTimeout(() => {
-          this.persistTimers.delete(rootId);
-          this.persistUIState(rootId, state);
+        this.persistTimers.set(id, setTimeout(() => {
+          this.persistTimers.delete(id);
+          this.persistLog(id, state);
         }, 500));
       }
-      /** Flush pending persist immediately (on complete/disconnect) */
-      flushPersist(rootId, state) {
-        const existing = this.persistTimers.get(rootId);
+      /** Flush pending persist immediately (turn end, interrupt, release, drop). */
+      flushPersist(id, state) {
+        const existing = this.persistTimers.get(id);
         if (existing) {
           clearTimeout(existing);
-          this.persistTimers.delete(rootId);
+          this.persistTimers.delete(id);
         }
-        this.persistUIState(rootId, state);
+        this.persistLog(id, state);
+      }
+      /** Sub-sessions of `rootId` with a debounced write still pending. */
+      pendingSubPersists(rootId) {
+        const prefix = `${rootId}>`;
+        return [...this.persistTimers.keys()].filter((key) => key.startsWith(prefix));
       }
       /**
        * Ensure UIState for a root session. On first access for a session that
@@ -7224,17 +7260,40 @@ var init_session_ui_store = __esm({
         this.uiStates.set(rootId, state);
         return state;
       }
-      /** Persist UI state (root messages + token counts) to disk.
-       *  `archive` is passed ONLY by archiveOldMessages (the commit step of an
-       *  archive write): `count` is the new segment count and `userDelta` the main
-       *  user turns leaving the active file. Every other call leaves both on-disk
-       *  values alone. */
-      persistUIState(rootId, state, archive) {
+      /** Persist one UI log to its own file, overwriting it whole: the root's
+       *  (`id` = root id: messages + token counts) or a sub-session's (`id` =
+       *  taskId: `state.subSessionLogs[id]`, which holds the sub's full history —
+       *  see loadSubHistory — plus the in-flight turn as a temp assistant, the
+       *  same snapshot the root writes). `archive` is passed ONLY by
+       *  archiveOldMessages (the commit step of an archive write): `count` is the
+       *  new segment count and `userDelta` the main user turns leaving the active
+       *  file. Every other call leaves both on-disk values alone. */
+      persistLog(id, state, archive) {
+        const rootId = this.findRootSessionId(id);
+        const sub = id === rootId ? void 0 : state.subSessionLogs.get(id);
+        if (id !== rootId && (!sub || this.host.isSessionDeleted(rootId)))
+          return;
         try {
           const projectPath = this.uiStateProjectPaths.get(rootId) ?? this.host.workspaceRoot;
-          const snapshot2 = createSaveSnapshot(state);
+          const snapshot2 = createSaveSnapshot(sub ?? state);
           if (snapshot2.length === 0)
             return;
+          if (sub) {
+            const parts = id.split(">");
+            this.host.persistSessionFile({
+              sessionId: id,
+              projectPath,
+              messages: snapshot2,
+              contextTokens: 0,
+              outputTokens: 0,
+              agentId: this.resolveAgentId(id),
+              agentName: sub.agentName,
+              source: "delegated",
+              description: sub.description,
+              parentSessionId: parts.slice(0, -1).join(">")
+            });
+            return;
+          }
           const inMem = this.host.getSession(rootId);
           const row = inMem ? null : this.db.select().from(agentSessions).where(eq6(agentSessions.id, rootId)).get();
           this.host.persistSessionFile({
@@ -7253,7 +7312,7 @@ var init_session_ui_store = __esm({
           });
           this.uiStateDirty.delete(rootId);
         } catch (err) {
-          console.error(`[SessionUIStore] persistUIState failed for ${rootId}: ${err instanceof Error ? err.message : String(err)}`);
+          console.error(`[SessionUIStore] persistLog failed for ${id}: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
       /**
@@ -7300,7 +7359,7 @@ var init_session_ui_store = __esm({
           const n = readArchiveCount(dir, seg) + 1;
           writeArchiveSegment(dir, seg, n, older);
           state.messageLog = kept;
-          this.persistUIState(rootId, state, { count: n, userDelta: countMainUserMessages(older) });
+          this.persistLog(rootId, state, { count: n, userDelta: countMainUserMessages(older) });
           if (readArchiveCount(dir, seg) < n) {
             state.messageLog = [...older, ...kept];
             console.warn(`[SessionUIStore] archive commit for ${rootId} segment ${n} did not land \u2014 rolled back`);
@@ -7313,37 +7372,6 @@ var init_session_ui_store = __esm({
           return 0;
         }
       }
-      /** Persist a sub-session's UI log to its own disk file */
-      persistSubSession(state, rootId, taskId) {
-        if (this.host.isSessionDeleted(rootId))
-          return;
-        const sub = state.subSessionLogs.get(taskId);
-        if (!sub || sub.messageLog.length === 0)
-          return;
-        try {
-          const projectPath = this.uiStateProjectPaths.get(rootId) ?? this.host.workspaceRoot;
-          const agentId = this.resolveAgentId(taskId);
-          const existing = loadSessionMessages(taskId, projectPath, agentId);
-          const seen = new Set(existing.map((m) => m.id).filter(Boolean));
-          const merged = [...existing, ...sub.messageLog.filter((m) => !m.id || !seen.has(m.id))];
-          const parts = taskId.split(">");
-          const directParentId = parts.length > 1 ? parts.slice(0, -1).join(">") : rootId;
-          this.host.persistSessionFile({
-            sessionId: taskId,
-            projectPath,
-            messages: merged,
-            contextTokens: 0,
-            outputTokens: 0,
-            agentId,
-            agentName: sub.agentName,
-            source: "delegated",
-            description: sub.description,
-            parentSessionId: directParentId
-          });
-        } catch (err) {
-          console.error(`[SessionUIStore] persistSubSession failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
       /** Process-local cache of taskId → authoritative agentId, so the hot persist
        *  path doesn't hit the db on every sub-session write. */
       agentIdCache = /* @__PURE__ */ new Map();
@@ -7412,7 +7440,7 @@ var init_session_ui_store = __esm({
           agentName
         });
         this.uiStateDirty.add(rootId);
-        this.persistUIState(rootId, state);
+        this.persistLog(rootId, state);
       }
       /**
        * Replace the message log entirely (used for compact, which rewrites the
@@ -7426,7 +7454,7 @@ var init_session_ui_store = __esm({
         state.turnToolCalls = [];
         state.turnContentBlocks = [];
         this.uiStateDirty.add(rootId);
-        this.persistUIState(rootId, state);
+        this.persistLog(rootId, state);
       }
       /**
        * Drop the in-memory UIState for a session (e.g. after stopSession / clear).
@@ -7442,8 +7470,12 @@ var init_session_ui_store = __esm({
        */
       dropUIState(sessionId) {
         const state = this.uiStates.get(sessionId);
-        if (state && this.persistTimers.has(sessionId))
-          this.flushPersist(sessionId, state);
+        if (state && sessionId === this.findRootSessionId(sessionId)) {
+          if (this.persistTimers.has(sessionId))
+            this.flushPersist(sessionId, state);
+          for (const taskId of this.pendingSubPersists(sessionId))
+            this.flushPersist(taskId, state);
+        }
         this.uiStates.delete(sessionId);
         this.uiStateProjectPaths.delete(sessionId);
         this.uiStateTouched.delete(sessionId);
@@ -7477,25 +7509,45 @@ var init_session_ui_store = __esm({
       }
       // ── Operations the manager's session-lifecycle methods delegate here ──
       // These exist so the manager never reaches into the maps above directly.
-      /** Flush any pending debounced persist for a session's root before release,
-       *  so an interrupted run's last UI batch lands on disk. No-op if not loaded. */
+      /** Flush the tree's unpersisted UI logs before release, so an interrupted
+       *  run's last UI batch lands on disk. No-op if not loaded. The root's file
+       *  is rewritten only when its log holds changes (dirty): a root turn end
+       *  already flushed at `complete`, and a sub's release must not rewrite the
+       *  root's (large) file for nothing. */
       flushSession(sessionId) {
         const rootId = this.findRootSessionId(sessionId);
         const state = this.uiStates.get(rootId);
-        if (state)
+        if (!state)
+          return;
+        if (this.uiStateDirty.has(rootId))
           this.flushPersist(rootId, state);
+        for (const taskId of this.pendingSubPersists(rootId))
+          this.flushPersist(taskId, state);
       }
-      /** Flush a sub-session's UI log to its own file. Needed after synthetic
-       *  interrupted tool_results on interrupt/stop: applyEvent's tool_result case
-       *  never sets `subSessionSave`, and a stopped sub gets no later event
-       *  (usage/agent_done) to trigger the usual persist — without this the marker
-       *  would live only in memory and vanish on restart. No-op if the root state
-       *  isn't loaded. */
+      /** Server shutdown: land every loaded tree's unpersisted UI logs — a dirty
+       *  root plus every live sub log (pending timers would never fire, and a
+       *  sub's streamed text since its last write rides no timer at all). Same
+       *  writes flushSession makes, minus the "pending timer" filter on subs. */
+      flushAll() {
+        for (const [rootId, state] of this.uiStates) {
+          if (rootId !== this.findRootSessionId(rootId))
+            continue;
+          if (this.uiStateDirty.has(rootId))
+            this.flushPersist(rootId, state);
+          for (const taskId of state.subSessionLogs.keys())
+            this.flushPersist(taskId, state);
+        }
+      }
+      /** Flush a sub-session's UI log to its own file now. Called after the
+       *  synthetic interrupted tool_results on interrupt/stop: those only arm the
+       *  500ms debounce, and the interrupt is a turn boundary — the marker should
+       *  land immediately rather than ride a timer. No-op if the root state isn't
+       *  loaded. */
       flushSubSession(taskId) {
         const rootId = this.findRootSessionId(taskId);
         const state = this.uiStates.get(rootId);
         if (state)
-          this.persistSubSession(state, rootId, taskId);
+          this.flushPersist(taskId, state);
       }
       /**
        * Prepare a session's UIState for a view request. When the session isn't
@@ -7504,9 +7556,10 @@ var init_session_ui_store = __esm({
        * session evolving elsewhere would freeze on the first snapshot.
        */
       prepareForView(sessionId, selfDriven) {
-        if (!selfDriven) {
-          this.uiStates.delete(sessionId);
-          this.uiStateDirty.delete(sessionId);
+        const isRoot = sessionId === this.findRootSessionId(sessionId);
+        const liveTree = isRoot && this.host.hasActiveWorkInTree(sessionId);
+        if (!isRoot || !selfDriven && !liveTree) {
+          this.dropUIState(sessionId);
         }
         this.uiStateProjectPaths.set(sessionId, this.host.workspaceRoot);
         return this.ensureUIState(sessionId);
@@ -7518,10 +7571,12 @@ var init_session_ui_store = __esm({
         this.uiStateProjectPaths.delete(id);
         this.uiStateTouched.delete(id);
         this.uiStateDirty.delete(id);
-        const timer = this.persistTimers.get(id);
-        if (timer) {
-          clearTimeout(timer);
-          this.persistTimers.delete(id);
+        for (const key of [id, ...this.pendingSubPersists(id)]) {
+          const timer = this.persistTimers.get(key);
+          if (timer) {
+            clearTimeout(timer);
+            this.persistTimers.delete(key);
+          }
         }
         this.eventListeners.delete(id);
         this.agentIdCache.delete(id);
@@ -7762,7 +7817,7 @@ var init_session_query_store = __esm({
 });
 
 // ../server/dist/agents/sse.js
-async function* readSseJson(body) {
+async function* readSseJson(body, onChunk) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -7771,6 +7826,7 @@ async function* readSseJson(body) {
       const { done, value } = await reader.read();
       if (done)
         break;
+      onChunk?.();
       buffer = (buffer + decoder.decode(value, { stream: true })).replace(/\r\n/g, "\n");
       let sep2;
       while ((sep2 = buffer.indexOf("\n\n")) !== -1) {
@@ -7828,7 +7884,7 @@ async function fetchAnthropicStream(opts) {
   if (!res.body)
     throw new Error(`[${tag}] empty response body`);
   const acc = new AnthropicStreamAccumulator(startTime, opts.onDelta);
-  for await (const ev of readSseJson(res.body)) {
+  for await (const ev of readSseJson(res.body, () => opts.onDelta?.(ACTIVITY_DELTA))) {
     if (ev.type === "error") {
       throw new Error(`[${tag}] ${SSE_ERROR_STATUS[ev.error?.type ?? ""] ?? "?"} ${ev.error?.type ?? "?"}: ${ev.error?.message ?? ""}`);
     }
@@ -7842,6 +7898,7 @@ var AnthropicStreamAccumulator, SSE_ERROR_STATUS;
 var init_anthropic_stream = __esm({
   "../server/dist/agents/anthropic-stream.js"() {
     "use strict";
+    init_agent_loop();
     init_sse();
     AnthropicStreamAccumulator = class {
       startTime;
@@ -8041,6 +8098,7 @@ var init_bedrock_agent = __esm({
         const acc = new AnthropicStreamAccumulator(startTime, onDelta);
         const decoder = new TextDecoder();
         for await (const chunk of response.body ?? []) {
+          onDelta?.(ACTIVITY_DELTA);
           if (chunk.chunk?.bytes)
             acc.push(JSON.parse(decoder.decode(chunk.chunk.bytes)));
         }
@@ -8129,7 +8187,7 @@ async function fetchChatCompletionStream(opts) {
   if (!res.body)
     throw new Error(`[${tag}] empty response body`);
   const acc = new ChatCompletionAccumulator(startTime, opts.onDelta);
-  for await (const chunk of readSseJson(res.body)) {
+  for await (const chunk of readSseJson(res.body, () => opts.onDelta?.(ACTIVITY_DELTA))) {
     if (chunk.error) {
       throw new Error(`[${tag}] API error in stream: ${JSON.stringify(chunk.error).slice(0, 300)}`);
     }
@@ -8143,6 +8201,7 @@ var ChatCompletionAccumulator;
 var init_openai_chat_stream = __esm({
   "../server/dist/agents/openai-chat-stream.js"() {
     "use strict";
+    init_agent_loop();
     init_sse();
     ChatCompletionAccumulator = class {
       startTime;
@@ -9518,7 +9577,7 @@ async function readResponsesStream(res, onDelta, startTime, signal) {
     throw new Error("[MantleAgent] empty response body");
   let final;
   let firstDeltaAt;
-  for await (const ev of readSseJson(res.body)) {
+  for await (const ev of readSseJson(res.body, () => onDelta?.(ACTIVITY_DELTA))) {
     switch (ev.type) {
       case "response.output_text.delta":
         firstDeltaAt ??= Date.now();
@@ -12310,7 +12369,7 @@ async function initObservability() {
     return true;
   }
   const { registerSdk: registerSdk2 } = await Promise.resolve().then(() => (init_otel_sdk(), otel_sdk_exports));
-  providers = registerSdk2(process.env.OTEL_SERVICE_NAME, "1.5.0-alpha");
+  providers = registerSdk2(process.env.OTEL_SERVICE_NAME, "1.5.2-alpha");
   console.log(`[Observability] OTLP export \u2192 ${process.env.OTEL_EXPORTER_OTLP_ENDPOINT} (service.name=${process.env.OTEL_SERVICE_NAME}, capture_content=${config.observability.captureContent})`);
   return true;
 }
@@ -12676,6 +12735,11 @@ function generateSessionId() {
   const rand2 = Math.random().toString(36).slice(2, 8);
   return `sid_${ts}_${rand2}`;
 }
+function interimDoor(parentId, batch) {
+  if (parentId !== null)
+    return batch.some((q) => q.sourceSessionId === parentId) ? "parent" : null;
+  return batch.some((q) => q.sourceSessionId === void 0 && q.text.includes(RELAY_CHANNEL_PREFIX)) ? "relay" : null;
+}
 var CONTINUE_TASK_KICK, SessionManager;
 var init_session_manager = __esm({
   "../server/dist/agents/session-manager.js"() {
@@ -12962,6 +13026,7 @@ var init_session_manager = __esm({
           streamedThisCall: false,
           finalOutput: "",
           turnError: null,
+          turnErrorKind: null,
           promise: null,
           abortController: null,
           messageQueue: [],
@@ -12976,6 +13041,7 @@ var init_session_manager = __esm({
           isCompacting: false,
           compactAbortController: null,
           compactedThisTurn: false,
+          foldAfterCompact: null,
           systemPrompt,
           thinkingEffort,
           workingDir,
@@ -13289,6 +13355,10 @@ var init_session_manager = __esm({
       getUIState(rootSessionId) {
         return this.uiStore.getUIState(rootSessionId);
       }
+      /** Server shutdown: land every loaded tree's unpersisted UI logs. */
+      flushAll() {
+        this.uiStore.flushAll();
+      }
       appendUserMessage(sessionId, text6, opts) {
         this.uiStore.appendUserMessage(sessionId, text6, opts);
       }
@@ -13437,6 +13507,7 @@ var init_session_manager = __esm({
         session.lastActivityAt = null;
         session.finalOutput = "";
         session.turnError = null;
+        session.turnErrorKind = null;
         const stamp = `[${(/* @__PURE__ */ new Date()).toISOString()}]`;
         const stamped = (text6) => text6 ? `${stamp} ${text6}` : stamp;
         if (typeof message === "string") {
@@ -13508,6 +13579,7 @@ var init_session_manager = __esm({
               console.error(`[SessionManager] Session ${session.id} account error: ${msg}`);
               this.emitEvent(session.id, { type: "error", error: msg, agentName: session.agentName, taskId: session.parentId ? session.id : void 0 });
               session.turnError = msg;
+              session.turnErrorKind = kind;
               resultText = `Error: ${msg}`;
               break;
             }
@@ -13583,6 +13655,7 @@ var init_session_manager = __esm({
             console.error(`[SessionManager] Session ${session.id} error (attempt ${attempt + 1}/${maxRetries})${errDetail ? ` [${errDetail}]` : ""}: ${msg}`);
             this.emitEvent(session.id, { type: "error", error: msg, agentName: session.agentName, taskId: session.parentId ? session.id : void 0 });
             session.turnError = errName ? `${errName}: ${msg}` : msg;
+            session.turnErrorKind = kind;
             resultText = `Error: ${errName ? `${errName}: ` : ""}${msg}`;
             break;
           }
@@ -13605,6 +13678,7 @@ var init_session_manager = __esm({
           throw new Error(`Session ${sessionId} not found`);
         const hasFirst = typeof message === "string" ? message !== "" : message.length > 0;
         console.debug(`[SessionManager] runSession ${sessionId} (agent: ${session.agentId}, parent: ${session.parentId ?? "none"}) \u2014 hasFirst: ${hasFirst}`);
+        const lastTurn = { batch: [], waitingOnChildren: false };
         const runFn = async () => {
           let result = "";
           if (hasFirst) {
@@ -13613,14 +13687,16 @@ var init_session_manager = __esm({
             session.interruptRequested = false;
             session.resumedAfterInterrupt = false;
             session.selfKick = false;
+            lastTurn.batch = [{ text: rawMessageText({ role: "user", content: message }) }];
+            lastTurn.waitingOnChildren = interimDoor(session.parentId, lastTurn.batch) !== null && listActiveChildren(this.db, session.id).length > 0;
             result = await this.runAgentTurn(session, message);
             console.debug(`[SessionManager] runSession ${sessionId} first turn done \u2014 result: ${result.slice(0, 150)}`);
             if (session.messageQueue.length > 0 && session.finalOutput !== "" && !session.turnError) {
-              this.sendOpeningInterim(session);
+              this.sendOpeningInterim(session, lastTurn.batch);
             }
           }
           if (session.messageQueue.length > 0) {
-            await this.drainQueue(session);
+            await this.drainQueue(session, lastTurn);
             result = session.output || result;
           }
           return result;
@@ -13635,6 +13711,7 @@ var init_session_manager = __esm({
           if (session.parentId === null) {
             this.emitEvent(session.id, { type: "complete" });
           }
+          this.sendDeferredInterim(session, lastTurn);
           this.tryReportToParent(session);
           deliverGoalRound(this, session).catch((err) => {
             console.error(`[GoalMode] deliverGoalRound failed for ${session.id}: ${err instanceof Error ? err.message : String(err)}`);
@@ -13668,7 +13745,7 @@ var init_session_manager = __esm({
       tryReportToParent(session) {
         if (!session.parentId)
           return;
-        const activeChildren = this.db.select({ id: agentSessions.id }).from(agentSessions).where(and6(eq9(agentSessions.parentId, session.id), isNull4(agentSessions.stoppedAt), isNull4(agentSessions.archivedAt))).all();
+        const activeChildren = listActiveChildren(this.db, session.id);
         if (activeChildren.length > 0) {
           console.debug(`[SessionManager] tryReportToParent: ${session.id} has ${activeChildren.length} active children, skipping`);
           return;
@@ -13676,7 +13753,8 @@ var init_session_manager = __esm({
         this.db.update(agentSessions).set({ stoppedAt: Date.now() }).where(eq9(agentSessions.id, session.id)).run();
         let result = session.finalOutput || session.output || "(no output)";
         if (session.turnError) {
-          result = `[SUB-AGENT ABORTED: the last turn was terminated by an unrecoverable error, NOT completed. Error: ${session.turnError}. The text below is a partial trace of the aborted turn \u2014 do not treat it as a finished result. Re-dispatch with query_session("${session.id}", ...) to let it resume.]
+          const next = session.turnErrorKind === "account" ? `This is a model account / credential / balance / permission problem: retrying or re-dispatching will fail the same way. Fix the model configuration first (or tell the user to fix it), and do not resume it with query_session("${session.id}", ...) until then.` : `Re-dispatch with query_session("${session.id}", ...) to let it resume.`;
+          result = `[SUB-AGENT ABORTED: the last turn was terminated by an unrecoverable error, NOT completed. Error: ${session.turnError}. The text below is a partial trace of the aborted turn \u2014 do not treat it as a finished result. ${next}]
 
 ${result}`;
         }
@@ -13727,12 +13805,7 @@ ${result}`;
           return { llm: "", ui: "" };
         const now = Date.now();
         const nowIso = new Date(now).toISOString();
-        const stillRunning = this.db.select({
-          agentName: agentSessions.agentName,
-          description: agentSessions.description,
-          createdAt: agentSessions.createdAt,
-          updatedAt: agentSessions.updatedAt
-        }).from(agentSessions).where(and6(eq9(agentSessions.parentId, session.id), isNull4(agentSessions.stoppedAt), isNull4(agentSessions.archivedAt))).all();
+        const stillRunning = listActiveChildren(this.db, session.id);
         if (stillRunning.length === 0 && session.messageQueue.length === 0) {
           const done = "All sub-agents you dispatched have completed. This is the final report \u2014 you may now consolidate and wrap up.";
           return { llm: `
@@ -13762,7 +13835,7 @@ Still running:
        *  entries were traced by the channel before sendUserMessage — so drain does
        *  NOT re-emit a `user` event. It DOES emit one `queued_message` per merged
        *  batch (root only) to split the assistant bubble for the new turn. */
-      async drainQueue(session) {
+      async drainQueue(session, lastTurn) {
         while (session.messageQueue.length > 0) {
           const batch = session.messageQueue.splice(0);
           session.resumedAfterInterrupt = session.interruptRequested;
@@ -13784,6 +13857,8 @@ ${q.text}` : q.text).join("\n\n");
           }
           const kickNote = kickFlagReset ? "\n\n[System] The continue_task flag you set last turn was reset by this interrupt. If the interrupted task is still unfinished after you answer, call continue_task again." : "";
           const input = this.buildInput(merged + suffix.llm + kickNote, images.length > 0 ? images : void 0, session.supportsImage);
+          lastTurn.batch = batch;
+          lastTurn.waitingOnChildren = interimDoor(session.parentId, batch) !== null && listActiveChildren(this.db, session.id).length > 0;
           try {
             await this.runAgentTurn(session, input);
           } catch (err) {
@@ -13809,7 +13884,8 @@ ${q.text}` : q.text).join("\n\n");
           }
         }
       }
-      /** Interim report for a drained turn. A turn followed by another turn (kick /
+      /** Interim report for a drained turn (sendDeferredInterim sends through here
+       *  too). A turn followed by another turn (kick /
        *  queued message) is otherwise lost to whoever asked: the end-of-run reports
        *  (tryReportToParent / deliverRelayReport) read only the LAST turn's output,
        *  and the next runAgentTurn resets it. So when the batch just answered came
@@ -13821,25 +13897,44 @@ ${q.text}` : q.text).join("\n\n");
        *  an interim would wake G mid-round, and a fresh query_session from G would
        *  interrupt W again. */
       sendInterimReport(session, batch) {
-        const fromParent = session.parentId !== null && batch.some((q) => q.sourceSessionId === session.parentId);
-        const fromRelay = session.parentId === null && batch.some((q) => q.sourceSessionId === void 0 && q.text.includes(RELAY_CHANNEL_PREFIX));
-        if (fromParent)
-          this.deliverInterim(session, "parent");
-        else if (fromRelay)
-          this.deliverInterim(session, "relay");
+        const to = interimDoor(session.parentId, batch);
+        if (to)
+          this.deliverInterim(session, to);
       }
       /** Interim report for the OPENING turn (runSession's `hasFirst` turn): when it
        *  ends naturally while the queue already holds a follow-up, the drain resets
-       *  output and the wrap-up is lost the same way. No batch to read the door from
-       *  here — the opening message is the dispatch itself — so the owed party is
-       *  whoever this session reports to at the end: its parent, or a relay caller
-       *  (reply_to row). Goal workers have neither, so they get nothing. */
-      sendOpeningInterim(session) {
+       *  output and the wrap-up is lost the same way. A sub-agent's opening message
+       *  is its parent's dispatch, so it always owes the parent. A root owes its
+       *  relay caller only when the opening message itself is relay-prefixed (same
+       *  door as the drain path): a pending reply_to alone is not enough — a local
+       *  user chatting into a root that still owes a relay report would otherwise
+       *  have their answer forwarded to the caller. Goal workers have neither. */
+      sendOpeningInterim(session, batch) {
         if (session.parentId !== null)
           this.deliverInterim(session, "parent");
-        else if (readReplyTo(this.db, session.id) !== null)
+        else if (interimDoor(null, batch) === "relay" && readReplyTo(this.db, session.id) !== null)
           this.deliverInterim(session, "relay");
       }
+      /** Interim report for the run's LAST turn while a still-running child holds
+       *  the end-of-run report back. The loss it fixes: tryReportToParent /
+       *  deliverRelayReport fire only once the subtree is quiet, and read only the
+       *  last turn. A session waiting on a sub-agent is asked by its caller
+       *  (relay_send / the parent's query_session) and answers; the run ends with the
+       *  child still running, so both skip, and the child's report later wakes a new
+       *  run whose first turn resets output — the answer reached no one. Sends only
+       *  when that turn answered the owed party while already waiting
+       *  (waitingOnChildren — door first, db lookup only past it) and the subtree is
+       *  STILL busy. Runs in runSession's finally right before those two, which read
+       *  the same db gate synchronously: children running → they skip and this sends;
+       *  none → they report this turn as the final and this doesn't. Never overlaps
+       *  sendInterimReport's drain call: a turn another turn follows is never the last. */
+      sendDeferredInterim(session, lastTurn) {
+        if (!lastTurn.waitingOnChildren || session.finalOutput === "" || session.turnError)
+          return;
+        if (listActiveChildren(this.db, session.id).length === 0)
+          return;
+        this.sendInterimReport(session, lastTurn.batch);
+      }
       /** Body = the WHOLE turn's text (`output`, not `finalOutput`): in a turn that
        *  answered and then called continue_task the answer rides the tool_use
        *  response, whose text is `final: false` and never reaches finalOutput. */
@@ -13959,6 +14054,12 @@ ${body}`;
        *      isn't a non-empty array, so a string-content turn would be silently
        *      deleted by the repair that runs right after this. */
       foldIntoAgentMessages(session, text6) {
+        if (session.isCompacting) {
+          session.foldAfterCompact = session.foldAfterCompact ? `${session.foldAfterCompact}
+
+${text6}` : text6;
+          return;
+        }
         const msgs = session.agent.messages;
         const last = msgs[msgs.length - 1];
         if (last?.role === "user" && Array.isArray(last.content)) {
@@ -13997,8 +14098,10 @@ ${q.text}` : q.text);
               } catch {
               }
             }
-            session.agent.messages = repairConversationMessages(session.agent.messages, `[Session:${id}]`);
-            this.releaseSession(id);
+            if (!session.isCompacting) {
+              session.agent.messages = repairConversationMessages(session.agent.messages, `[Session:${id}]`);
+              this.releaseSession(id);
+            }
           }
           this.db.update(agentSessions).set({ stoppedAt: now }).where(eq9(agentSessions.id, id)).run();
         }
@@ -14110,7 +14213,8 @@ ${cleaned}` : cleaned;
        * Send a user message to a session (WS handler → agent).
        * If idle: runs the message directly.
        * If busy: enqueues and requests graceful interrupt.
-       * If compacting: enqueues for post-compact processing.
+       * If compacting: enqueues for post-compact processing (plus a graceful
+       * interrupt when the compact runs inside a live turn).
        * Returns 'running' | 'queued' to inform the caller.
        */
       async sendUserMessage(sessionId, message, images, accessLevel) {
@@ -14137,6 +14241,8 @@ ${cleaned}` : cleaned;
         }
         if (session.isCompacting) {
           session.messageQueue.push({ text: message, images });
+          if (session.abortController !== null)
+            session.interruptRequested = true;
           console.debug(`[SessionManager] sendUserMessage: ${sessionId} compacting \u2014 message queued`);
           return "queued";
         }
@@ -14246,7 +14352,8 @@ ${cleaned}` : cleaned;
         const overThreshold = session.lastContextTokens > session.contextConfig.maxTokens * session.contextConfig.compressAt;
         if (!overThreshold)
           return;
-        if (this.compactCut(session.agent.messages) === 0)
+        const cut = compactCut(session.agent.messages);
+        if (cut === 0)
           return;
         const taskId = session.parentId ? session.id : void 0;
         try {
@@ -14262,14 +14369,43 @@ ${result.summary}`, agentName: "user", report: true, taskId });
             this.emitEvent(session.id, { type: "compacted", totalTokens: result.estimatedTokens, taskId });
             console.debug(`[SessionManager] Auto-compact ${session.id}: ${result.olderCount} messages compacted`);
           } else {
-            this.emitEvent(session.id, { type: "system", text: "Compaction skipped \u2014 no summary produced", taskId });
+            this.localCompactFallback(session, cut, "no summary produced", taskId);
           }
         } catch (err) {
-          console.debug(`[SessionManager] Auto-compact ${session.id} failed: ${err instanceof Error ? err.message : String(err)}`);
-          this.emitEvent(session.id, { type: "system", text: "Compaction failed \u2014 context unchanged", taskId });
+          const msg = err instanceof Error ? err.message : String(err);
+          console.debug(`[SessionManager] Auto-compact ${session.id} failed: ${msg}`);
+          this.localCompactFallback(session, cut, msg, taskId);
         } finally {
-          session.isCompacting = false;
-        }
+          this.clearCompacting(session);
+        }
+      }
+      /** Auto-compact fallback when the LLM summary failed (threw / idle-timed out
+       *  / came back empty). selfCompactSession has already rolled the history
+       *  back; leaving it as-is kept the session over threshold, so every later
+       *  model call re-ran the same failing summarize. Do the no-LLM compact
+       *  instead, with the LLM path's tail micro-compact + token estimate. */
+      localCompactFallback(session, cut, reason, taskId) {
+        const local = localCompactMessages(session.agent.messages);
+        if (local.compacted) {
+          const [summaryMsg, ...tail] = local.messages;
+          const tailMicro = microCompactMessages(tail, 1);
+          session.agent.messages = [summaryMsg, ...tailMicro.compacted ? tailMicro.messages : tail];
+        }
+        session.lastContextTokens = estimateMessageTokens(session.agent.messages) + estimateMessageTokens([{ role: "user", content: session.systemPrompt }]);
+        const why = reason.length > 80 ? `${reason.slice(0, 80)}\u2026` : reason;
+        this.emitEvent(session.id, { type: "system", text: `Auto-compacted ${cut} older messages (local fallback \u2014 LLM summary failed: ${why})`, taskId, compactEnd: true });
+      }
+      /** Leave the compact-in-flight state (auto: maybeAutoCompact's finally;
+       *  manual: endCompact), then land a queue fold a Stop parked meanwhile
+       *  (see foldIntoAgentMessages) on the post-compact history. */
+      clearCompacting(session) {
+        session.isCompacting = false;
+        session.compactAbortController = null;
+        const parked = session.foldAfterCompact;
+        if (!parked)
+          return;
+        session.foldAfterCompact = null;
+        this.foldIntoAgentMessages(session, parked);
       }
       /** Check if a session is compacting */
       isSessionCompacting(sessionId) {
@@ -14351,8 +14487,7 @@ ${result.summary}`, agentName: "user", report: true, taskId });
         const session = this.sessions.get(sessionId);
         if (!session)
           return;
-        session.isCompacting = false;
-        session.compactAbortController = null;
+        this.clearCompacting(session);
         if (session.messageQueue.length > 0 && session.promise === null) {
           console.debug(`[SessionManager] Compact ${sessionId} ended \u2014 draining ${session.messageQueue.length} queued message(s)`);
           this.runSession(sessionId, "").catch((err) => {
@@ -14370,38 +14505,6 @@ ${result.summary}`, agentName: "user", report: true, taskId });
           session.compactAbortController = null;
         }
       }
-      /**
-       * Compute the compaction cut point: messages[0..cut) get summarized,
-       * messages[cut..] are kept. Returns 0 when there is nothing to compact
-       * (too few messages) — the "compaction is feasible" predicate.
-       *
-       * Single source of truth shared by selfCompactSession AND the
-       * pre-preflight feasibility gates in maybeAutoCompact / compactSession:
-       * gate and actual compact must run the same computation on the same
-       * `session.agent.messages` reference or they drift ("gate said yes,
-       * compact said no" re-creates the orphan-preflight bug).
-       *
-       * Note the tail loop only ever moves `cut` UP (a tail of user tool_result
-       * messages extends the summarized region — they're protocol continuations
-       * of an assistant turn, not standalone turns), so cut === 0 is exactly
-       * the `messages.length <= keepCount` case.
-       */
-      compactCut(messages2) {
-        const keepCount = config.compact.keep_messages;
-        if (messages2.length <= keepCount)
-          return 0;
-        let cut = Math.max(0, messages2.length - keepCount);
-        while (cut < messages2.length) {
-          const m = messages2[cut];
-          const firstBlock = Array.isArray(m.content) ? m.content[0] : void 0;
-          if (m.role === "user" && firstBlock?.type === "tool_result") {
-            cut++;
-            continue;
-          }
-          break;
-        }
-        return cut;
-      }
       /**
        * Self-compact: let the current agent summarize its own conversation.
        * The agent already has full context cached, so this is fast and lossless.
@@ -14412,7 +14515,7 @@ ${result.summary}`, agentName: "user", report: true, taskId });
         if (!session)
           return null;
         const messages2 = session.agent.messages;
-        const cut = this.compactCut(messages2);
+        const cut = compactCut(messages2);
         if (cut === 0)
           return null;
         session.compactedThisTurn = true;
@@ -14427,29 +14530,24 @@ ${result.summary}`, agentName: "user", report: true, taskId });
           "Write in the SAME LANGUAGE as the conversation.",
           "Output ONLY the summary, no preamble."
         ].join("\n");
-        const timeoutMs = config.compact.summarize_timeout_sec * 1e3;
-        const timeoutCtrl = new AbortController();
-        const timer = setTimeout(() => timeoutCtrl.abort(abortReason("compact-timeout")), timeoutMs);
         const cleanRecent = messages2.slice(cut).map((m) => structuredClone(m));
         const preRunLen = messages2.length;
         const preRunTail = structuredClone(messages2[preRunLen - 1]);
         let rebuilt = false;
         try {
           let summaryText = "";
-          if (signal)
-            signal.addEventListener("abort", () => timeoutCtrl.abort(abortReason("compact-cancelled")), { once: true });
-          const iter = session.agent.run(compactInstruction, {
-            cancelSignal: timeoutCtrl.signal
-          });
+          const iter = session.agent.run(compactInstruction, { cancelSignal: signal });
           for await (const event of iter) {
-            if (signal?.aborted || timeoutCtrl.signal.aborted)
+            if (signal?.aborted)
+              break;
+            if (event.type === "tool_call") {
+              summaryText = "";
               break;
+            }
             if (event.type === "text") {
               summaryText += event.text ?? "";
             }
           }
-          if (timeoutCtrl.signal.aborted)
-            throw new Error(`Self-compact timed out after ${timeoutMs / 1e3}s`);
           if (signal?.aborted)
             throw new Error("Self-compact cancelled");
           if (!summaryText.trim())
@@ -14468,7 +14566,6 @@ ${summaryText}` }]
           const estimatedTokens = estimateMessageTokens(session.agent.messages) + estimateMessageTokens([{ role: "user", content: session.systemPrompt }]);
           return { summary: summaryText, olderCount, estimatedTokens };
         } finally {
-          clearTimeout(timer);
           if (!rebuilt) {
             session.agent.messages.length = preRunLen;
             session.agent.messages[preRunLen - 1] = preRunTail;
@@ -14510,7 +14607,7 @@ ${summaryText}` }]
         if (session.isCompacting)
           return "already";
         const rawCount = session.agent.messages.length;
-        if (this.compactCut(session.agent.messages) === 0)
+        if (compactCut(session.agent.messages) === 0)
           return "nothing";
         const ac = await this.beginCompact(sessionId);
         if (!ac)
@@ -14537,9 +14634,9 @@ ${result.summary}`, agentName: "user", report: true, taskId });
           return "compacted";
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          if (msg === "Self-compact cancelled") {
+          if (ac.signal.aborted) {
             this.emitEvent(sessionId, { type: "system", text: "Compact cancelled" });
-            return "nothing";
+            return "cancelled";
           }
           this.emitEvent(sessionId, { type: "system", text: "Compaction failed \u2014 context unchanged", taskId });
           throw err;
@@ -14843,10 +14940,14 @@ ${result.summary}`, agentName: "user", report: true, taskId });
        *  message), and requests a SOFT interrupt so a busy turn yields after its
        *  current tool — same effect as sendUserMessage's busy branch, minus the
        *  idle/run path (the caller already established the session is busy or
-       *  compacting). When compacting there is no live turn to interrupt, so the
-       *  flag is NOT set (mirrors sendUserMessage's compacting branch): endCompact's
-       *  drain would snapshot it into resumedAfterInterrupt and let continue_task
-       *  arm a kick in a turn that interrupted nothing. endCompact drains the queue. */
+       *  compacting). A compact outside a live model loop (manual /compact, or the
+       *  turn-end auto-compact — abortController already null) has nothing to
+       *  interrupt, so the flag is NOT set there (mirrors sendUserMessage's
+       *  compacting branch): the drain would snapshot it into resumedAfterInterrupt
+       *  and let continue_task arm a kick in a turn that interrupted nothing. A
+       *  mid-turn auto-compact (beforeCallModel) does interrupt a live turn — the
+       *  flag is set, so the turn yields after its next tool instead of running on
+       *  to its natural end with the message still queued. */
       async enqueueUserMessage(sessionId, text6, images) {
         const session = this.sessions.get(sessionId);
         if (!session)
@@ -14856,7 +14957,7 @@ ${result.summary}`, agentName: "user", report: true, taskId });
           this.emitEvent(sessionId, { type: "system", text: `\u26A0 ${w}` });
         }
         session.messageQueue.push({ text: scoped.text, images });
-        if (!session.isCompacting)
+        if (!session.isCompacting || session.abortController !== null)
           session.interruptRequested = true;
         console.debug(`[SessionManager] User message enqueued for ${sessionId} (${session.messageQueue.length} in queue)`);
       }
@@ -14885,7 +14986,9 @@ ${q.text}` : q.text);
           this.markPendingToolCallsInterrupted(sessionId);
         }
         this.cancelCompact(sessionId);
-        session.agent.messages = repairConversationMessages(session.agent.messages, `[Session:${sessionId}]`);
+        if (!session.isCompacting) {
+          session.agent.messages = repairConversationMessages(session.agent.messages, `[Session:${sessionId}]`);
+        }
       }
     };
   }
@@ -15153,6 +15256,7 @@ async function createHarness(opts) {
       }
     }
     activeOverrides2.set(USER_ID, sessionId);
+    const sessionAgentId = sm.getSessionById(sessionId)?.agentId ?? agentId;
     const disabledSet = getDisabledSet(sm.getDb(), "agent");
     const agents = await scanAvailableAgents(workspace, disabledSet);
     const agentEntry = agents.find((a) => a.id === agentId);
@@ -15160,7 +15264,7 @@ async function createHarness(opts) {
     const unsubPersistent = sm.registerEventListener(sessionId, (event) => {
       for (const h of eventHandlers) h(event);
     });
-    return { sm, workspace, sessionId, accessLevel, supportsImage, unsubPersistent };
+    return { sm, workspace, sessionId, agentId: sessionAgentId, accessLevel, supportsImage, unsubPersistent };
   }
   let state = await bindWorkspace(initialPath, opts.sessionId, opts.newSession ?? false);
   async function send(message, images) {
@@ -15227,6 +15331,7 @@ async function createHarness(opts) {
       state = {
         ...state,
         sessionId: result.switchTo,
+        agentId: state.sm.getSessionById(result.switchTo)?.agentId ?? agentId,
         unsubPersistent: state.sm.registerEventListener(result.switchTo, (event) => {
           for (const h of eventHandlers) h(event);
         })
@@ -15307,6 +15412,9 @@ async function createHarness(opts) {
     get workspace() {
       return state.workspace;
     },
+    get agentId() {
+      return state.agentId;
+    },
     get supportsImage() {
       return state.supportsImage;
     },
@@ -16265,8 +16373,8 @@ function formatUsageLine(event) {
     parts.push(`${ANSI.dim}think off${ANSI.reset}`);
   }
   if (event.modelId) {
-    const shortModel3 = event.modelId.replace(/^global\.anthropic\./, "");
-    parts.push(`${ANSI.blue}${shortModel3}${ANSI.reset}`);
+    const shortModel2 = event.modelId.replace(/^global\.anthropic\./, "");
+    parts.push(`${ANSI.blue}${shortModel2}${ANSI.reset}`);
   }
   return `${ANSI.dim}[${ANSI.reset} ${parts.join("  ")} ${ANSI.dim}]${ANSI.reset}`;
 }
@@ -16506,22 +16614,15 @@ var init_history = __esm({
 // src/tui/components/status-bar.tsx
 import { Box as Box4, Text as Text4 } from "ink";
 import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-function shortModel(modelId) {
-  return modelId.replace(/^global\.anthropic\./, "").replace(/^anthropic\./, "").replace(/-\d{8}$/, "");
-}
 function shortPath(p) {
   const home = process.env.HOME ?? "";
   if (home && p.startsWith(home)) return "~" + p.slice(home.length);
   return p;
 }
-function StatusBar({ agentName, modelId, contextPercent, workspace, sessionId, verbose }) {
+function StatusBar({ agentId, contextPercent, workspace, sessionId, verbose }) {
   return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", justifyContent: "space-between", paddingX: 1, children: [
     /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", gap: 1, children: [
-      /* @__PURE__ */ jsx4(Text4, { color: "green", children: agentName }),
-      modelId ? /* @__PURE__ */ jsxs3(Fragment, { children: [
-        /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "\xB7" }),
-        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: shortModel(modelId) })
-      ] }) : null,
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: agentId }),
       contextPercent != null ? /* @__PURE__ */ jsxs3(Fragment, { children: [
         /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "\xB7" }),
         /* @__PURE__ */ jsx4(Text4, { color: contextPercent > 80 ? "red" : contextPercent > 50 ? "yellow" : "green", children: `\u25EF ${contextPercent}%` })
@@ -17228,10 +17329,8 @@ function initialState(verbose) {
     liveThinking: null,
     spinnerLabel: null,
     running: false,
-    modelId: null,
     contextTokens: null,
     agentNameByTaskId: /* @__PURE__ */ new Map(),
-    rootAgentName: "agent",
     subAgents: /* @__PURE__ */ new Map(),
     verbose,
     pendingToolInput: null,
@@ -17325,7 +17424,7 @@ function messagesToLogLines(messages2) {
       if (u.thinkingEffort && u.thinkingEffort !== "off") {
         parts.push(`${ANSI2.magenta}think ${u.thinkingEffort}${ANSI2.reset}`);
       }
-      if (m.modelId) parts.push(`${ANSI2.blue}${shortModel2(m.modelId)}${ANSI2.reset}`);
+      if (m.modelId) parts.push(`${ANSI2.blue}${shortModel(m.modelId)}${ANSI2.reset}`);
       lines.push({ text: `${tsStr} ${ANSI2.dim}\xB7${ANSI2.reset} ${parts.join("  ")}` });
       continue;
     }
@@ -17396,7 +17495,7 @@ function fmtK2(n) {
 function fmtMs2(ms) {
   return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${ms}ms`;
 }
-function shortModel2(id) {
+function shortModel(id) {
   return id.replace(/^global\.anthropic\./, "").replace(/^anthropic\./, "").replace(/-\d{8}$/, "");
 }
 function formatTs(ms) {
@@ -17433,10 +17532,8 @@ function reducer(state, action) {
         liveThinking: null,
         spinnerLabel: null,
         running: false,
-        modelId: null,
         contextTokens: null,
         agentNameByTaskId: /* @__PURE__ */ new Map(),
-        rootAgentName: "agent",
         subAgents: /* @__PURE__ */ new Map(),
         pendingToolInput: null,
         pendingToolArg: null,
@@ -17476,9 +17573,6 @@ function reducer(state, action) {
               }]
             };
           }
-          if (!e.taskId && e.agentName) {
-            next = { ...next, rootAgentName: e.agentName };
-          }
           return next;
         }
         case "agent_done": {
@@ -17590,7 +17684,6 @@ function reducer(state, action) {
             blocks,
             liveText: "",
             liveThinking: null,
-            modelId: e.modelId ?? state.modelId,
             contextTokens: ctx > 0 ? ctx : state.contextTokens
           };
         }
@@ -17898,8 +17991,7 @@ ${lines.join("\n")}` });
       /* @__PURE__ */ jsx11(
         StatusBar,
         {
-          agentName: state.rootAgentName,
-          modelId: state.modelId,
+          agentId: harness.agentId,
           contextPercent: ctxPercent,
           workspace: harness.workspace,
           sessionId: harness.sessionId,
@@ -22275,6 +22367,10 @@ function createWebChannel(deps) {
     const sessionId = opts?.sessionId ?? getActiveSessionId(sm, account.accountId);
     if (!sessionId)
       return false;
+    if (sm.isSessionCompacting(sessionId) && !sm.isSessionRunning(sessionId)) {
+      sm.cancelCompact(sessionId);
+      return true;
+    }
     if (!sm.isSessionRunning(sessionId))
       return false;
     await sm.stopSession(sessionId);
@@ -23860,6 +23956,9 @@ function sendWsNotification(event, state, turnId, ctx) {
         sendJson(ctx.ws, { type: "compact:started" });
       }
       sendJson(ctx.ws, { type: "chat:system", text: event.text ?? "", taskId, agentName, sessionId });
+      if (event.compactEnd && !taskId) {
+        sendJson(ctx.ws, { type: "compact:done" });
+      }
       break;
     case "error":
       sendJson(ctx.ws, { type: "error", error: event.error, agentName, taskId, sessionId });
@@ -24599,7 +24698,8 @@ ${msg.message}` : markers.join("\n");
         rememberChat(msg);
         await sm.enqueueUserMessage(sid, msg.message, msg.images);
         ackChat(msg);
-        sendJson(ws, { type: "chat:queued", reason: "compact", message: "Context compacting, message queued \u2014 will process after compact completes." });
+        const queuedText = sm.isSessionRunning(sid) ? "Context compacting, message queued \u2014 will process after the compact and the current step finish." : "Context compacting, message queued \u2014 will process after compact completes.";
+        sendJson(ws, { type: "chat:queued", reason: "compact", message: queuedText });
         return;
       }
       if (sm.isSessionRunning(sid)) {
@@ -24627,7 +24727,7 @@ ${msg.message}` : markers.join("\n");
       const sid = client2.sessionId;
       if (!sm || !sid)
         return;
-      if (sm.isSessionCompacting(sid)) {
+      if (sm.isSessionCompacting(sid) && !sm.isSessionRunning(sid)) {
         sm.cancelCompact(sid);
         sendJson(ws, { type: "chat:stopped", sessionId: client2.sessionId });
         return;
@@ -24642,7 +24742,7 @@ ${msg.message}` : markers.join("\n");
       const sid = client2.sessionId;
       if (!sm || !sid)
         return;
-      if (sm.isSessionCompacting(sid)) {
+      if (sm.isSessionCompacting(sid) && !sm.isSessionRunning(sid)) {
         sm.cancelCompact(sid);
         sendJson(ws, { type: "chat:stopped", sessionId: client2.sessionId });
         return;
@@ -32857,6 +32957,14 @@ async function gracefulShutdown(signal) {
   if (server && typeof server.close === "function") {
     server.close();
   }
+  for (const { workspacePath, sm } of registry.list()) {
+    try {
+      sm.flushAll();
+    } catch (err) {
+      console.error(`[Server] flushAll failed for ${workspacePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    releaseWorkspaceRuntime(workspacePath);
+  }
   console.log("[Server] Shutdown complete");
   await shutdownObservability();
   process.exit(0);
@@ -32907,7 +33015,7 @@ var init_dist2 = __esm({
     init_git_ssh();
     __dirname3 = path72.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "1.5.0-alpha";
+    HALO_VERSION = "1.5.2-alpha";
     PROJECT_ROOT = findProjectRoot();
     HALO_HOME4 = path72.join(homedir24(), ".halo");
     GIT_SHA = readGitSha();
@@ -33838,7 +33946,7 @@ import path73 from "node:path";
 import fs67 from "node:fs";
 import { homedir as homedir25 } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
-var VERSION = "1.5.0-alpha";
+var VERSION = "1.5.2-alpha";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands: