@turmind/halo 1.5.10 → 1.5.11

package/dist/index.js

@@ -2967,6 +2967,7 @@ Error: tool "${tu.name}" was not run \u2014 the response hit the output token li
           const inputErrors = new Map(result.toolCalls.filter((tc) => tc.inputError).map((tc) => [tc.id, tc.inputError]));
           const toolResults = [];
           let shouldEndTurn = false;
+          let cutId = null;
           try {
             for (const tu of toolUseBlocks) {
               if (options?.cancelSignal?.aborted)
@@ -3006,8 +3007,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`;
                   isError = true;
                 }
               }
-              if (options?.cancelSignal?.aborted)
+              if (options?.cancelSignal?.aborted) {
+                cutId = tu.id;
                 return;
+              }
               const uiCap = config.limits.toolResultUiMax;
               const resultTextFull = resultText.length > uiCap ? resultText.slice(0, uiCap) + `
 
@@ -3053,6 +3056,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`;
               };
             }
           } finally {
+            const answered = new Set(toolResults.map((b) => b.tool_use_id));
+            for (const tu of toolUseBlocks) {
+              if (answered.has(tu.id) || tu.id === cutId)
+                continue;
+              toolResults.push({
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: `${TOOL_ERROR_MARKER}
+Error: tool "${tu.name}" was not run \u2014 the turn was interrupted before this call started. Safe to re-issue if still needed.`,
+                is_error: true
+              });
+            }
             if (toolResults.length > 0) {
               this.messages.push({ role: "user", content: toolResults });
             }
@@ -3780,6 +3795,11 @@ function ensureHaloHome(haloHome2) {
       console.log(`[Init] Removed stale \`${staleId}\` skill (merged into \`web-search\`)`);
     }
   }
+  const staleAcpSkill = path12.join(globalDir2, "skills", "acp");
+  if (fs9.existsSync(staleAcpSkill)) {
+    fs9.rmSync(staleAcpSkill, { recursive: true, force: true });
+    console.log("[Init] Removed stale `acp` skill (outbound ACP client dropped)");
+  }
   const docsSrc = resolveDocsSource();
   if (!docsSrc) {
     console.log(`[Init] No docs source found \u2014 skipping platform docs seed. Searched: ${DOCS_SRC_CANDIDATES.join(", ")}`);
@@ -3846,7 +3866,7 @@ var init_init = __esm({
       path12.resolve(__dirname, "..", "bundled-docs"),
       path12.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 90;
+    TEMPLATE_VERSION = 92;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -3865,11 +3885,6 @@ var init_init = __esm({
       "skill",
       "workspace",
       "cron",
-      // Meta-skill: walks the user through generating a per-remote
-      // `ask-<label>` ACP binding skill. The generated bindings live in
-      // user-owned skill dirs (workspace or global) and aren't templated;
-      // only this generator itself is platform-owned.
-      "acp",
       // Always-on file delivery primitive: every channel handler (web /
       // wechat / telegram / slack / feishu) intercepts `MEDIA:<path>` from
       // the agent's reply and uploads it. The skill body teaches the agent
@@ -4043,6 +4058,12 @@ async function callerTeamFor(sm, sessionId) {
 function isSameTree(a, b) {
   return a.split(">")[0] === b.split(">")[0];
 }
+function isSelfOrAncestor(callerId, targetId) {
+  return callerId === targetId || callerId.startsWith(targetId + ">");
+}
+function selfOrAncestorRefusal(verb, targetId) {
+  return `cannot ${verb} session ${targetId}: it is your own session or one of its ancestors, so the ${verb} would wait on the very turn making this call. To end your work, just finish this turn.`;
+}
 function buildSessionTools(sm, sessionId) {
   const startSessionTool = {
     name: "start_session",
@@ -4192,6 +4213,9 @@ ${params.message}` : params.message;
         if (!isSameTree(params.session_id, sessionId)) {
           return JSON.stringify({ code: 1, error: `session ${params.session_id} not found` });
         }
+        if (isSelfOrAncestor(sessionId, params.session_id)) {
+          return JSON.stringify({ code: 1, error: selfOrAncestorRefusal("stop", params.session_id) });
+        }
         await sm.stopSession(params.session_id);
         return JSON.stringify({ code: 0, message: `Session ${params.session_id} stopped.` });
       } catch (err) {
@@ -4213,6 +4237,9 @@ ${params.message}` : params.message;
         if (!isSameTree(params.session_id, sessionId)) {
           return JSON.stringify({ code: 1, error: `session ${params.session_id} not found` });
         }
+        if (isSelfOrAncestor(sessionId, params.session_id)) {
+          return JSON.stringify({ code: 1, error: selfOrAncestorRefusal("archive", params.session_id) });
+        }
         const count = await sm.archiveSessionTree(params.session_id);
         return JSON.stringify({ code: 0, message: `Archived ${count} session(s).` });
       } catch (err) {
@@ -7130,7 +7157,7 @@ function resolveTarget(workspace) {
 function buildRelayTools(host, callerSessionId) {
   const relaySend = {
     name: "relay_send",
-    description: "Dispatch a message to a session in ANOTHER workspace on this server. Creates the session if `session_id` does not exist there (with `agent_id`, or the workspace's default agent). If the session is busy the message is queued and the current step is softly interrupted (finishes its current tool, then reads your message) \u2014 use this for follow-ups and corrections too. Returns immediately; when the target's whole subtree finishes, its wrap-up is delivered to you as a `[Relay report \xB7 \u2026]` message. If a busy target answers your message and then resumes the task it interrupted, that answer arrives first as a `[Relay interim report \xB7 \u2026]` \u2014 the final report still follows. Do not poll \u2014 the report arrives on its own. Returns JSON with code 0 on success.",
+    description: "Dispatch a message to a session in ANOTHER workspace on this server. Creates the session if `session_id` does not exist there (with `agent_id`, or the workspace's default agent). If the session is busy the message is queued and the current step is softly interrupted (finishes its current batch of tool calls, then reads your message) \u2014 use this for follow-ups and corrections too. Returns immediately; when the target's whole subtree finishes, its wrap-up is delivered to you as a `[Relay report \xB7 \u2026]` message. If a busy target answers your message and then resumes the task it interrupted, that answer arrives first as a `[Relay interim report \xB7 \u2026]` \u2014 the final report still follows. Do not poll \u2014 the report arrives on its own. Returns JSON with code 0 on success.",
     inputSchema: {
       type: "object",
       properties: {
@@ -7174,6 +7201,9 @@ function buildRelayTools(host, callerSessionId) {
     if (typeof resolved === "string")
       return resolved;
     const { wsPath, target } = resolved;
+    if (target === host && isSelfOrAncestor(callerSessionId, params.session_id)) {
+      return jsonErr2(`cannot relay to session ${params.session_id}: it is your own session or one of its ancestors, so its report would come back to you. Talk to your parent through your final reply, or use the session tools.`);
+    }
     if (!target.getSessionById(params.session_id)) {
       if (hard)
         return jsonErr2("session not found");
@@ -7208,6 +7238,9 @@ ${params.message}`;
         const { target } = resolved;
         if (!target.getSessionById(params.session_id))
           return jsonErr2("session not found");
+        if (target === host && isSelfOrAncestor(callerSessionId, params.session_id)) {
+          return jsonErr2(selfOrAncestorRefusal("stop", params.session_id));
+        }
         await target.stopSession(params.session_id);
         return JSON.stringify({ code: 0, message: `Session ${params.session_id} stopped.` });
       } catch (err) {
@@ -7276,6 +7309,7 @@ var init_relay = __esm({
     init_schema();
     init_config();
     init_commands2();
+    init_session_tools();
     RELAY_CHANNEL_PREFIX = "[channel: relay | from: ";
     _registry = null;
     RELAY_UNAVAILABLE = "relay is not available in the CLI / TUI \u2014 it only runs inside `halo server`. This is permanent for this runtime, not a temporary outage: do not retry. Tell the user to send this request from the admin UI or an IM / Web channel connected to the server, or to open the target workspace directly with `halo tui -w <workspace path>`.";
@@ -7481,27 +7515,27 @@ var init_workspace = __esm({
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
       }
-      async readFile(path76) {
-        const fullPath = this.validatePath(path76);
+      async readFile(path77) {
+        const fullPath = this.validatePath(path77);
         return readFile(fullPath, "utf-8");
       }
-      async writeFile(path76, content) {
-        const fullPath = this.validatePath(path76);
+      async writeFile(path77, content) {
+        const fullPath = this.validatePath(path77);
         const dir = resolve(fullPath, "..");
         await mkdir(dir, { recursive: true });
         await writeFile(fullPath, content, "utf-8");
       }
-      validatePath(path76) {
-        const fullPath = isAbsolute(path76) ? resolve(path76) : resolve(this.projectRoot, path76);
+      validatePath(path77) {
+        const fullPath = isAbsolute(path77) ? resolve(path77) : resolve(this.projectRoot, path77);
         const root = resolve(this.projectRoot);
         if (fullPath !== root && !fullPath.startsWith(root + sep)) {
-          throw new WorkspaceError(`Path "${path76}" is outside the workspace directory "${this.projectRoot}"`);
+          throw new WorkspaceError(`Path "${path77}" is outside the workspace directory "${this.projectRoot}"`);
         }
         try {
           const real = realpathSync2(fullPath);
           const realRoot = realpathSync2(root);
           if (real !== realRoot && !real.startsWith(realRoot + sep)) {
-            throw new WorkspaceError(`Path "${path76}" is outside the workspace directory "${this.projectRoot}"`);
+            throw new WorkspaceError(`Path "${path77}" is outside the workspace directory "${this.projectRoot}"`);
           }
         } catch (err) {
           if (err instanceof WorkspaceError)
@@ -7688,12 +7722,12 @@ var init_git_manager = __esm({
             const code = parts[0];
             const status = code[0];
             const isRenameOrCopy = status === "R" || status === "C";
-            const path76 = isRenameOrCopy ? parts[2] : parts[1];
-            if (!path76 || seen.has(path76))
+            const path77 = isRenameOrCopy ? parts[2] : parts[1];
+            if (!path77 || seen.has(path77))
               continue;
-            seen.add(path76);
+            seen.add(path77);
             files.push({
-              path: path76,
+              path: path77,
               status,
               from: isRenameOrCopy ? parts[1] : void 0
             });
@@ -7841,9 +7875,9 @@ var init_git_manager = __esm({
        *  empty for an added file or the root commit) and `modified` is the version
        *  at `commit` (empty for a deletion). The working-tree/staged path above is
        *  left entirely untouched (commit === undefined preserves existing behavior). */
-      async getFileDiff(path76, staged, from, commit) {
+      async getFileDiff(path77, staged, from, commit) {
         if (commit) {
-          const parentPath = from || path76;
+          const parentPath = from || path77;
           let original2 = "";
           try {
             original2 = await this.git.show([`${commit}^:${parentPath}`]);
@@ -7852,13 +7886,13 @@ var init_git_manager = __esm({
           }
           let modified2 = "";
           try {
-            modified2 = await this.git.show([`${commit}:${path76}`]);
+            modified2 = await this.git.show([`${commit}:${path77}`]);
           } catch {
             modified2 = "";
           }
           return { original: original2, modified: modified2 };
         }
-        const headPath = from || path76;
+        const headPath = from || path77;
         let original = "";
         try {
           original = await this.git.show([`HEAD:${headPath}`]);
@@ -7868,13 +7902,13 @@ var init_git_manager = __esm({
         let modified = "";
         if (staged) {
           try {
-            modified = await this.git.show([`:${path76}`]);
+            modified = await this.git.show([`:${path77}`]);
           } catch {
             modified = "";
           }
         } else {
           try {
-            modified = await this.workspace.readFile(path76);
+            modified = await this.workspace.readFile(path77);
           } catch {
             modified = "";
           }
@@ -12171,7 +12205,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.10");
+  providers = registerSdk2(process.env.OTEL_SERVICE_NAME, "1.5.11");
   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;
 }
@@ -12574,7 +12608,7 @@ var init_session_manager = __esm({
     init_session_skill_commands();
     init_session_state_store();
     init_genai_spans();
-    CONTINUE_TASK_KICK = `[System] You called continue_task: the task interrupted earlier is not finished. Resume it now from where it stopped. Any tool call marked "[tool execution interrupted \u2014 no result]" did not run \u2014 re-issue it if you still need the result (this overrides the marker's do-not-retry note \u2014 you explicitly asked to continue).`;
+    CONTINUE_TASK_KICK = `[System] You called continue_task: the task interrupted earlier is not finished. Resume it now from where it stopped. Any tool call marked "[tool execution interrupted \u2014 no result]" was cut off mid-run and its result is lost, and any marked "was not run" never started \u2014 re-issue either if you still need the result (this overrides the interrupted marker's do-not-retry note \u2014 you explicitly asked to continue).`;
     SessionManager = class _SessionManager {
       // The fields below are marked `internal:` because they're consumed by
       // helpers in this directory (session-tools.ts). Treat them as
@@ -13319,6 +13353,7 @@ var init_session_manager = __esm({
           message = i === -1 ? [{ type: "text", text: stamp }, ...message] : message.map((b, j) => j === i && b.type === "text" ? { type: "text", text: stamped(b.text) } : b);
         }
         beginTurn(session, message);
+        let batchRan = false;
         for (let attempt = 0; attempt < maxRetries; attempt++) {
           session.abortController = new AbortController();
           const signal = session.abortController.signal;
@@ -13333,6 +13368,10 @@ var init_session_manager = __esm({
                 this.trimImages(session);
                 await this.maybeAutoCompact(session);
                 this.saveAgentState(session);
+                if (session.interruptRequested && batchRan) {
+                  console.debug(`[SessionManager] Soft interrupt at batch boundary in ${session.id}`);
+                  session.abortController?.abort(abortReason("interrupt"));
+                }
               }
             });
             for await (const event of iter) {
@@ -13341,13 +13380,10 @@ var init_session_manager = __esm({
               if (event.type === "text") {
                 resultText += event.text ?? "";
               }
+              if (event.type === "tool_result")
+                batchRan = true;
               onAgentEvent(session, event);
               this.processSessionEvent(session, event);
-              if (session.interruptRequested && event.type === "tool_result") {
-                console.debug(`[SessionManager] Graceful interrupt after tool result in ${session.id}`);
-                session.abortController?.abort(abortReason("interrupt"));
-                this.markPendingToolCallsInterrupted(session.id);
-              }
             }
             session.abortController = null;
             if (session.interruptRequested) {
@@ -13765,15 +13801,18 @@ ${body}`;
       }
       // ── Session operations ─────────────────────────────────────────────
       /**
-       * UI-only repair for an aborted turn: emit a synthetic `tool_result` for
+       * UI-only repair for a hard-aborted turn: emit a synthetic `tool_result` for
        * every pending tool call (tool_call seen, no output yet) in the session's
        * cached UI log. On abort, runAgentTurn's consumer loop breaks on
        * `signal.aborted` BEFORE processing the in-flight tool's real tool_result
-       * event, so without this the UI block stays "running" forever. Routing
-       * through the normal emitEvent pipeline means ui-log-builder persistence,
-       * admin WS push, and TUI rendering all pick it up unchanged. Never touches
-       * agent.messages — the model-facing repair is conversation-repair's
-       * synthesized [interrupted] tool_result. Idempotent: completed tools
+       * event, so without this the UI block stays "running" forever. The batch
+       * runs serially and setToolResult fills the first pending entry, so the
+       * first pending call is the one that was running (`[interrupted by user]`,
+       * model side: repair's do-not-retry marker) and the rest never started
+       * (`[not run — interrupted]`, model side: agent-loop's "not run" result).
+       * Routing through the normal emitEvent pipeline means ui-log-builder
+       * persistence, admin WS push, and TUI rendering all pick it up unchanged.
+       * Never touches agent.messages. Idempotent: completed tools
        * (output already set) are never overwritten. Call BEFORE awaiting the
        * aborted turn's promise — its finally emits `complete`, which flushes and
        * clears the pending buffers this scans.
@@ -13790,12 +13829,12 @@ ${body}`;
         if (pending.length === 0)
           return;
         const session = this.sessions.get(sessionId);
-        for (const tc of pending) {
+        for (const [i, tc] of pending.entries()) {
           this.emitEvent(sessionId, {
             type: "tool_result",
             toolName: tc.name,
             toolUseId: tc.toolUseId,
-            toolResult: "[interrupted by user]",
+            toolResult: i === 0 ? "[interrupted by user]" : "[not run \u2014 interrupted]",
             agentName: session?.agentName,
             agentId: session?.agentId,
             taskId: sessionId === rootId ? void 0 : sessionId
@@ -13811,7 +13850,7 @@ ${body}`;
        * single semantic shared by esc (TUI / admin) and the `interrupt_session`
        * tool:
        *
-       *   - abort the in-flight turn at once (not at the next tool_result),
+       *   - abort the in-flight turn at once (not at the next batch boundary),
        *   - do NOT discard `messageQueue`: once the aborted turn unwinds,
        *     runSession's runFn drains every queued message into ONE merged follow-up
        *     turn (drainQueue). An empty queue just goes idle.
@@ -14213,6 +14252,10 @@ ${result.summary}`, agentName: "user", report: true, taskId });
       isSessionCompacting(sessionId) {
         return this.sessions.get(sessionId)?.isCompacting ?? false;
       }
+      /** Any message waiting in the session's queue (a turn / endCompact drains it) */
+      hasQueuedMessages(sessionId) {
+        return (this.sessions.get(sessionId)?.messageQueue.length ?? 0) > 0;
+      }
       /** Check if a session is running */
       isSessionRunning(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -14739,7 +14782,7 @@ ${result.summary}`, agentName: "user", report: true, taskId });
       /** Enqueue a user message directly (admin WS busy/compacting queue path).
        *  Pushes onto the single messageQueue with no `sourceSessionId` (a user
        *  message), and requests a SOFT interrupt so a busy turn yields after its
-       *  current tool — same effect as sendUserMessage's busy branch, minus the
+       *  current tool batch — same effect as sendUserMessage's busy branch, minus the
        *  idle/run path (the caller already established the session is busy or
        *  compacting). A compact outside a live model loop (manual /compact, or the
        *  turn-end auto-compact — abortController already null) has nothing to
@@ -14747,7 +14790,7 @@ ${result.summary}`, agentName: "user", report: true, taskId });
        *  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
+       *  flag is set, so the turn yields at its next batch boundary instead of running on
        *  to its natural end with the message still queued. */
       async enqueueUserMessage(sessionId, text6, images) {
         const session = this.sessions.get(sessionId);
@@ -16731,8 +16774,8 @@ function applyPathPick(value, ref, pick) {
   const before = value.slice(0, markerStart);
   const kind = ref.kind === "scope" ? "scope" : ref.kind === "image" ? "image" : pick.isImage ? "image" : "file";
   const needsQuote = pick.insertPath.includes(" ");
-  const path76 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
-  return `${before}@${kind} ${path76}`;
+  const path77 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
+  return `${before}@${kind} ${path77}`;
 }
 var init_path_suggest_engine = __esm({
   "src/tui/path-suggest-engine.ts"() {
@@ -17691,7 +17734,9 @@ function App({ harness, verbose }) {
     let cancelled = false;
     harness.getSessionMessages(harness.sessionId).then((msgs) => {
       if (cancelled || !msgs || msgs.length === 0) return;
-      const blocks = messagesToBlocks(msgs);
+      const all = messagesToBlocks(msgs);
+      const hidden = all.length - REPLAY_BLOCKS;
+      const blocks = hidden > 0 ? [{ id: nextId(), kind: "system", text: `\u2500\u2500 ${hidden} earlier messages hidden \xB7 ctrl+o for the full log \u2500\u2500` }, ...all.slice(-REPLAY_BLOCKS)] : all;
       if (blocks.length > 0) dispatch6({ type: "load-history", blocks });
     }).catch(() => {
     });
@@ -17954,7 +17999,7 @@ ${lines.join("\n")}` });
     ] })
   ] });
 }
-var MAX_CONTEXT_TOKENS_FALLBACK, blockSeq, ANSI2;
+var MAX_CONTEXT_TOKENS_FALLBACK, blockSeq, REPLAY_BLOCKS, ANSI2;
 var init_app = __esm({
   "src/tui/app.tsx"() {
     "use strict";
@@ -17970,6 +18015,7 @@ var init_app = __esm({
     init_log_viewer();
     MAX_CONTEXT_TOKENS_FALLBACK = 272e3;
     blockSeq = 0;
+    REPLAY_BLOCKS = 100;
     ANSI2 = {
       reset: "\x1B[0m",
       dim: "\x1B[2m",
@@ -20795,8 +20841,8 @@ function detectOrphans(tree, declared) {
       if (!block || typeof block !== "object")
         continue;
       for (const k of Object.keys(block)) {
-        const path76 = `${namespaceId}.${kindWord}.${k}`;
-        if (!declaredMap.has(path76)) {
+        const path77 = `${namespaceId}.${kindWord}.${k}`;
+        if (!declaredMap.has(path77)) {
           out.push({ namespaceId, kind: kindWord === "params" ? "param" : "secret", key: k });
         }
       }
@@ -21877,11 +21923,18 @@ var init_session_prefix = __esm({
 });
 
 // ../server/dist/channels/web/handler.js
+import fs49 from "node:fs";
 function buildWebSessionPrefix(accountId) {
   return sessionPrefix("web", accountId);
 }
 function canAddressSession(account, sessionId) {
-  return account.accessLevel === "full" || sessionId.startsWith(buildWebSessionPrefix(account.accountId));
+  const prefix = buildWebSessionPrefix(account.accountId);
+  return account.accessLevel === "full" || sessionId.startsWith(prefix) || isOwnGoalSession(account, sessionId, prefix);
+}
+function isOwnGoalSession(account, sessionId, prefix) {
+  if (!sessionId.startsWith("goal_") || !hasWorkspaceHalo(account.workspacePath))
+    return false;
+  return readGoalState(getWorkspaceDb(account.workspacePath).db, sessionId)?.workerSessionId.startsWith(prefix) ?? false;
 }
 function createWebChannel(deps) {
   const { registry: registry2, db } = deps;
@@ -21890,24 +21943,24 @@ function createWebChannel(deps) {
     const prefix = buildWebSessionPrefix(accountId);
     return findActiveSessionId(sm, accountId, prefix, activeOverrides2, "full") ?? void 0;
   }
-  function resolveWorkspace(account, override) {
-    let path76 = account.workspacePath;
+  function resolveWorkspace(account, override, scaffold = true) {
+    let path77 = account.workspacePath;
     if (override && override !== account.workspacePath) {
       if (account.accessLevel !== "full") {
         return { ok: false, error: "workspace override requires a full-access token" };
       }
-      path76 = override;
+      path77 = override;
     }
-    const resolved = resolveAccountWorkspace({ ...account, workspacePath: path76 });
+    const resolved = scaffold ? resolveAccountWorkspace({ ...account, workspacePath: path77 }) : fs49.existsSync(path77) ? path77 : null;
     if (!resolved)
       return { ok: false, error: "workspace not found" };
     return { ok: true, path: resolved };
   }
-  function resolveRequest(token, workspaceOverride) {
+  function resolveRequest(token, workspaceOverride, scaffold = true) {
     const account = getAccountByToken(db, token);
     if (!account || !account.enabled)
       return { ok: false, error: "Invalid or disabled token" };
-    const ws = resolveWorkspace(account, workspaceOverride);
+    const ws = resolveWorkspace(account, workspaceOverride, scaffold);
     if (!ws.ok)
       return ws;
     return { ok: true, account, workspace: ws.path };
@@ -22119,7 +22172,9 @@ function createWebChannel(deps) {
     const state = sm.getUIState(sessionId);
     if (!state)
       return { sessionId, messages: [], running: false };
-    const messages2 = createSaveSnapshot(state);
+    const snapshot3 = createSaveSnapshot(state);
+    const since = opts?.since;
+    const messages2 = since === void 0 ? snapshot3 : snapshot3.filter((m) => !m.taskId && m.timestamp >= since);
     const running = sm.isSessionRunning(sessionId);
     return { sessionId, messages: messages2, running };
   }
@@ -22138,6 +22193,21 @@ function createWebChannel(deps) {
     await sm.createSession(agent.id, null, `Web: ${account.label || account.accountId}`, void 0, sessionId, void 0, accessLevel);
     return { ok: true, sessionId };
   }
+  function listSessions2(token, opts) {
+    const req = resolveRequest(token, opts?.workspace, false);
+    if (!req.ok)
+      return req;
+    if (!hasWorkspaceHalo(req.workspace))
+      return { ok: true, workspace: req.workspace, sessions: [], nextCursor: null };
+    const sm = registry2.getOrCreate(req.workspace);
+    const page = sm.listSessions({ rootOnly: true, prefix: buildWebSessionPrefix(req.account.accountId), limit: WEB_LIST_PAGE, cursor: opts?.cursor });
+    return {
+      ok: true,
+      workspace: req.workspace,
+      sessions: page.sessions.map((s) => ({ sessionId: s.id, title: s.title || s.description || null, updatedAt: s.updatedAt })),
+      nextCursor: page.nextCursor
+    };
+  }
   async function* subscribe(token, signal, opts) {
     const req = resolveRequest(token, opts?.workspace);
     if (!req.ok) {
@@ -22151,9 +22221,16 @@ function createWebChannel(deps) {
       return;
     }
     yield sseData({ type: "session", sessionId });
-    yield* listenSession(sm, sessionId).events(signal);
+    const listener = listenSession(sm, sessionId);
+    const busy = sm.isSessionRunning(sessionId) || sm.isSessionCompacting(sessionId) && sm.hasQueuedMessages(sessionId);
+    if (!busy) {
+      listener.close();
+      yield sseData({ type: "complete" });
+      return;
+    }
+    yield* listener.events(signal);
   }
-  return { handleMessage, handleStop, getHistory, subscribe, createSession };
+  return { handleMessage, handleStop, getHistory, subscribe, createSession, listSessions: listSessions2 };
 }
 function sseData(obj) {
   return `data: ${JSON.stringify(obj)}
@@ -22196,12 +22273,14 @@ function createMediaBuffer() {
         const out = flushAll() + sseData({ type: "thinking", text: event.text ?? "" });
         return out;
       }
+      // `toolUseId` pairs a result with its call (the ACP adapter uses it as
+      // the stable toolCallId); additive — older clients ignore it.
       case "tool_call": {
-        const out = flushAll() + sseData({ type: "tool_call", toolName: event.toolName, toolInput: event.toolInput });
+        const out = flushAll() + sseData({ type: "tool_call", toolName: event.toolName, toolUseId: event.toolUseId, toolInput: event.toolInput });
         return out;
       }
       case "tool_result": {
-        const out = flushAll() + sseData({ type: "tool_result", toolName: event.toolName, result: event.toolResult?.slice(0, 500) });
+        const out = flushAll() + sseData({ type: "tool_result", toolName: event.toolName, toolUseId: event.toolUseId, result: event.toolResult?.slice(0, 500) });
         return out;
       }
       case "complete": {
@@ -22223,6 +22302,7 @@ function createMediaBuffer() {
     }
   };
 }
+var WEB_LIST_PAGE;
 var init_handler = __esm({
   "../server/dist/channels/web/handler.js"() {
     "use strict";
@@ -22235,9 +22315,11 @@ var init_handler = __esm({
     init_commands2();
     init_agent_loader();
     init_db();
+    init_init();
     init_goal_mode();
     init_i18n();
     init_session_prefix();
+    WEB_LIST_PAGE = 50;
   }
 });
 
@@ -22297,13 +22379,13 @@ var init_session_types = __esm({
 
 // ../server/dist/routes/halo-city.js
 import { Hono as Hono10 } from "hono";
-import fs49 from "node:fs";
+import fs50 from "node:fs";
 import path58 from "node:path";
 import Database6 from "better-sqlite3";
 function scanSkills2(dir) {
   let names;
   try {
-    names = fs49.readdirSync(dir);
+    names = fs50.readdirSync(dir);
   } catch {
     return [];
   }
@@ -22312,7 +22394,7 @@ function scanSkills2(dir) {
     const skillMd = path58.join(dir, entry, "SKILL.md");
     let stat;
     try {
-      stat = fs49.statSync(skillMd);
+      stat = fs50.statSync(skillMd);
       if (!stat.isFile())
         continue;
     } catch {
@@ -22321,7 +22403,7 @@ function scanSkills2(dir) {
     let meta = _skillCache.get(skillMd, stat.mtimeMs);
     if (!meta) {
       try {
-        const { name, description, command } = parseSkillFrontmatter(fs49.readFileSync(skillMd, "utf-8"));
+        const { name, description, command } = parseSkillFrontmatter(fs50.readFileSync(skillMd, "utf-8"));
         meta = _skillCache.set(skillMd, stat.mtimeMs, { id: entry, name: name || entry, description: description ?? "", command });
       } catch {
         continue;
@@ -22421,7 +22503,7 @@ function snapshotWorkspace(sm, wsPath, label) {
 function roReader(rawPath) {
   let wsPath;
   try {
-    wsPath = fs49.realpathSync(rawPath);
+    wsPath = fs50.realpathSync(rawPath);
   } catch {
     return null;
   }
@@ -22429,7 +22511,7 @@ function roReader(rawPath) {
   if (cached)
     return cached;
   const dbPath = path58.join(wsPath, ".halo", "halo.db");
-  if (!fs49.existsSync(dbPath))
+  if (!fs50.existsSync(dbPath))
     return null;
   try {
     const db = new Database6(dbPath, { readonly: true, fileMustExist: true });
@@ -22457,7 +22539,7 @@ function dropRoReader(rawPath) {
     return;
   let wsPath = rawPath;
   try {
-    wsPath = fs49.realpathSync(rawPath);
+    wsPath = fs50.realpathSync(rawPath);
   } catch {
   }
   const r = _roReaders.get(wsPath);
@@ -22554,7 +22636,7 @@ function workspaceBirth(wsPath) {
   let b = _birthCache.get(wsPath);
   if (b === void 0) {
     try {
-      b = fs49.statSync(wsPath).birthtimeMs || fs49.statSync(wsPath).ctimeMs;
+      b = fs50.statSync(wsPath).birthtimeMs || fs50.statSync(wsPath).ctimeMs;
     } catch {
       b = 0;
     }
@@ -22566,7 +22648,7 @@ function discoverWorkspaces(registry2) {
   const out = /* @__PURE__ */ new Map();
   const add = (p, label) => {
     try {
-      const resolved = fs49.realpathSync(p);
+      const resolved = fs50.realpathSync(p);
       if (!out.has(resolved))
         out.set(resolved, label);
     } catch {
@@ -22630,7 +22712,7 @@ function createShowRoutes(registry2) {
     if (!globalView) {
       let allowed = false;
       try {
-        allowed = fs49.realpathSync(wsPath) === fs49.realpathSync(account.workspacePath);
+        allowed = fs50.realpathSync(wsPath) === fs50.realpathSync(account.workspacePath);
       } catch {
       }
       if (!allowed || !canAddressSession(account, id))
@@ -22826,7 +22908,7 @@ var init_commands3 = __esm({
 // ../server/dist/routes/agentcore.js
 import { Hono as Hono13 } from "hono";
 import path59 from "node:path";
-import fs50 from "node:fs";
+import fs51 from "node:fs";
 function sanitizeRuntimeId(runtimeSessionId) {
   return runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
 }
@@ -22835,7 +22917,7 @@ function haloSessionId(runtimeSessionId) {
 }
 function userWorkspace(base, runtimeSessionId) {
   const dir = path59.join(base, "users", sanitizeRuntimeId(runtimeSessionId));
-  fs50.mkdirSync(dir, { recursive: true });
+  fs51.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function acceptChunk(uploads, msg) {
@@ -23372,17 +23454,17 @@ function passwordStrengthError(pw) {
 }
 function authMiddleware() {
   return async (c, next) => {
-    const path76 = c.req.path;
-    if (PUBLIC_PATHS.some((p) => path76 === p || path76.startsWith(p + "?"))) {
+    const path77 = c.req.path;
+    if (PUBLIC_PATHS.some((p) => path77 === p || path77.startsWith(p + "?"))) {
       return next();
     }
-    if (EXTENSION_ASSET_PATH.test(path76)) {
+    if (EXTENSION_ASSET_PATH.test(path77)) {
       return next();
     }
     const token = getCookie(c, COOKIE_NAME);
     const payload = validateToken(token);
     if (!payload) {
-      if (!path76.startsWith("/api/")) {
+      if (!path77.startsWith("/api/")) {
         return next();
       }
       return c.json({ error: "Unauthorized" }, 401);
@@ -23644,7 +23726,7 @@ var init_upgrade_router = __esm({
 });
 
 // ../server/dist/ws/file-watcher.js
-import fs51 from "node:fs";
+import fs52 from "node:fs";
 import path60 from "node:path";
 function enqueueNativeOp(op) {
   const result = nativeOpChain.then(op);
@@ -23754,7 +23836,7 @@ var init_file_watcher = __esm({
         }
         let root = workspaceRoot;
         try {
-          root = fs51.realpathSync(workspaceRoot);
+          root = fs52.realpathSync(workspaceRoot);
         } catch {
         }
         if (this.subscription && this.workspaceRoot === root)
@@ -23812,7 +23894,7 @@ var init_file_watcher = __esm({
         } else {
           let isDir = false;
           try {
-            isDir = fs51.statSync(absPath).isDirectory();
+            isDir = fs52.statSync(absPath).isDirectory();
           } catch {
           }
           action = isDir ? "addDir" : "add";
@@ -23888,7 +23970,7 @@ var init_file_watcher = __esm({
 });
 
 // ../server/dist/ws/git-dir-watcher.js
-import fs52 from "node:fs";
+import fs53 from "node:fs";
 import path61 from "node:path";
 var GitDirWatcher;
 var init_git_dir_watcher = __esm({
@@ -23914,7 +23996,7 @@ var init_git_dir_watcher = __esm({
         this.stop();
         this.workspaceRoot = workspaceRoot;
         const gitDir = path61.join(workspaceRoot, ".git");
-        if (fs52.existsSync(gitDir)) {
+        if (fs53.existsSync(gitDir)) {
           this.watchGitDir(gitDir);
         } else {
           this.watchParentForGit(workspaceRoot);
@@ -23923,7 +24005,7 @@ var init_git_dir_watcher = __esm({
       /** Watch the `.git` dir for index/HEAD changes (steady state). */
       watchGitDir(gitDir) {
         try {
-          this.watcher = fs52.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs53.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleGitEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -23942,7 +24024,7 @@ var init_git_dir_watcher = __esm({
        *  Exists solely during the non-repo window; upgraded away on first `.git`. */
       watchParentForGit(workspaceRoot) {
         try {
-          this.watcher = fs52.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs53.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleParentEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -23979,7 +24061,7 @@ var init_git_dir_watcher = __esm({
         if (!root)
           return;
         const gitDir = path61.join(root, ".git");
-        if (!fs52.existsSync(gitDir))
+        if (!fs53.existsSync(gitDir))
           return;
         this.closeWatcher();
         this.watchGitDir(gitDir);
@@ -25001,9 +25083,9 @@ import Database7 from "better-sqlite3";
 import { drizzle as drizzle5 } from "drizzle-orm/better-sqlite3";
 import { sqliteTable as sqliteTable5, text as text5, integer as integer5 } from "drizzle-orm/sqlite-core";
 import path63 from "node:path";
-import fs53 from "node:fs";
+import fs54 from "node:fs";
 function createCronDb(globalDir2) {
-  fs53.mkdirSync(globalDir2, { recursive: true });
+  fs54.mkdirSync(globalDir2, { recursive: true });
   const dbPath = path63.join(globalDir2, "cron.db");
   const sqlite = new Database7(dbPath);
   sqlite.pragma("journal_mode = WAL");
@@ -25234,7 +25316,7 @@ var init_dispatcher = __esm({
 
 // ../server/dist/cron/runner.js
 import { spawn as spawn3, execFileSync } from "node:child_process";
-import fs54 from "node:fs";
+import fs55 from "node:fs";
 import path64 from "node:path";
 import { homedir as homedir23 } from "node:os";
 import { Cron } from "croner";
@@ -25311,7 +25393,7 @@ function effectiveSessionId(job) {
 function sessionKeyFor(workspacePath, sessionId) {
   let ws;
   try {
-    ws = fs54.realpathSync(workspacePath);
+    ws = fs55.realpathSync(workspacePath);
   } catch {
     ws = path64.resolve(workspacePath);
   }
@@ -25386,7 +25468,7 @@ function sweepOrphanRuns(opts) {
   }
 }
 function startCronDaemon() {
-  fs54.mkdirSync(logsDir(), { recursive: true });
+  fs55.mkdirSync(logsDir(), { recursive: true });
   sweepOrphanRuns();
   reloadAll();
   _daemonTimers.push(setInterval(pruneOldLogs, DAY_MS2));
@@ -25566,7 +25648,7 @@ async function runJob(jobId, triggerKind) {
   const runId = newRunId();
   const startedAt = Date.now();
   const logPath = logPathFor(runId);
-  fs54.mkdirSync(logsDir(), { recursive: true });
+  fs55.mkdirSync(logsDir(), { recursive: true });
   const sessionId = effectiveSessionId(job);
   const sessionKey = sessionKeyFor(job.workspacePath, sessionId);
   const host = _sessionRegistry?.peek(job.workspacePath);
@@ -25606,7 +25688,7 @@ async function runJob(jobId, triggerKind) {
     }).run();
     broadcast({ type: "cron:run_changed", jobId, runId, status: "running" });
     const targets = parseTargets(job.targets);
-    if (!fs54.existsSync(job.workspacePath)) {
+    if (!fs55.existsSync(job.workspacePath)) {
       finalize(runId, jobId, {
         status: "failed",
         output: null,
@@ -25623,7 +25705,7 @@ async function runJob(jobId, triggerKind) {
       args.push("--access", accessLevel);
     const [spawnBin, spawnArgs] = process.platform === "win32" && cli.endsWith(".cmd") ? ["cmd.exe", ["/c", cli, ...args]] : [cli, args];
     const timeoutSec = job.timeoutSec ?? CLI_TIMEOUT_SEC;
-    const teeStream = fs54.createWriteStream(logPath, { flags: "a" });
+    const teeStream = fs55.createWriteStream(logPath, { flags: "a" });
     teeStream.write(`=== ${(/* @__PURE__ */ new Date()).toISOString()} cron run ${runId} job=${jobId} trigger=${triggerKind} ===
 `);
     teeStream.write(`agent=${job.agentId} session=${sessionId}${accessLevel ? ` access=${accessLevel}` : ""} workspace=${job.workspacePath} schedule=${job.schedule}
@@ -25812,15 +25894,15 @@ function pruneOldRuns(jobId) {
 }
 function pruneOldLogs() {
   const dir = logsDir();
-  if (!fs54.existsSync(dir))
+  if (!fs55.existsSync(dir))
     return;
   const cutoff = Date.now() - LOG_RETENTION_DAYS * DAY_MS2;
-  for (const name of fs54.readdirSync(dir)) {
+  for (const name of fs55.readdirSync(dir)) {
     const p = path64.join(dir, name);
     try {
-      const stat = fs54.statSync(p);
+      const stat = fs55.statSync(p);
       if (stat.mtimeMs < cutoff)
-        fs54.rmSync(p, { force: true });
+        fs55.rmSync(p, { force: true });
     } catch {
     }
   }
@@ -25859,7 +25941,7 @@ var init_runner = __esm({
 // ../server/dist/routes/cron.js
 import { Hono as Hono15 } from "hono";
 import { eq as eq15, desc as desc3, lt as lt6, and as and11 } from "drizzle-orm";
-import fs55 from "node:fs/promises";
+import fs56 from "node:fs/promises";
 import { Cron as Cron2 } from "croner";
 function newJobId() {
   return `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -26153,7 +26235,7 @@ function createCronRoutes() {
       return c.json({ log: null });
     let log2 = null;
     try {
-      log2 = await fs55.readFile(row.logPath, "utf-8");
+      log2 = await fs56.readFile(row.logPath, "utf-8");
     } catch {
     }
     return c.json({ log: log2 });
@@ -26217,7 +26299,7 @@ var init_cron = __esm({
 });
 
 // ../server/dist/extensions/install.js
-import fs56 from "node:fs";
+import fs57 from "node:fs";
 import path65 from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import JSZip2 from "jszip";
@@ -26251,41 +26333,41 @@ async function unpackZip(zipBuf, dest) {
       throw new ExtensionInstallError(`zip entry is a symlink: ${entry.name}`);
     const abs = path65.join(dest, rel);
     if (entry.dir) {
-      fs56.mkdirSync(abs, { recursive: true });
+      fs57.mkdirSync(abs, { recursive: true });
       continue;
     }
-    fs56.mkdirSync(path65.dirname(abs), { recursive: true });
-    fs56.writeFileSync(abs, await entry.async("nodebuffer"));
+    fs57.mkdirSync(path65.dirname(abs), { recursive: true });
+    fs57.writeFileSync(abs, await entry.async("nodebuffer"));
   }
 }
 function stripWrapperDir(dir) {
-  if (fs56.existsSync(path65.join(dir, MANIFEST_FILE)))
+  if (fs57.existsSync(path65.join(dir, MANIFEST_FILE)))
     return;
-  const children = fs56.readdirSync(dir, { withFileTypes: true });
+  const children = fs57.readdirSync(dir, { withFileTypes: true });
   if (children.length !== 1 || !children[0].isDirectory())
     return;
   const inner = path65.join(dir, children[0].name);
-  if (!fs56.existsSync(path65.join(inner, MANIFEST_FILE)))
+  if (!fs57.existsSync(path65.join(inner, MANIFEST_FILE)))
     return;
-  for (const name of fs56.readdirSync(inner)) {
-    fs56.renameSync(path65.join(inner, name), path65.join(dir, name));
+  for (const name of fs57.readdirSync(inner)) {
+    fs57.renameSync(path65.join(inner, name), path65.join(dir, name));
   }
-  fs56.rmdirSync(inner);
+  fs57.rmdirSync(inner);
 }
 function rand() {
   return randomBytes2(3).toString("hex");
 }
 async function installExtensionZip(zipBuf, expectId) {
   const root = extensionsRoot();
-  fs56.mkdirSync(root, { recursive: true });
+  fs57.mkdirSync(root, { recursive: true });
   const stage = path65.join(root, `.tmp-unpack-${rand()}`);
-  fs56.mkdirSync(stage);
+  fs57.mkdirSync(stage);
   try {
     await unpackZip(zipBuf, stage);
     stripWrapperDir(stage);
     let manifestId;
     try {
-      const raw = JSON.parse(fs56.readFileSync(path65.join(stage, MANIFEST_FILE), "utf-8"));
+      const raw = JSON.parse(fs57.readFileSync(path65.join(stage, MANIFEST_FILE), "utf-8"));
       manifestId = typeof raw.id === "string" ? raw.id : "";
     } catch (err) {
       throw new ExtensionInstallError(`${MANIFEST_FILE} missing or unreadable at the zip root: ${err instanceof Error ? err.message : String(err)}`);
@@ -26299,34 +26381,34 @@ async function installExtensionZip(zipBuf, expectId) {
       throw new ExtensionInstallError(`invalid extension: ${verdict.error}`);
     const target = path65.join(root, manifestId);
     const old = path65.join(root, `.old-${manifestId}-${rand()}`);
-    const hadOld = fs56.existsSync(target);
+    const hadOld = fs57.existsSync(target);
     if (hadOld)
-      fs56.renameSync(target, old);
+      fs57.renameSync(target, old);
     try {
-      fs56.renameSync(stage, target);
+      fs57.renameSync(stage, target);
     } catch (err) {
       if (hadOld)
-        fs56.renameSync(old, target);
+        fs57.renameSync(old, target);
       throw err;
     }
     if (hadOld)
-      fs56.rmSync(old, { recursive: true, force: true });
+      fs57.rmSync(old, { recursive: true, force: true });
     const info = readExtensionDir(target);
     if ("error" in info)
       throw new ExtensionInstallError(`installed but failed re-validation: ${info.error}`);
     console.log(`[Extensions] installed ${info.id}@${info.version}${hadOld ? " (replaced previous)" : ""}`);
     return info;
   } finally {
-    fs56.rmSync(stage, { recursive: true, force: true });
+    fs57.rmSync(stage, { recursive: true, force: true });
   }
 }
 function uninstallExtension(id) {
   if (!isExtensionId(id))
     throw new ExtensionInstallError(`"${id}" is not a valid extension id`);
   const dir = path65.join(extensionsRoot(), id);
-  if (!fs56.existsSync(dir))
+  if (!fs57.existsSync(dir))
     return false;
-  fs56.rmSync(dir, { recursive: true, force: true });
+  fs57.rmSync(dir, { recursive: true, force: true });
   console.log(`[Extensions] removed ${id}`);
   return true;
 }
@@ -26343,7 +26425,7 @@ var init_install2 = __esm({
 });
 
 // ../server/dist/extensions/watcher.js
-import fs57 from "node:fs";
+import fs58 from "node:fs";
 function scheduleFlush() {
   if (flushTimer)
     return;
@@ -26362,7 +26444,7 @@ function rescanAndBroadcast() {
 }
 function openWatcher(root) {
   try {
-    watcher = fs57.watch(root, { persistent: false, recursive: false }, () => scheduleFlush());
+    watcher = fs58.watch(root, { persistent: false, recursive: false }, () => scheduleFlush());
     watcher.on("error", (err) => {
       console.warn(`[Extensions] watch error on ${root}: ${err.message} \u2014 retrying in 1s`);
       closeWatcher();
@@ -26388,7 +26470,7 @@ function start() {
     return;
   const root = extensionsRoot();
   try {
-    fs57.mkdirSync(root, { recursive: true });
+    fs58.mkdirSync(root, { recursive: true });
   } catch (err) {
     console.warn(`[Extensions] cannot create ${root}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -26423,7 +26505,7 @@ var init_watcher = __esm({
 
 // ../server/dist/routes/extensions.js
 import { Hono as Hono16 } from "hono";
-import fs58 from "node:fs";
+import fs59 from "node:fs";
 import path66 from "node:path";
 import { Readable as Readable2 } from "node:stream";
 function assetMime(fileName) {
@@ -26442,15 +26524,15 @@ function resolveAsset(id, version, rest) {
   let dir;
   let real;
   try {
-    dir = fs58.realpathSync(path66.join(extensionsRoot(), id));
-    real = fs58.realpathSync(path66.join(dir, ...segments));
+    dir = fs59.realpathSync(path66.join(extensionsRoot(), id));
+    real = fs59.realpathSync(path66.join(dir, ...segments));
   } catch {
     return null;
   }
   if (real !== dir && !real.startsWith(dir + path66.sep))
     return null;
   try {
-    if (!fs58.statSync(real).isFile())
+    if (!fs59.statSync(real).isFile())
       return null;
   } catch {
     return null;
@@ -26512,8 +26594,8 @@ function createExtensionRoutes() {
     const abs = resolveAsset(c.req.param("id"), c.req.param("version"), c.req.param("rest"));
     if (!abs)
       return c.json({ error: "Not found" }, 404);
-    const stat = fs58.statSync(abs);
-    const nodeStream = fs58.createReadStream(abs);
+    const stat = fs59.statSync(abs);
+    const nodeStream = fs59.createReadStream(abs);
     c.req.raw.signal?.addEventListener("abort", () => nodeStream.destroy(), { once: true });
     return new Response(Readable2.toWeb(nodeStream), {
       headers: {
@@ -26567,7 +26649,7 @@ var init_extensions = __esm({
 });
 
 // ../server/dist/models/watcher.js
-import fs59 from "node:fs";
+import fs60 from "node:fs";
 function snapshot2() {
   const { effective } = loadProviders();
   return {
@@ -26595,7 +26677,7 @@ function reloadAndBroadcast() {
 }
 function openWatcher2(root) {
   try {
-    watcher2 = fs59.watch(root, { persistent: false, recursive: false }, () => scheduleFlush2());
+    watcher2 = fs60.watch(root, { persistent: false, recursive: false }, () => scheduleFlush2());
     watcher2.on("error", (err) => {
       console.warn(`[Models] watch error on ${root}: ${err.message} \u2014 retrying in 1s`);
       closeWatcher2();
@@ -26621,7 +26703,7 @@ function start2() {
     return;
   const root = globalHubModelsDir();
   try {
-    fs59.mkdirSync(root, { recursive: true });
+    fs60.mkdirSync(root, { recursive: true });
   } catch (err) {
     console.warn(`[Models] cannot create ${root}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -27738,12 +27820,12 @@ var init_handler3 = __esm({
 });
 
 // ../server/dist/routes/channel-accounts.js
-import fs60 from "node:fs";
+import fs61 from "node:fs";
 function accountListFields(a) {
   return {
     accountId: a.accountId,
     workspacePath: a.workspacePath,
-    workspaceMissing: !fs60.existsSync(a.workspacePath),
+    workspaceMissing: !fs61.existsSync(a.workspacePath),
     label: a.label,
     enabled: a.enabled,
     accessLevel: a.accessLevel,
@@ -28385,7 +28467,7 @@ var init_cdn = __esm({
 });
 
 // ../server/dist/channels/wechat/send-media.js
-import fs61 from "node:fs/promises";
+import fs62 from "node:fs/promises";
 import path68 from "node:path";
 function inferKind(filePath) {
   const cls = classifyMedia(filePath);
@@ -28398,7 +28480,7 @@ function inferKind(filePath) {
 async function sendMediaFile(params) {
   const { baseUrl, token, toUserId, contextToken, contextTokenAt, filePath } = params;
   const kind = params.kind ?? inferKind(filePath);
-  const plaintext = await fs61.readFile(filePath);
+  const plaintext = await fs62.readFile(filePath);
   const prep = prepareUpload(plaintext);
   console.log(`[WeChat] sendMediaFile: path=${filePath} kind=${kind} rawsize=${prep.rawsize} filesize=${prep.filesize}`);
   const mediaType = kind === "image" ? UploadMediaType.IMAGE : kind === "video" ? UploadMediaType.VIDEO : UploadMediaType.FILE;
@@ -28599,7 +28681,7 @@ var init_login = __esm({
 });
 
 // ../server/dist/channels/wechat/handler.js
-import fs62 from "node:fs";
+import fs63 from "node:fs";
 import path69 from "node:path";
 import QRCode from "qrcode";
 function wxRoute(fromUserId, contextToken, contextTokenAt) {
@@ -29030,7 +29112,7 @@ async function handleSlashCommand(args) {
         contextToken,
         filePath: tmpPath
       });
-      await fs62.promises.unlink(tmpPath).catch(() => {
+      await fs63.promises.unlink(tmpPath).catch(() => {
       });
       await reply(t("wechat.qr_sent", lang, { level, path: account.workspacePath }));
       waitLogin({ sessionKey: login.sessionKey }).then(async (result2) => {
@@ -29111,7 +29193,7 @@ var init_handler4 = __esm({
 // ../server/dist/routes/wechat.js
 import { Hono as Hono18 } from "hono";
 import path70 from "node:path";
-import fs63 from "node:fs";
+import fs64 from "node:fs";
 function createWechatRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono18();
@@ -29120,7 +29202,7 @@ function createWechatRoutes(deps) {
       return {
         ...stripSecrets(acc),
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs63.existsSync(acc.workspacePath)
+        workspaceMissing: !fs64.existsSync(acc.workspacePath)
       };
     });
     return c.json({ accounts });
@@ -29349,7 +29431,26 @@ var init_descriptor2 = __esm({
 import { Hono as Hono19 } from "hono";
 import { streamSSE } from "hono/streaming";
 import crypto5 from "node:crypto";
-import fs64 from "node:fs";
+import fs65 from "node:fs";
+function streamWithKeepalive(c, chunks) {
+  return streamSSE(c, async (stream) => {
+    const timer = setInterval(() => {
+      void stream.write(": keepalive\n\n");
+    }, SSE_KEEPALIVE_MS);
+    try {
+      for await (const chunk of chunks()) {
+        await stream.write(chunk);
+      }
+    } finally {
+      clearInterval(timer);
+    }
+  });
+}
+function epochParam(raw) {
+  if (raw === void 0 || raw === "")
+    return void 0;
+  return /^\d+$/.test(raw) ? Number(raw) : null;
+}
 function createWebRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono19();
@@ -29443,11 +29544,7 @@ function createWebRoutes(deps) {
     const denied = sessionOverrideError(c, auth.account, opts.sessionId);
     if (denied)
       return denied;
-    return streamSSE(c, async (stream) => {
-      for await (const chunk of channel.handleMessage(token, body.message ?? "", body.images, opts, c.req.raw.signal)) {
-        await stream.write(chunk);
-      }
-    });
+    return streamWithKeepalive(c, () => channel.handleMessage(token, body.message ?? "", body.images, opts, c.req.raw.signal));
   });
   app2.post("/web/sessions", async (c) => {
     const auth = authToken(c);
@@ -29463,6 +29560,18 @@ function createWebRoutes(deps) {
       return c.json({ error: result.error }, 403);
     return c.json({ sessionId: result.sessionId });
   });
+  app2.get("/web/sessions", (c) => {
+    const auth = authToken(c);
+    if (!auth.ok)
+      return auth.response;
+    const cursor = epochParam(c.req.query("cursor"));
+    if (cursor === null)
+      return c.json({ error: "Invalid cursor" }, 400);
+    const result = channel.listSessions(auth.token, { workspace: readOverrides(c).workspace, cursor });
+    if (!result.ok)
+      return c.json({ error: result.error }, 403);
+    return c.json({ workspace: result.workspace, sessions: result.sessions, nextCursor: result.nextCursor });
+  });
   app2.post("/web/stop", async (c) => {
     const auth = authToken(c);
     if (!auth.ok)
@@ -29482,7 +29591,10 @@ function createWebRoutes(deps) {
     const denied = sessionOverrideError(c, auth.account, overrides.sessionId);
     if (denied)
       return denied;
-    const result = channel.getHistory(auth.token, overrides);
+    const since = epochParam(c.req.query("since"));
+    if (since === null)
+      return c.json({ error: "Invalid since" }, 400);
+    const result = channel.getHistory(auth.token, { ...overrides, since });
     if (!result) {
       if (overrides.sessionId)
         return c.json({ error: "session not found" }, 404);
@@ -29500,11 +29612,7 @@ function createWebRoutes(deps) {
     const denied = sessionOverrideError(c, auth.account, opts.sessionId);
     if (denied)
       return denied;
-    return streamSSE(c, async (stream) => {
-      for await (const chunk of channel.subscribe(auth.token, abortController.signal, opts)) {
-        await stream.write(chunk);
-      }
-    });
+    return streamWithKeepalive(c, () => channel.subscribe(auth.token, abortController.signal, opts));
   });
   app2.get("/web/file", async (c) => {
     const auth = authToken(c);
@@ -29514,30 +29622,30 @@ function createWebRoutes(deps) {
     const filePath = c.req.query("path");
     if (!filePath)
       return c.json({ error: "path required" }, 400);
-    const path76 = await import("node:path");
-    const resolved = path76.default.resolve(account.workspacePath, filePath);
-    const root = path76.default.resolve(account.workspacePath);
-    if (resolved !== root && !resolved.startsWith(root + path76.default.sep)) {
+    const path77 = await import("node:path");
+    const resolved = path77.default.resolve(account.workspacePath, filePath);
+    const root = path77.default.resolve(account.workspacePath);
+    if (resolved !== root && !resolved.startsWith(root + path77.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     let real;
     let realRoot;
     try {
-      real = fs64.realpathSync(resolved);
-      realRoot = fs64.realpathSync(root);
+      real = fs65.realpathSync(resolved);
+      realRoot = fs65.realpathSync(root);
     } catch {
       return c.json({ error: "file not found" }, 404);
     }
-    if (real !== realRoot && !real.startsWith(realRoot + path76.default.sep)) {
+    if (real !== realRoot && !real.startsWith(realRoot + path77.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     if (isHiddenWorkspacePath(real, realRoot)) {
       return c.json({ error: "path is not accessible" }, 403);
     }
-    const stat = fs64.statSync(real);
+    const stat = fs65.statSync(real);
     if (stat.isDirectory())
       return c.json({ error: "cannot serve directory" }, 400);
-    const ext = path76.default.extname(real).toLowerCase();
+    const ext = path77.default.extname(real).toLowerCase();
     const nonImageMimes = {
       ".mp4": "video/mp4",
       ".webm": "video/webm",
@@ -29545,14 +29653,15 @@ function createWebRoutes(deps) {
       ".txt": "text/plain"
     };
     const contentType = imageMimeFromExt(ext) || nonImageMimes[ext] || "application/octet-stream";
-    const fileName = path76.default.basename(resolved);
-    const data = fs64.readFileSync(real);
+    const fileName = path77.default.basename(resolved);
+    const data = fs65.readFileSync(real);
     c.header("content-type", contentType);
     c.header("content-disposition", `inline; filename="${fileName}"`);
     return c.body(data);
   });
   return app2;
 }
+var SSE_KEEPALIVE_MS;
 var init_web = __esm({
   "../server/dist/routes/web.js"() {
     "use strict";
@@ -29564,6 +29673,7 @@ var init_web = __esm({
     init_web_token();
     init_sandbox();
     init_workspace_path();
+    SSE_KEEPALIVE_MS = 15e3;
   }
 });
 
@@ -29766,10 +29876,10 @@ async function authTest(botToken) {
   return slackPost("auth.test", botToken, {});
 }
 async function uploadFile(args) {
-  const fs68 = await import("node:fs");
-  const path76 = await import("node:path");
-  const filename = args.filename ?? path76.basename(args.filePath);
-  const stat = fs68.statSync(args.filePath);
+  const fs69 = await import("node:fs");
+  const path77 = await import("node:path");
+  const filename = args.filename ?? path77.basename(args.filePath);
+  const stat = fs69.statSync(args.filePath);
   if (!stat.isFile())
     throw new Error(`[slack:uploadFile] not a regular file: ${args.filePath}`);
   const length = stat.size;
@@ -29787,7 +29897,7 @@ async function uploadFile(args) {
   if (step1Parsed.ok === false || !step1Parsed.upload_url || !step1Parsed.file_id) {
     throw new Error(`[slack:files.getUploadURLExternal] ${step1Parsed.error ?? "unknown"}`);
   }
-  const buf = fs68.readFileSync(args.filePath);
+  const buf = fs69.readFileSync(args.filePath);
   const step2 = await fetch(step1Parsed.upload_url, {
     method: "POST",
     body: buf
@@ -30705,10 +30815,10 @@ async function replyMessage(args) {
   return { message_id: parsed.data?.message_id ?? "" };
 }
 async function uploadImage(args) {
-  const fs68 = await import("node:fs");
-  const path76 = await import("node:path");
-  const buf = fs68.readFileSync(args.filePath);
-  const filename = path76.basename(args.filePath);
+  const fs69 = await import("node:fs");
+  const path77 = await import("node:path");
+  const buf = fs69.readFileSync(args.filePath);
+  const filename = path77.basename(args.filePath);
   const send = async (token) => {
     const form = new FormData();
     form.append("image_type", "message");
@@ -30724,10 +30834,10 @@ async function uploadImage(args) {
   return { imageKey: parsed.data.image_key };
 }
 async function uploadFile2(args) {
-  const fs68 = await import("node:fs");
-  const path76 = await import("node:path");
-  const buf = fs68.readFileSync(args.filePath);
-  const filename = args.filename ?? path76.basename(args.filePath);
+  const fs69 = await import("node:fs");
+  const path77 = await import("node:path");
+  const buf = fs69.readFileSync(args.filePath);
+  const filename = args.filename ?? path77.basename(args.filePath);
   const send = async (token) => {
     const form = new FormData();
     form.append("file_type", args.fileType);
@@ -31554,7 +31664,7 @@ var init_event_adapter5 = __esm({
 
 // ../server/dist/channels/wecom/handler.js
 import path73 from "node:path";
-import fs65 from "node:fs/promises";
+import fs66 from "node:fs/promises";
 import { WSClient as WSClient2, generateReqId } from "@wecom/aibot-node-sdk";
 function pickConversation(body) {
   const userid = body.from?.userid ?? "unknown";
@@ -31687,7 +31797,7 @@ async function sendWecomMedia(args) {
   const ext = path73.extname(filePath).toLowerCase();
   const cls = classifyMedia(filePath);
   const type = cls === "image" && [".png", ".jpg", ".jpeg", ".gif"].includes(ext) ? "image" : cls === "video" && ext === ".mp4" ? "video" : "file";
-  const buf = await fs65.readFile(filePath);
+  const buf = await fs66.readFile(filePath);
   if (buf.length > MAX_WECOM_DOWNLOAD_BYTES)
     throw new Error("file exceeds 20MB");
   const { media_id: mediaId } = await wsClient.uploadMedia(buf, { type, filename: path73.basename(filePath) });
@@ -32145,14 +32255,14 @@ import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 import path74 from "node:path";
-import fs66 from "node:fs";
+import fs67 from "node:fs";
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { homedir as homedir24 } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function findProjectRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 32; i++) {
-    if (fs66.existsSync(path74.join(dir, "pnpm-workspace.yaml")))
+    if (fs67.existsSync(path74.join(dir, "pnpm-workspace.yaml")))
       return dir;
     const parent = path74.dirname(dir);
     if (parent === dir)
@@ -32163,15 +32273,15 @@ function findProjectRoot() {
   return process.cwd();
 }
 function acquireSingleInstanceLock(lockFile) {
-  fs66.mkdirSync(path74.dirname(lockFile), { recursive: true });
-  const fd = fs66.openSync(lockFile, fs66.constants.O_RDWR | fs66.constants.O_CREAT, 420);
+  fs67.mkdirSync(path74.dirname(lockFile), { recursive: true });
+  const fd = fs67.openSync(lockFile, fs67.constants.O_RDWR | fs67.constants.O_CREAT, 420);
   const result = spawnSync3("flock", ["-n", "3"], {
     stdio: ["ignore", "ignore", "ignore", fd]
   });
   if (result.error) {
     const content = readLockPid(fd);
     if (content > 0 && isProcessAlive(content)) {
-      fs66.closeSync(fd);
+      fs67.closeSync(fd);
       console.error(`[Server] another halo server is already running (pid ${content}). kill it first.`);
       process.exit(1);
     }
@@ -32180,19 +32290,19 @@ function acquireSingleInstanceLock(lockFile) {
     if (content > 0 && !isProcessAlive(content)) {
       console.warn(`[Server] removing stale server.lock (pid ${content} not running)`);
     } else {
-      fs66.closeSync(fd);
+      fs67.closeSync(fd);
       console.error(`[Server] another halo server is already running${content > 0 ? ` (pid ${content})` : ""}. kill it first.`);
       process.exit(1);
     }
   }
-  fs66.ftruncateSync(fd);
-  fs66.writeSync(fd, String(process.pid));
-  fs66.fsyncSync(fd);
+  fs67.ftruncateSync(fd);
+  fs67.writeSync(fd, String(process.pid));
+  fs67.fsyncSync(fd);
 }
 function readLockPid(fd) {
   try {
     const buf = Buffer.alloc(32);
-    const n = fs66.readSync(fd, buf, 0, 32, 0);
+    const n = fs67.readSync(fd, buf, 0, 32, 0);
     return parseInt(buf.subarray(0, n).toString("utf-8").trim(), 10) || 0;
   } catch {
     return 0;
@@ -32220,7 +32330,7 @@ function isProcessAlive(pid) {
   }
 }
 function readGitSha() {
-  if (!fs66.existsSync(path74.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs66.existsSync(path74.join(PROJECT_ROOT, ".git")))
+  if (!fs67.existsSync(path74.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs67.existsSync(path74.join(PROJECT_ROOT, ".git")))
     return null;
   try {
     const rev = spawnSync3("git", ["rev-parse", "--short", "HEAD"], { cwd: PROJECT_ROOT, encoding: "utf-8" });
@@ -32243,10 +32353,10 @@ function resolveFrontendDir() {
   if (process.env.HALO_FRONTEND_DIR)
     return path74.resolve(process.env.HALO_FRONTEND_DIR);
   const bundled = path74.resolve(__dirname3, "..", "admin-out");
-  if (fs66.existsSync(path74.join(bundled, "index.html")))
+  if (fs67.existsSync(path74.join(bundled, "index.html")))
     return bundled;
   const sibling = path74.resolve(__dirname3, "..", "..", "admin", "out");
-  if (fs66.existsSync(path74.join(sibling, "index.html")))
+  if (fs67.existsSync(path74.join(sibling, "index.html")))
     return sibling;
   return path74.resolve(PROJECT_ROOT, "packages", "admin", "out");
 }
@@ -32327,11 +32437,11 @@ var init_dist2 = __esm({
     init_git_ssh();
     __dirname3 = path74.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "1.5.10";
+    HALO_VERSION = "1.5.11";
     PROJECT_ROOT = findProjectRoot();
     HALO_HOME4 = path74.join(homedir24(), ".halo");
     GIT_SHA = readGitSha();
-    if (!fs66.existsSync(path74.join(HALO_HOME4, "global", ".template-version"))) {
+    if (!fs67.existsSync(path74.join(HALO_HOME4, "global", ".template-version"))) {
       process.stderr.write("\x1B[31m[Server] ~/.halo/global/ not initialized. Run `halo setup` first.\x1B[0m\n");
       process.exit(1);
     }
@@ -32424,7 +32534,7 @@ var init_dist2 = __esm({
     setCronSessionRegistry(registry);
     if (OWNS_RUNTIMES) {
       for (const ws of listRunningWorkspaces()) {
-        if (!fs66.existsSync(path74.join(ws, ".halo")))
+        if (!fs67.existsSync(path74.join(ws, ".halo")))
           continue;
         if (!claimWorkspaceRuntime(ws))
           continue;
@@ -32458,7 +32568,7 @@ var init_dist2 = __esm({
     app.get("/*", (c) => {
       const indexPath = path74.join(FRONTEND_DIR, "index.html");
       try {
-        const html = fs66.readFileSync(indexPath, "utf-8");
+        const html = fs67.readFileSync(indexPath, "utf-8");
         return c.html(html);
       } catch {
         return c.text("Frontend not built. Run: cd packages/admin && npx next build", 503);
@@ -32619,21 +32729,57 @@ var init_halo_client = __esm({
           throw new Error("halo session create: missing sessionId");
         return data.sessionId;
       }
-      /** GET /api/web/history with an explicit sessionId, returns true iff
-       *  the server has a row for it (used by ACP `session/load`). */
-      async sessionExists(workspace, sessionId) {
-        const url = new URL(`${this.opts.baseUrl}/api/web/history`);
-        url.searchParams.set("workspace", workspace);
-        url.searchParams.set("sessionId", sessionId);
-        const res = await fetch(url, { headers: this.authHeaders({ "x-token": this.opts.token }) });
+      /** GET /api/web/subscribe as SSE — same frames as `chat`. Ends after a
+       *  single `complete` when the session isn't running. */
+      async *subscribe(workspace, sessionId, signal) {
+        const res = await fetch(this.sessionUrl("/api/web/subscribe", workspace, sessionId), {
+          headers: this.authHeaders({ "x-token": this.opts.token }),
+          signal
+        });
+        if (!res.ok || !res.body) {
+          const msg = await safeText(res);
+          throw new Error(`halo subscribe ${res.status}: ${msg}`);
+        }
+        yield* parseSseStream(res.body);
+      }
+      /** GET /api/web/history for an explicit sessionId; null when the server
+       *  has no such session (404). `since` (epoch ms) = only root-log rows
+       *  stamped at or after it — omitted for the full log. */
+      async history(workspace, sessionId, signal, since) {
+        const url = this.sessionUrl("/api/web/history", workspace, sessionId);
+        if (since !== void 0)
+          url.searchParams.set("since", String(since));
+        const res = await fetch(url, {
+          headers: this.authHeaders({ "x-token": this.opts.token }),
+          signal
+        });
         if (res.status === 404)
-          return false;
+          return null;
         if (!res.ok) {
           const msg = await safeText(res);
           throw new Error(`halo history ${res.status}: ${msg}`);
         }
-        const data = await res.json();
-        return typeof data.sessionId === "string" && data.sessionId === sessionId;
+        return await res.json();
+      }
+      /** GET /api/web/sessions — one page of the token's own root sessions,
+       *  newest first. `workspace` is the server-resolved absolute path. */
+      async listSessions(workspace, cursor) {
+        const url = new URL(`${this.opts.baseUrl}/api/web/sessions`);
+        url.searchParams.set("workspace", workspace);
+        if (cursor !== void 0)
+          url.searchParams.set("cursor", String(cursor));
+        const res = await fetch(url, { headers: this.authHeaders({ "x-token": this.opts.token }) });
+        if (!res.ok) {
+          const msg = await safeText(res);
+          throw new Error(`halo session list ${res.status}: ${msg}`);
+        }
+        return await res.json();
+      }
+      sessionUrl(path77, workspace, sessionId) {
+        const url = new URL(`${this.opts.baseUrl}${path77}`);
+        url.searchParams.set("workspace", workspace);
+        url.searchParams.set("sessionId", sessionId);
+        return url;
       }
       /** POST /api/web/stop. */
       async stop(workspace, sessionId) {
@@ -32657,26 +32803,218 @@ var init_halo_client = __esm({
   }
 });
 
+// ../acp-adapter/dist/acp-updates.js
+function toolKind(toolName) {
+  return TOOL_KINDS[toolName] ?? "other";
+}
+function toolTitle(toolName, input) {
+  const arg = titleArg(input)?.replace(/\s+/g, " ").trim();
+  return arg ? `${toolName}: ${arg.slice(0, TITLE_ARG_MAX)}` : toolName;
+}
+function titleArg(input) {
+  if (typeof input === "string") {
+    if (!input.startsWith("{"))
+      return input;
+    try {
+      return titleArg(JSON.parse(input));
+    } catch {
+      return input;
+    }
+  }
+  const value = input;
+  if (!value || typeof value !== "object")
+    return void 0;
+  for (const key of TITLE_ARGS) {
+    const v = value[key];
+    if (typeof v === "string" && v)
+      return v;
+  }
+  return void 0;
+}
+function textChunk(kind, text6) {
+  return { sessionUpdate: kind, content: { type: "text", text: text6 } };
+}
+function toolResultContent(text6) {
+  return [{ type: "content", content: { type: "text", text: text6 } }];
+}
+function replayToolCall(tc, fallbackId) {
+  const output = tc.output?.slice(0, REPLAY_OUTPUT_MAX);
+  return {
+    sessionUpdate: "tool_call",
+    toolCallId: tc.toolUseId || `replay-${fallbackId}`,
+    title: toolTitle(tc.name, tc.input),
+    kind: toolKind(tc.name),
+    status: "completed",
+    rawInput: tc.input,
+    ...output !== void 0 ? { rawOutput: output, content: toolResultContent(output) } : {}
+  };
+}
+function replayUpdates(messages2) {
+  const out = [];
+  messages2.forEach((m, i) => {
+    if (m.deleted || m.taskId)
+      return;
+    if (m.role === "user") {
+      if (m.content)
+        out.push(textChunk("user_message_chunk", m.content));
+      return;
+    }
+    if (m.role !== "assistant")
+      return;
+    const msgKey = m.id ?? String(i);
+    if (m.contentBlocks && m.contentBlocks.length > 0) {
+      m.contentBlocks.forEach((b, j) => {
+        if (b.type === "tool_call")
+          out.push(replayToolCall(b.toolCall, `${msgKey}-${j}`));
+        else if (b.text)
+          out.push(textChunk(b.type === "thinking" ? "agent_thought_chunk" : "agent_message_chunk", b.text));
+      });
+      return;
+    }
+    m.toolCalls?.forEach((tc, j) => out.push(replayToolCall(tc, `${msgKey}-${j}`)));
+    if (m.content)
+      out.push(textChunk("agent_message_chunk", m.content));
+  });
+  return out;
+}
+function stripMediaLines(text6) {
+  return text6.split(/(?<=\n)/).map((line) => line.replace(MEDIA_MARKER_RE2, "")).join("");
+}
+function replyAfterPrompt(messages2, prompt) {
+  let start3 = -1;
+  for (let i = messages2.length - 1; i >= 0; i--) {
+    const m = messages2[i];
+    if (m.role === "user" && (m.content === prompt || m.content.startsWith(prompt + "\n\n"))) {
+      start3 = i;
+      break;
+    }
+  }
+  if (start3 === -1)
+    return "";
+  return stripMediaLines(messages2.slice(start3 + 1).filter((m) => m.role === "assistant" && !m.deleted && !m.taskId).map((m) => m.content).join(""));
+}
+var TOOL_KINDS, TITLE_ARGS, TITLE_ARG_MAX, REPLAY_OUTPUT_MAX, MEDIA_MARKER_RE2;
+var init_acp_updates = __esm({
+  "../acp-adapter/dist/acp-updates.js"() {
+    "use strict";
+    TOOL_KINDS = {
+      file_read: "read",
+      file_write: "edit",
+      file_edit: "edit",
+      shell_exec: "execute",
+      grep: "search",
+      glob: "search",
+      file_list: "search",
+      web_fetch: "fetch"
+    };
+    TITLE_ARGS = ["command", "pattern", "url", "path"];
+    TITLE_ARG_MAX = 80;
+    REPLAY_OUTPUT_MAX = 500;
+    MEDIA_MARKER_RE2 = /^MEDIA:\s*(\S.*?)\s*$/gm;
+  }
+});
+
+// ../acp-adapter/dist/version.js
+var ADAPTER_VERSION;
+var init_version = __esm({
+  "../acp-adapter/dist/version.js"() {
+    "use strict";
+    ADAPTER_VERSION = "0.1.0";
+  }
+});
+
 // ../acp-adapter/dist/adapter.js
+import path75 from "node:path";
+function composePrompt(blocks) {
+  const segments = [];
+  let run = "";
+  const paragraph = (s) => {
+    if (run)
+      segments.push(run);
+    run = "";
+    segments.push(s);
+  };
+  const images = [];
+  for (const b of blocks) {
+    if (b.type === "text") {
+      run += b.text ?? "";
+    } else if (b.type === "image" && b.data && b.mimeType) {
+      images.push({ data: b.data, mimeType: b.mimeType });
+    } else if (b.type === "resource" && b.resource) {
+      const { uri = "", text: text6 } = b.resource;
+      if (typeof text6 === "string") {
+        const fence = "`".repeat(Math.max(3, longestBacktickRun(text6) + 1));
+        paragraph(`[resource: ${uri}]
+${fence}
+${text6}
+${fence}`);
+      } else {
+        paragraph(`[binary resource omitted: ${uri}]`);
+      }
+    } else if (b.type === "resource_link") {
+      paragraph(`[resource link: ${[b.name, b.uri].filter(Boolean).join(" ")}]`);
+    } else {
+      process.stderr.write(`[acp-adapter] dropping ${b.type} content block (not supported)
+`);
+    }
+  }
+  if (run)
+    segments.push(run);
+  return { text: segments.join("\n\n"), images };
+}
+function longestBacktickRun(s) {
+  let max = 0;
+  for (const m of s.matchAll(/`+/g))
+    max = Math.max(max, m[0].length);
+  return max;
+}
+function nonEmpty(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve2) => {
+    if (signal.aborted)
+      return resolve2();
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done);
+  });
+}
 function newError(message, code = -32603) {
   const e = new Error(message);
   e.code = code;
   return e;
 }
-var AcpAdapter;
+var RETRY_DELAYS_MS, CANCEL_GRACE_MS, SETTLE_SKEW_MS, AcpAdapter;
 var init_adapter = __esm({
   "../acp-adapter/dist/adapter.js"() {
     "use strict";
     init_halo_client();
+    init_acp_updates();
+    init_version();
+    RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3];
+    CANCEL_GRACE_MS = 5e3;
+    SETTLE_SKEW_MS = 5 * 6e4;
     AcpAdapter = class {
       conn;
       config;
       client;
+      retryDelaysMs;
+      cancelGraceMs;
       sessions = /* @__PURE__ */ new Map();
-      constructor(conn, config3) {
+      constructor(conn, config3, deps = {}) {
         this.conn = conn;
         this.config = config3;
-        this.client = new HaloClient({ baseUrl: config3.baseUrl, token: config3.token, headers: config3.headers });
+        this.client = deps.client ?? new HaloClient({ baseUrl: config3.baseUrl, token: config3.token, headers: config3.headers });
+        this.retryDelaysMs = deps.retryDelaysMs ?? RETRY_DELAYS_MS;
+        this.cancelGraceMs = deps.cancelGraceMs ?? CANCEL_GRACE_MS;
         this.registerHandlers();
       }
       registerHandlers() {
@@ -32684,7 +33022,11 @@ var init_adapter = __esm({
         this.conn.onRequest("authenticate", () => this.handleAuthenticate());
         this.conn.onRequest("session/new", (params) => this.handleSessionNew(params));
         this.conn.onRequest("session/load", (params) => this.handleSessionLoad(params));
+        this.conn.onRequest("session/list", (params) => this.handleSessionList(params));
         this.conn.onRequest("session/prompt", (params) => this.handleSessionPrompt(params));
+        this.conn.onNotification("session/cancel", (params) => {
+          this.handleSessionCancel(params);
+        });
         this.conn.onRequest("session/cancel", (params) => this.handleSessionCancel(params));
       }
       /**
@@ -32698,13 +33040,15 @@ var init_adapter = __esm({
           protocolVersion: 1,
           agentCapabilities: {
             loadSession: true,
+            sessionCapabilities: { list: {} },
             promptCapabilities: {
               image: true,
               audio: false,
               embeddedContext: true
             }
           },
-          authMethods: []
+          authMethods: [],
+          agentInfo: { name: "halo", title: "Halo", version: ADAPTER_VERSION }
         };
       }
       /** Authentication is satisfied by the adapter's launch flags; ACP
@@ -32730,37 +33074,66 @@ var init_adapter = __esm({
       /**
        * Resume a session whose id the ACP client persisted from an earlier
        * `session/new`. Adapter doesn't store anything on disk — the client
-       * is the source of truth for "which sessions are mine". We only:
+       * is the source of truth for "which sessions are mine". We:
        *
-       *   1. Verify the session still exists on the halo server (via
-       *      /api/web/history with the explicit sessionId — server returns
-       *      404 when the row is gone).
-       *   2. Register it in our in-memory map so the same prompt / cancel
+       *   1. Fetch its history (`/api/web/history` with the explicit id —
+       *      404 when the row is gone → invalid-params error).
+       *   2. Replay the whole conversation as `session/update`s, all of them
+       *      before the response (ACP session-setup "Loading Sessions").
+       *   3. Register it in our in-memory map so the same prompt / cancel
        *      paths work for it.
        *
-       * Returns null on success per ACP spec; throws an invalid-params
-       * error if the session can't be found.
+       * `cwd` / `mcpServers` are accepted and ignored: the agent runs in the
+       * server-side workspace and can't reach the client's local MCP servers.
+       * A turn still running server-side is replayed as far as it got; the
+       * live tail isn't attached.
        */
       async handleSessionLoad(params) {
         const p = params;
         if (!p.sessionId)
           throw newError("invalid params: sessionId required", -32602);
-        const exists = await this.client.sessionExists(this.config.workspace, p.sessionId);
-        if (!exists)
+        const history = await this.client.history(this.config.workspace, p.sessionId);
+        if (!history)
           throw newError(`unknown session: ${p.sessionId}`, -32602);
         if (!this.sessions.has(p.sessionId)) {
           this.sessions.set(p.sessionId, { workspace: this.config.workspace });
         }
-        return null;
+        for (const update of replayUpdates(history.messages)) {
+          this.conn.notify("session/update", { sessionId: p.sessionId, update });
+        }
+        return {};
+      }
+      /**
+       * One page of the token's own root sessions (`GET /api/web/sessions`),
+       * newest first. Every session's `cwd` is the server-resolved workspace —
+       * where the agent actually runs — so a `cwd` filter matches only that
+       * path; anything else is an empty page, not an error (spec). The cursor
+       * is the server's `nextCursor` (an updatedAt epoch-ms) as an opaque
+       * string; anything that doesn't parse back is invalid params.
+       */
+      async handleSessionList(params) {
+        const p = params ?? {};
+        const cursor = p.cursor || void 0;
+        if (cursor !== void 0 && !/^\d+$/.test(cursor))
+          throw newError(`invalid cursor: ${cursor}`, -32602);
+        const page = await this.client.listSessions(this.config.workspace, cursor === void 0 ? void 0 : Number(cursor));
+        if (p.cwd !== void 0 && path75.resolve(p.cwd) !== path75.resolve(page.workspace))
+          return { sessions: [] };
+        return {
+          sessions: page.sessions.map((s) => ({
+            sessionId: s.sessionId,
+            cwd: page.workspace,
+            ...s.title ? { title: s.title } : {},
+            updatedAt: new Date(s.updatedAt).toISOString()
+          })),
+          ...page.nextCursor !== null ? { nextCursor: String(page.nextCursor) } : {}
+        };
       }
       /**
        * Forward the user's prompt to halo and stream back updates.
        *
-       * ACP `session/prompt.params.prompt` is an array of content blocks
-       * (text, image, resource). For v1 we extract `text` blocks only and
-       * concatenate; image blocks become halo `images[]` entries.
-       * Resource / embedded-context blocks are ignored with a warning to
-       * stderr (we don't have a way to ship them to halo yet).
+       * ACP `session/prompt.params.prompt` is an array of content blocks;
+       * `composePrompt` turns it into halo's `message` + `images[]`.
        */
       async handleSessionPrompt(params) {
         const p = params;
@@ -32769,57 +33142,167 @@ var init_adapter = __esm({
         const state = this.sessions.get(p.sessionId);
         if (!state)
           throw newError(`unknown session: ${p.sessionId}`, -32602);
-        if (state.promptAbort) {
+        if (state.turn) {
           throw newError("prompt already in progress for this session", -32600);
         }
-        const blocks = p.prompt ?? [];
-        const text6 = blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
-        const images = [];
-        for (const b of blocks) {
-          if (b.type === "image" && b.data && b.mimeType) {
-            images.push({ data: b.data, mimeType: b.mimeType });
-          } else if (b.type === "resource" || b.type === "resource_link") {
-            process.stderr.write(`[acp-adapter] dropping ${b.type} content block (not yet supported)
-`);
-          }
-        }
+        const { text: text6, images } = composePrompt(p.prompt ?? []);
         if (!text6 && images.length === 0) {
           throw newError("invalid params: empty prompt", -32602);
         }
-        const abort = new AbortController();
-        state.promptAbort = abort;
-        state.lastToolCall = void 0;
-        const sessionId = p.sessionId;
-        let stopReason = "end_turn";
+        const turn = {
+          cancel: new AbortController(),
+          http: new AbortController(),
+          haloSessionId: p.sessionId,
+          prompt: text6,
+          startedAt: Date.now(),
+          fallbackIds: 0,
+          streamed: "",
+          contentEvents: 0,
+          announcedTools: /* @__PURE__ */ new Set()
+        };
+        state.turn = turn;
         try {
-          for await (const ev of this.client.chat({
+          const stopReason = await this.runTurn(p.sessionId, state, turn, {
             message: text6,
             images: images.length > 0 ? images : void 0,
             workspace: state.workspace,
-            sessionId,
+            sessionId: p.sessionId,
             agentId: this.config.agentId
-          }, abort.signal)) {
-            const action = this.routeEvent(sessionId, state, ev);
-            if (action === "cancelled") {
-              stopReason = "cancelled";
-              break;
-            }
-            if (action === "end")
-              break;
-          }
+          });
+          return { stopReason };
+        } finally {
+          turn.http.abort();
+          state.turn = void 0;
+        }
+      }
+      /**
+       * One prompt turn: the /chat stream, then — when the session was busy
+       * (`queued`, the message drains in the running turn) or the stream died
+       * before `complete` — /subscribe until the terminal `complete`. A cancel
+       * at any point resolves `cancelled`, once the stream is drained or the
+       * grace period ran out.
+       */
+      async runTurn(acpSessionId, state, turn, chat) {
+        let result;
+        try {
+          result = await this.pump(acpSessionId, turn, this.client.chat(chat, turn.http.signal));
         } catch (err) {
-          const aborted = abort.signal.aborted || err instanceof Error && err.name === "AbortError";
-          if (aborted) {
-            stopReason = "cancelled";
-          } else {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.sendChunk(sessionId, "agent_message_chunk", `[adapter error] ${msg}`);
+          if (turn.cancel.signal.aborted)
+            return "cancelled";
+          this.sendChunk(acpSessionId, "agent_message_chunk", `[adapter error] ${errMessage(err)}`);
+          return "end_turn";
+        }
+        if (turn.cancel.signal.aborted)
+          return "cancelled";
+        if (result === "end")
+          return "end_turn";
+        if (result === "queued") {
+          result = await this.pumpSafe(acpSessionId, turn, this.client.subscribe(state.workspace, turn.haloSessionId, turn.http.signal));
+          if (turn.cancel.signal.aborted)
+            return "cancelled";
+          if (result !== "dropped")
+            return this.settle(acpSessionId, state, turn);
+        }
+        return this.reconnect(acpSessionId, state, turn);
+      }
+      /**
+       * The stream ended without `complete` and without a cancel (proxy idle
+       * timeout, network blip, server restart). Re-attach via /subscribe with
+       * backoff; a re-attach that delivers frames resets the budget, so a long
+       * task can survive repeated drops. Once a re-attached stream completes
+       * (or subscribe reports the run already over) the reply is settled
+       * against history — text produced while detached is lost from the live
+       * stream.
+       */
+      async reconnect(acpSessionId, state, turn) {
+        let failures = 0;
+        while (failures < this.retryDelaysMs.length) {
+          await sleep3(this.retryDelaysMs[failures], turn.cancel.signal);
+          if (turn.cancel.signal.aborted)
+            return "cancelled";
+          const before = turn.contentEvents;
+          const result = await this.pumpSafe(acpSessionId, turn, this.client.subscribe(state.workspace, turn.haloSessionId, turn.http.signal));
+          if (turn.cancel.signal.aborted)
+            return "cancelled";
+          if (result !== "dropped")
+            return this.settle(acpSessionId, state, turn);
+          failures = turn.contentEvents > before ? 0 : failures + 1;
+        }
+        this.sendChunk(acpSessionId, "agent_message_chunk", "[adapter error] connection lost");
+        return "end_turn";
+      }
+      /** Route a stream's events until a terminal one. A stream that ends or
+       *  throws after opening is 'dropped'; one that throws before its first
+       *  event rethrows (the request itself failed). */
+      async pump(acpSessionId, turn, stream) {
+        let opened = false;
+        try {
+          for await (const ev of stream) {
+            opened = true;
+            const action = this.routeEvent(acpSessionId, turn, ev);
+            if (action)
+              return action;
           }
-        } finally {
-          state.promptAbort = void 0;
+        } catch (err) {
+          if (!opened)
+            throw err;
+          if (!turn.http.signal.aborted)
+            process.stderr.write(`[acp-adapter] stream dropped: ${errMessage(err)}
+`);
+        }
+        return "dropped";
+      }
+      /** `pump` for re-attach attempts, where a failed request is just one
+       *  more dropped attempt. */
+      async pumpSafe(acpSessionId, turn, stream) {
+        try {
+          return await this.pump(acpSessionId, turn, stream);
+        } catch (err) {
+          if (!turn.http.signal.aborted)
+            process.stderr.write(`[acp-adapter] subscribe failed: ${errMessage(err)}
+`);
+          return "dropped";
+        }
+      }
+      /**
+       * After a re-attach: compare what was streamed with the reply the
+       * server logged for this prompt. Streamed text that is a prefix gets
+       * only the missing tail; anything else (a gap mid-reply) gets the whole
+       * reply again behind a marker, so the client never silently shows a
+       * reply with a hole in it.
+       */
+      async settle(acpSessionId, state, turn) {
+        await this.settleFromHistory(acpSessionId, state, turn);
+        return turn.cancel.signal.aborted ? "cancelled" : "end_turn";
+      }
+      async settleFromHistory(acpSessionId, state, turn) {
+        let reply;
+        try {
+          const since = Math.max(0, turn.startedAt - SETTLE_SKEW_MS);
+          const history = await this.client.history(state.workspace, turn.haloSessionId, turn.http.signal, since);
+          if (!history)
+            return;
+          reply = replyAfterPrompt(history.messages, turn.prompt);
+        } catch (err) {
+          if (!turn.http.signal.aborted)
+            process.stderr.write(`[acp-adapter] history after reconnect failed: ${errMessage(err)}
+`);
+          return;
         }
-        return { stopReason };
+        if (!reply || turn.streamed.endsWith(reply))
+          return;
+        const missing = reply.startsWith(turn.streamed) ? reply.slice(turn.streamed.length) : `[reconnected \u2014 full reply]
+${reply}`;
+        this.sendChunk(acpSessionId, "agent_message_chunk", missing);
+        turn.streamed = reply;
       }
+      /**
+       * ACP cancel: stop the halo session, then let the prompt keep reading
+       * so the stop's own updates (interrupted tool rows, the final text)
+       * reach the client BEFORE the `cancelled` response (prompt-turn
+       * "Cancellation"). If no `complete` arrives within the grace period the
+       * stream is aborted and the prompt resolves `cancelled` anyway.
+       */
       handleSessionCancel(params) {
         const p = params;
         if (!p.sessionId)
@@ -32827,10 +33310,13 @@ var init_adapter = __esm({
         const state = this.sessions.get(p.sessionId);
         if (!state)
           return null;
-        if (state.promptAbort)
-          state.promptAbort.abort();
-        void this.client.stop(state.workspace, p.sessionId).catch((err) => {
-          process.stderr.write(`[acp-adapter] cancel stop failed: ${err instanceof Error ? err.message : String(err)}
+        const turn = state.turn;
+        if (turn && !turn.cancel.signal.aborted) {
+          turn.cancel.abort();
+          setTimeout(() => turn.http.abort(), this.cancelGraceMs).unref();
+        }
+        void this.client.stop(state.workspace, turn?.haloSessionId ?? p.sessionId).catch((err) => {
+          process.stderr.write(`[acp-adapter] cancel stop failed: ${errMessage(err)}
 `);
         });
         return null;
@@ -32838,17 +33324,23 @@ var init_adapter = __esm({
       /**
        * Translate one halo SSE event into an ACP session/update
        * notification. Returns 'end' when the event terminates the prompt
-       * (complete / error), 'cancelled' if the stream was cancelled, or null
-       * to continue.
+       * (complete / error), 'queued' when the session was busy, or null to
+       * continue.
        */
-      routeEvent(acpSessionId, state, ev) {
+      routeEvent(acpSessionId, turn, ev) {
+        if (ev.type !== "session")
+          turn.contentEvents++;
         switch (ev.type) {
           case "session":
+            if (typeof ev.sessionId === "string" && ev.sessionId)
+              turn.haloSessionId = ev.sessionId;
             return null;
           case "stream": {
             const text6 = typeof ev.text === "string" ? ev.text : "";
-            if (text6)
+            if (text6) {
+              turn.streamed += text6;
               this.sendChunk(acpSessionId, "agent_message_chunk", text6);
+            }
             return null;
           }
           case "thinking": {
@@ -32859,60 +33351,34 @@ var init_adapter = __esm({
           }
           case "tool_call": {
             const toolName = typeof ev.toolName === "string" ? ev.toolName : "tool";
-            const callId = `${acpSessionId}-${toolName}-${Date.now().toString(36)}`;
-            state.lastToolCall = { callId, toolName };
-            this.conn.notify("session/update", {
-              sessionId: acpSessionId,
-              update: {
-                sessionUpdate: "tool_call",
-                toolCallId: callId,
-                title: toolName,
-                kind: "other",
-                status: "in_progress",
-                rawInput: ev.toolInput
-              }
-            });
+            const callId = nonEmpty(ev.toolUseId) ?? `${acpSessionId}-${toolName}-${turn.startedAt.toString(36)}-${++turn.fallbackIds}`;
+            turn.lastToolCall = { callId, toolName };
+            this.announceTool(acpSessionId, turn, callId, toolName, ev.toolInput);
             return null;
           }
           case "tool_result": {
             const evToolName = typeof ev.toolName === "string" ? ev.toolName : void 0;
             const result = typeof ev.result === "string" ? ev.result : "";
-            const last = state.lastToolCall;
-            if (last && (!evToolName || evToolName === last.toolName)) {
-              this.conn.notify("session/update", {
-                sessionId: acpSessionId,
-                update: {
-                  sessionUpdate: "tool_call_update",
-                  toolCallId: last.callId,
-                  status: "completed",
-                  content: [{ type: "content", content: { type: "text", text: result } }]
-                }
-              });
-              state.lastToolCall = void 0;
-              return null;
+            const last = turn.lastToolCall;
+            let callId = nonEmpty(ev.toolUseId);
+            if (!callId && last && (!evToolName || evToolName === last.toolName))
+              callId = last.callId;
+            if (!callId) {
+              callId = `${acpSessionId}-${evToolName ?? "tool"}-orphan-${turn.startedAt.toString(36)}-${++turn.fallbackIds}`;
             }
-            const toolName = evToolName ?? "tool";
-            const callId = `${acpSessionId}-${toolName}-orphan-${Date.now().toString(36)}`;
-            this.conn.notify("session/update", {
-              sessionId: acpSessionId,
-              update: {
-                sessionUpdate: "tool_call",
-                toolCallId: callId,
-                title: toolName,
-                kind: "other",
-                status: "in_progress"
-              }
-            });
+            if (!turn.announcedTools.has(callId))
+              this.announceTool(acpSessionId, turn, callId, evToolName ?? "tool", void 0);
             this.conn.notify("session/update", {
               sessionId: acpSessionId,
               update: {
                 sessionUpdate: "tool_call_update",
                 toolCallId: callId,
                 status: "completed",
-                content: [{ type: "content", content: { type: "text", text: result } }]
+                content: toolResultContent(result)
               }
             });
-            state.lastToolCall = void 0;
+            if (last?.callId === callId)
+              turn.lastToolCall = void 0;
             return null;
           }
           case "error": {
@@ -32920,10 +33386,8 @@ var init_adapter = __esm({
             this.sendChunk(acpSessionId, "agent_message_chunk", `[error] ${errText2}`);
             return "end";
           }
-          case "queued": {
-            this.sendChunk(acpSessionId, "agent_message_chunk", "[queued \u2014 session busy]");
-            return "end";
-          }
+          case "queued":
+            return "queued";
           case "file": {
             const filePath = typeof ev.path === "string" ? ev.path : "";
             if (filePath)
@@ -32939,15 +33403,28 @@ var init_adapter = __esm({
             return null;
         }
       }
-      sendChunk(acpSessionId, kind, text6) {
+      /** `tool_call` notification. No `locations`: paths are server-side,
+       *  the client couldn't open them. */
+      announceTool(acpSessionId, turn, callId, toolName, toolInput) {
+        turn.announcedTools.add(callId);
         this.conn.notify("session/update", {
           sessionId: acpSessionId,
           update: {
-            sessionUpdate: kind,
-            content: { type: "text", text: text6 }
+            sessionUpdate: "tool_call",
+            toolCallId: callId,
+            title: toolTitle(toolName, toolInput),
+            kind: toolKind(toolName),
+            status: "in_progress",
+            ...toolInput !== void 0 ? { rawInput: toolInput } : {}
           }
         });
       }
+      sendChunk(acpSessionId, kind, text6) {
+        this.conn.notify("session/update", {
+          sessionId: acpSessionId,
+          update: textChunk(kind, text6)
+        });
+      }
     };
   }
 });
@@ -33254,11 +33731,11 @@ process.emitWarning = (warning, ...args) => {
 
 // src/index.ts
 init_server_supervisor();
-import path75 from "node:path";
-import fs67 from "node:fs";
+import path76 from "node:path";
+import fs68 from "node:fs";
 import { homedir as homedir25 } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
-var VERSION = "1.5.10";
+var VERSION = "1.5.11";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:
@@ -33545,8 +34022,8 @@ async function cmdSetup(argv = []) {
   const { buildBindProviderPlan: buildBindProviderPlan2, KEEP_CURRENT: KEEP_CURRENT2, AWS_CHAIN_PROVIDER: AWS_CHAIN_PROVIDER2 } = await Promise.resolve().then(() => (init_setup_bind_provider(), setup_bind_provider_exports));
   const { promptText: promptText2, promptPassword: promptPassword2, promptSelect: promptSelect2, promptMultiSelect: promptMultiSelect2 } = await Promise.resolve().then(() => (init_setup_prompts(), setup_prompts_exports));
   const nonInteractive = argv.includes("--non-interactive") || argv.includes("-y");
-  const haloHome2 = path75.join(homedir25(), ".halo");
-  const globalDir2 = path75.join(haloHome2, "global");
+  const haloHome2 = path76.join(homedir25(), ".halo");
+  const globalDir2 = path76.join(haloHome2, "global");
   ensureHaloHome2(haloHome2);
   process.stderr.write(`[setup] ${haloHome2}/ ready
 `);
@@ -33889,7 +34366,7 @@ async function cmdUpgrade() {
 `);
       process.exit(1);
     }
-    const broken = verifyNativeModules2(path75.join(rootDir, PKG));
+    const broken = verifyNativeModules2(path76.join(rootDir, PKG));
     if (broken.length > 0) {
       process.stderr.write(
         `
@@ -33920,7 +34397,7 @@ halo: upgrade failed (npm exited ${install.status}). ${hint}
 async function cmdAgents(flags) {
   const { initRuntime: initRuntime2, listAgents: listAgents2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
   await initRuntime2();
-  const workspace = path75.resolve(flags.workspace ?? process.cwd());
+  const workspace = path76.resolve(flags.workspace ?? process.cwd());
   const agents = await listAgents2(workspace);
   if (agents.length === 0) {
     process.stderr.write("No agents found.\n");
@@ -33936,7 +34413,7 @@ async function cmdAgents(flags) {
 async function cmdSessions(flags) {
   const { initRuntime: initRuntime2, listSessions: listSessions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
   await initRuntime2();
-  const workspace = path75.resolve(flags.workspace ?? process.cwd());
+  const workspace = path76.resolve(flags.workspace ?? process.cwd());
   const sessions = listSessions2(workspace);
   if (sessions.length === 0) {
     process.stderr.write("No sessions found.\n");
@@ -33967,7 +34444,7 @@ async function cmdModels(argv) {
     process.exitCode = 1;
     return;
   }
-  const plan = mod.planModelsInstall(path75.resolve(dir));
+  const plan = mod.planModelsInstall(path76.resolve(dir));
   for (const line of mod.formatPlan(plan)) process.stdout.write(`${line}
 `);
   if (plan.needsConfirm && !values.yes) {
@@ -34079,11 +34556,11 @@ ${stdinContent}` : stdinContent;
     harness.destroy();
   }
 }
-var SERVER_LOCK_PATH = path75.join(homedir25(), ".halo", "global", "server.lock");
-var SERVER_LOG_PATH = path75.join(homedir25(), ".halo", "logs", "server.log");
+var SERVER_LOCK_PATH = path76.join(homedir25(), ".halo", "global", "server.lock");
+var SERVER_LOG_PATH = path76.join(homedir25(), ".halo", "logs", "server.log");
 function readServerPid() {
   try {
-    const txt = fs67.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
+    const txt = fs68.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
     const n = parseInt(txt, 10);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -34170,8 +34647,8 @@ async function cmdServerStart(argv, _unused) {
     return;
   }
   const { spawn: spawn5 } = await import("node:child_process");
-  fs67.mkdirSync(path75.dirname(SERVER_LOG_PATH), { recursive: true });
-  const out = fs67.openSync(SERVER_LOG_PATH, "a");
+  fs68.mkdirSync(path76.dirname(SERVER_LOG_PATH), { recursive: true });
+  const out = fs68.openSync(SERVER_LOG_PATH, "a");
   const child = spawn5(process.argv[0], [process.argv[1], "server", "start"], {
     detached: true,
     stdio: ["ignore", out, out],
@@ -34272,7 +34749,7 @@ async function cmdServerLogs(argv) {
       lines: { type: "string", short: "n" }
     }
   });
-  if (!fs67.existsSync(SERVER_LOG_PATH)) {
+  if (!fs68.existsSync(SERVER_LOG_PATH)) {
     process.stderr.write(`No log file at ${SERVER_LOG_PATH}
 `);
     return;
@@ -34290,7 +34767,7 @@ function exitMissingSetup() {
   process.exit(1);
 }
 function isHaloHomeReady() {
-  return fs67.existsSync(path75.join(homedir25(), ".halo", "global", ".template-version"));
+  return fs68.existsSync(path76.join(homedir25(), ".halo", "global", ".template-version"));
 }
 async function main2() {
   const argv = process.argv.slice(2);