@joeyshi12/casper 0.14.4 → 0.15.0

package/dist/server.js

@@ -96,9 +96,7 @@ function agentPrompt() {
   const here = path4.dirname(url.fileURLToPath(import.meta.url));
   const candidates = [
     path4.resolve(here, "agents/prompt.txt"),
-    // bundled: beside server.js
     path4.resolve(here, "../../../assets/agents/prompt.txt")
-    // from source
   ];
   const found = candidates.find((c) => fs3.existsSync(c));
   return found ? fs3.readFileSync(found, "utf8").trimEnd() : null;
@@ -107,9 +105,7 @@ function mcpServerPath() {
   const here = path4.dirname(url.fileURLToPath(import.meta.url));
   const candidates = [
     path4.resolve(here, "mcp.js"),
-    // bundled: beside server.js
     path4.resolve(here, "../../dist/mcp.js")
-    // from source, if built
   ];
   return candidates.find((c) => fs3.existsSync(c)) ?? null;
 }
@@ -314,31 +310,19 @@ var init_config = __esm({
     config = {
       host: setting("HOST", "host", "0.0.0.0"),
       port: settingInt("PORT", "port", 4319),
-      /** Shared-secret token required to log in. Empty string disables auth (dev only). */
+      /** Shared secret for login. Empty disables auth (dev only). */
       token: setting("CASPER_TOKEN", "token", ""),
-      /** Device-login lifetime in seconds; slid forward on activity. Default 7 days. */
+      /** Device-login lifetime in seconds, slid forward on activity. Default 7 days. */
       sessionTtlSeconds: settingInt("CASPER_SESSION_TTL_SECONDS", "sessionTtlSeconds", 60 * 60 * 24 * 7),
       kiroBin: resolveKiroBin(setting("KIRO_BIN", "kiroBin", "kiro-cli"), home),
       defaultCwd: setting("DEFAULT_CWD", "defaultCwd", process.cwd()),
       maxLiveSessions: settingInt("MAX_LIVE_SESSIONS", "maxLiveSessions", 6),
-      /**
-       * The agent Casper installs, which is the one with the widget tools. Safe as a
-       * default even when it is missing: kiro-cli acp falls back to kiro_default rather
-       * than failing, and reports what it chose, which is what a session records.
-       */
+      /** The agent Casper installs, with the widget tools. Falls back to kiro_default
+       *  if missing rather than failing. */
       defaultAgent: setting("DEFAULT_AGENT", "defaultAgent", "casper"),
-      /**
-       * Filesystem root the file endpoints (/api/fs/dirs, /api/fs/file) are confined to; anything
-       * resolving outside it is rejected. Defaults to /, so browsing spans everything the process
-       * can read - set a narrower path to keep authenticated users out of system files such as /etc
-       * or SSH keys.
-       */
+      /** Filesystem root the file endpoints are confined to. Defaults to /; narrow it
+       *  to keep authenticated users out of system files such as /etc or SSH keys. */
       fileRoot: path5.resolve(setting("CASPER_FILE_ROOT", "fileRoot", "/")),
-      /**
-       * Directory where kiro-cli persists its own session files. Overridable for the
-       * same reason as every other path here: a non-default kiro home, a container,
-       * or a test that must not write into the real one.
-       */
       kiroSessionsDir: path5.resolve(
         setting(
           "CASPER_KIRO_SESSIONS_DIR",
@@ -346,16 +330,10 @@ var init_config = __esm({
           path5.join(home, ".kiro", "sessions", "cli")
         )
       ),
-      /** Where casper.db lives. Env-only: it says where data is, and the config
-       *  file isn't there. */
       casperDataDir: dataDirPath(),
-      /** Built web app to serve. Env-only: install layout, not a user preference. */
       webDist: env("CASPER_WEB_DIST", defaultWebDist()),
-      /** Per-session in-memory event ring buffer size. */
       eventBufferSize: settingInt("EVENT_BUFFER_SIZE", "eventBufferSize", 5e3),
-      /** Max size (bytes) for a single uploaded file. Default 100 MB. */
       maxUploadBytes: settingInt("CASPER_MAX_UPLOAD_BYTES", "maxUploadBytes", 100 * 1024 * 1024),
-      /** Absolute path of the settings file, for diagnostics. */
       configFile: configFilePath()
     };
   }
@@ -414,6 +392,13 @@ CREATE TABLE IF NOT EXISTS message_attachments (
   kind     TEXT    NOT NULL,
   PRIMARY KEY (chat_id, ordinal, path)
 );
+CREATE TABLE IF NOT EXISTS subagent_links (
+  child_session_id  TEXT PRIMARY KEY,
+  parent_session_id TEXT NOT NULL,
+  tool_call_id      TEXT NOT NULL,
+  stage_name        TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS subagent_links_parent ON subagent_links (parent_session_id);
 `;
   }
 });
@@ -451,12 +436,11 @@ var init_logins = __esm({
       ttlMs() {
         return config.sessionTtlSeconds * 1e3;
       }
-      /** Drop logins whose last activity is older than the TTL. */
       pruneExpired(now = Date.now()) {
         const cutoff = new Date(now - this.ttlMs()).toISOString();
         db().prepare("DELETE FROM logins WHERE last_seen_at < ?").run(cutoff);
       }
-      /** Create a login. Returns the raw token to set as the cookie value. */
+      /** Creates a login. Returns the raw token to set as the cookie value. */
       create(userAgent) {
         const token = randomBytes(32).toString("base64url");
         const nowIso = (/* @__PURE__ */ new Date()).toISOString();
@@ -473,10 +457,7 @@ var init_logins = __esm({
         ).run(record.id, record.hash, nowIso, nowIso, userAgent ?? null);
         return { token, record };
       }
-      /**
-       * Verify a raw token. Returns the record (sliding its expiry forward) or null
-       * if unknown/expired. Writes the lastSeen bump at most once a minute.
-       */
+      /** Verifies a raw token, sliding its expiry forward. Null if unknown or expired. */
       verify(token) {
         if (!token) return null;
         const now = Date.now();
@@ -493,7 +474,7 @@ var init_logins = __esm({
         }
         return record;
       }
-      /** List all active devices, marking the one owning `currentToken`. */
+      /** All active devices, marking the one owning `currentToken`. */
       list(currentToken) {
         this.pruneExpired();
         const currentHash = currentToken ? sha256(currentToken) : void 0;
@@ -506,17 +487,16 @@ var init_logins = __esm({
           current: currentHash !== void 0 && sameHash(r.hash, currentHash)
         }));
       }
-      /** Revoke the device holding this token (used on logout). */
+      /** Revokes the device holding this token (used on logout). */
       revokeToken(token) {
         if (!token) return;
         db().prepare("DELETE FROM logins WHERE hash = ?").run(sha256(token));
       }
-      /** Revoke a device by its public id. Returns false if there was no such device. */
+      /** Revokes a device by its public id. False if there was no such device. */
       revokeId(id) {
         const res = db().prepare("DELETE FROM logins WHERE id = ?").run(id);
         return res.changes > 0;
       }
-      /** Log out every device. */
       revokeAll() {
         db().prepare("DELETE FROM logins").run();
       }
@@ -972,7 +952,6 @@ var init_AcpClient = __esm({
           this.emit("serverRequest", msg);
         }
       }
-      /** Send a request and await its result. */
       request(method, params, timeoutMs = 12e4) {
         if (this.closed) return Promise.reject(new Error("ACP client is closed"));
         const id = this.nextId++;
@@ -1002,12 +981,8 @@ var init_AcpClient = __esm({
       write(msg) {
         this.writable.write(JSON.stringify(msg) + "\n");
       }
-      /**
-       * Reject all pending requests; call when the child process exits. The reason
-       * is passed through verbatim because it reaches the user as a turn_error -
-       * the caller supplies something readable, so don't bury it behind a prefix
-       * about ACP internals.
-       */
+      /** Rejects all pending requests, called when the child process exits. The
+       *  reason passes through verbatim, since it reaches the user as a turn_error. */
       fail(reason) {
         this.closed = true;
         for (const [id, pending] of this.pending) {
@@ -1088,7 +1063,7 @@ var init_KiroProcess = __esm({
         this.child.stdout.on("error", () => {
         });
       }
-      /** Perform the ACP initialize handshake. kiro's reply is not used. */
+      /** The ACP initialize handshake. kiro's reply is not used. */
       async initialize() {
         await this.client.request(ACP_METHODS.initialize, {
           protocolVersion: 1,
@@ -1096,8 +1071,6 @@ var init_KiroProcess = __esm({
             fs: { readTextFile: false, writeTextFile: false },
             terminal: false
           },
-          // Informational only - kiro logs it and nothing reads it back, so it isn't
-          // worth wiring to package.json.
           clientInfo: { name: "casper", version: "0.5.0" }
         });
       }
@@ -1107,7 +1080,7 @@ var init_KiroProcess = __esm({
       loadSession(params) {
         return this.client.request(ACP_METHODS.sessionLoad, params);
       }
-      /** Run a prompt turn to completion. Resolves with the stop reason. */
+      /** Runs a prompt turn to completion. */
       prompt(params) {
         return this.client.request(
           ACP_METHODS.sessionPrompt,
@@ -1130,27 +1103,17 @@ var init_KiroProcess = __esm({
           command: { command: command.replace(/^\//, ""), args: {} }
         });
       }
-      /** Cleanly shut down: close stdin (triggers kiro's graceful exit), then kill. */
-      /**
-       * Recent stderr from kiro, for attaching to a failure.
-       *
-       * A failed request doesn't always carry its cause in the JSON-RPC error - when
-       * it doesn't, kiro has usually written something here. Shared across turns, so
-       * treat it as context rather than proof.
-       */
+      /** Recent stderr from kiro, for attaching to a failure. */
       stderrTail() {
         return this.recentStderr.join("\n").trim();
       }
-      /**
-       * Why the child died, in terms a user can act on. The exit code alone is
-       * opaque, so append what kiro printed - that's where "credentials have
-       * expired, run kiro-cli login" and friends show up.
-       */
+      /** Why the child died: exit code plus whatever kiro printed. */
       exitReason(code, signal) {
         const base = signal ? `kiro-cli exited on ${signal}` : `kiro-cli exited with code ${code}`;
         const tail = this.recentStderr.join("\n").trim();
         return tail ? `${base}: ${tail}` : base;
       }
+      // Closes stdin to trigger kiro's graceful exit, then force-kills if it lingers.
       dispose() {
         if (this.disposed) return;
         this.disposed = true;
@@ -1162,11 +1125,8 @@ var init_KiroProcess = __esm({
           if (this.child.exitCode === null) this.child.kill("SIGTERM");
         }, 1e3).unref();
       }
-      /**
-       * Dispose and resolve once the child has actually exited. kiro writes its
-       * session file on shutdown, so a caller that then deletes those files must
-       * wait for exit first, or kiro's write recreates them.
-       */
+      /** Resolves once the child has exited. Caller must wait before deleting
+       *  session files, or kiro's shutdown write recreates them. */
       disposeAndWait(timeoutMs = 4e3) {
         if (this.child.exitCode !== null) {
           this.dispose();
@@ -1205,7 +1165,6 @@ var init_EventStore = __esm({
         this.chatId = chatId;
         this.capacity = config.eventBufferSize;
       }
-      /** Append an event, assign it the next seq, and fan it out. */
       append(payload) {
         this.seq += 1;
         const event = {
@@ -1219,19 +1178,15 @@ var init_EventStore = __esm({
         this.emit("event", event);
         return event;
       }
-      /** Highest assigned seq. Clients start their cursor here after a full refetch. */
+      /** Highest assigned seq; clients start their cursor here after a full refetch. */
       head() {
         return this.seq;
       }
-      /** Oldest seq still in the buffer (0 if empty). */
       tail() {
         return this.buffer.length > 0 ? this.buffer[0].seq : 0;
       }
-      /**
-       * Events with seq > cursor, in order. Returns { events, gap } - gap is true
-       * when the cursor is older than the buffer tail, meaning some events were
-       * evicted and the client must resync (full transcript refetch).
-       */
+      /** Events with seq > cursor. `gap` is true when the cursor is older than the
+       *  buffer tail, meaning evicted events the client must resync for instead. */
       getSince(cursor) {
         if (this.buffer.length === 0) {
           return { events: [], gap: cursor > 0 };
@@ -1294,6 +1249,153 @@ var init_TurnState = __esm({
   }
 });
 
+// server/src/session/SubagentTracker.ts
+var SubagentTracker;
+var init_SubagentTracker = __esm({
+  "server/src/session/SubagentTracker.ts"() {
+    "use strict";
+    SubagentTracker = class {
+      byChild = /* @__PURE__ */ new Map();
+      pendingCalls = [];
+      callStarted(toolCallId, stages) {
+        this.pendingCalls.push({ toolCallId, stages });
+      }
+      callFinished(toolCallId) {
+        const i = this.pendingCalls.findIndex((c) => c.toolCallId === toolCallId);
+        if (i >= 0) this.pendingCalls.splice(i, 1);
+      }
+      callFor(stageName) {
+        for (let i = this.pendingCalls.length - 1; i >= 0; i--) {
+          if (this.pendingCalls[i].stages.some((s) => s.name === stageName)) return this.pendingCalls[i];
+        }
+        return void 0;
+      }
+      /** Folds a list_update into the tracked state, returning links newly resolved
+       *  this call, so the caller persists each one once. */
+      apply(subagents, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+        const resolved = [];
+        for (const info of subagents) {
+          const existing = this.byChild.get(info.sessionId);
+          const nowIso = now();
+          const toolCallId = existing?.toolCallId ?? this.callFor(info.sessionName)?.toolCallId;
+          if (toolCallId && !existing?.toolCallId) {
+            resolved.push({ sessionId: info.sessionId, toolCallId, stageName: info.sessionName });
+          }
+          this.byChild.set(info.sessionId, {
+            sessionId: info.sessionId,
+            stageName: info.sessionName,
+            toolCallId,
+            status: info.status.type === "terminated" ? "completed" : "working",
+            activity: info.status.message,
+            createdAt: existing?.createdAt ?? nowIso,
+            updatedAt: nowIso
+          });
+        }
+        return resolved;
+      }
+      /** Started stages plus a synthetic 'pending' row for each declared stage that
+       *  hasn't started, so a stage waiting on a dependency still shows up. */
+      listForCall(toolCallId) {
+        const call = this.pendingCalls.find((c) => c.toolCallId === toolCallId);
+        const started = [...this.byChild.values()].filter((s) => s.toolCallId === toolCallId);
+        if (!call) return started.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        const startedNames = new Set(started.map((s) => s.stageName));
+        const pending = call.stages.filter((s) => !startedNames.has(s.name)).map((s) => ({
+          sessionId: `pending:${toolCallId}:${s.name}`,
+          stageName: s.name,
+          toolCallId,
+          status: "pending",
+          activity: s.depends_on?.length ? `Waits for ${s.depends_on.join(" and ")}` : void 0,
+          createdAt: "",
+          updatedAt: ""
+        }));
+        return [...started.sort((a, b) => a.createdAt.localeCompare(b.createdAt)), ...pending];
+      }
+      list() {
+        return [...this.byChild.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+      }
+      get(sessionId) {
+        return this.byChild.get(sessionId);
+      }
+    };
+  }
+});
+
+// server/src/session/subagentResult.ts
+function showSummaryAsAnswer(transcript) {
+  const out = [];
+  for (const item of transcript) {
+    if (item.type === "message" && item.message.role === "assistant" && item.message.text.trim() === INTERRUPTED) {
+      continue;
+    }
+    if (item.type === "tool_call" && item.tool.name === "summary") {
+      const input = item.tool.input;
+      const result = typeof input?.taskResult === "string" ? input.taskResult.trim() : "";
+      if (result) out.push({ type: "message", message: { id: item.tool.id, role: "assistant", text: result } });
+      continue;
+    }
+    out.push(item);
+  }
+  return out;
+}
+var INTERRUPTED;
+var init_subagentResult = __esm({
+  "server/src/session/subagentResult.ts"() {
+    "use strict";
+    INTERRUPTED = "Tool uses were interrupted, waiting for the next user prompt";
+  }
+});
+
+// server/src/session/subagentFallbackMatch.ts
+function isStageInput(v) {
+  return typeof v === "object" && v !== null && typeof v.name === "string";
+}
+function subagentCallInput(tool) {
+  if (tool.name !== "subagent") return null;
+  const input = tool.input;
+  if (!input || !Array.isArray(input.stages)) return null;
+  const stages = input.stages.filter(isStageInput);
+  return { task: typeof input.task === "string" ? input.task : void 0, stages };
+}
+function expectedTitle(call, stage) {
+  const task = call.task ?? "";
+  const expanded = stage.prompt_template ? stage.prompt_template.replace("{task}", task) : task;
+  return expanded.slice(0, TITLE_MAX_LENGTH);
+}
+function subagentCallsIn(transcript) {
+  const calls = [];
+  transcript.forEach((item, itemIndex) => {
+    if (item.type !== "tool_call") return;
+    const input = subagentCallInput(item.tool);
+    if (!input) return;
+    calls.push({ toolCallId: item.tool.id, itemIndex, input });
+  });
+  return calls;
+}
+function matchSubagentsFallback(calls, children) {
+  const sortedCalls = [...calls].sort((a, b) => a.itemIndex - b.itemIndex);
+  const unclaimed = [...children].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const matches = [];
+  for (const call of sortedCalls) {
+    for (const stage of call.input.stages) {
+      const want = expectedTitle(call.input, stage);
+      if (!want) continue;
+      const i = unclaimed.findIndex((c) => want.startsWith(c.title) || c.title.startsWith(want));
+      if (i < 0) continue;
+      const child = unclaimed.splice(i, 1)[0];
+      matches.push({ sessionId: child.sessionId, toolCallId: call.toolCallId, stageName: stage.name });
+    }
+  }
+  return matches;
+}
+var TITLE_MAX_LENGTH;
+var init_subagentFallbackMatch = __esm({
+  "server/src/session/subagentFallbackMatch.ts"() {
+    "use strict";
+    TITLE_MAX_LENGTH = 150;
+  }
+});
+
 // server/src/session/kiroFiles.ts
 import fs9 from "node:fs/promises";
 import path10 from "node:path";
@@ -1329,7 +1431,6 @@ function summarize(j) {
   const contextUsagePercentage = state?.rts_model_state?.context_usage_percentage ?? turns[turns.length - 1]?.context_usage_percentage;
   return {
     sessionId: j.session_id,
-    // Left empty when kiro has not named it; resolveSessionTitle decides what to show.
     title: j.title?.trim() ?? "",
     cwd: j.cwd,
     createdAt: j.created_at,
@@ -1362,6 +1463,29 @@ async function readPersistedSession(sessionId) {
     return null;
   }
 }
+async function listChildSessions(parentSessionId) {
+  if (!isValidSessionId(parentSessionId)) return [];
+  let names;
+  try {
+    names = await fs9.readdir(config.kiroSessionsDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  await Promise.all(
+    names.filter((n) => n.endsWith(".json")).map(async (n) => {
+      try {
+        const raw = await fs9.readFile(path10.join(config.kiroSessionsDir, n), "utf8");
+        const j = JSON.parse(raw);
+        if (j.parent_session_id === parentSessionId) {
+          out.push({ ...summarize(j), parentSessionId });
+        }
+      } catch {
+      }
+    })
+  );
+  return out;
+}
 async function promptCount(sessionId) {
   const entries = await readJsonlEntries(sessionId);
   return entries.filter((e) => e.kind === "Prompt").length;
@@ -1466,7 +1590,6 @@ var init_chatStore = __esm({
     "use strict";
     init_db();
     ChatStore = class {
-      /** Every chat. Ordering is kiro's business, applied once the file is joined on. */
       all() {
         return db().prepare("SELECT chat_id, session_id, title, cwd FROM chats").all().map((r) => ({ chatId: r.chat_id, sessionId: r.session_id, title: r.title, cwd: r.cwd }));
       }
@@ -1477,10 +1600,8 @@ var init_chatStore = __esm({
       create(chatId) {
         db().prepare("INSERT INTO chats (chat_id) VALUES (?) ON CONFLICT(chat_id) DO NOTHING").run(chatId);
       }
-      /**
-       * kiro names the session once it starts one; bind it to the chat that owns it. A session
-       * belongs to exactly one chat, so any earlier claim on it is released.
-       */
+      /** Binds the session kiro named once it started one. A session belongs to
+       *  exactly one chat, so any earlier claim on it is released. */
       bindSession(chatId, sessionId) {
         db().prepare("UPDATE chats SET session_id = NULL WHERE session_id = ? AND chat_id <> ?").run(sessionId, chatId);
         this.write(chatId, "session_id", sessionId);
@@ -1501,7 +1622,7 @@ var init_chatStore = __esm({
       setCwd(chatId, cwd) {
         this.write(chatId, "cwd", cwd);
       }
-      /** Record what was attached to one prompt. See db.ts for why the key is an ordinal. */
+      /** What was attached to one prompt, keyed by ordinal (see db.ts). */
       setAttachments(chatId, ordinal, files) {
         if (files.length === 0) return;
         const stmt = db().prepare(
@@ -1550,6 +1671,38 @@ var init_chatStore = __esm({
   }
 });
 
+// server/src/session/subagentLinks.ts
+var SubagentLinkStore;
+var init_subagentLinks = __esm({
+  "server/src/session/subagentLinks.ts"() {
+    "use strict";
+    init_db();
+    SubagentLinkStore = class {
+      /** Record (or correct) one child's link. Idempotent: a repeat call with the same
+       *  values is a no-op, and the row always reflects the latest call to resolve it. */
+      record(childSessionId, parentSessionId, toolCallId, stageName) {
+        db().prepare(
+          `INSERT INTO subagent_links (child_session_id, parent_session_id, tool_call_id, stage_name)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(child_session_id) DO UPDATE SET
+           parent_session_id = excluded.parent_session_id,
+           tool_call_id = excluded.tool_call_id,
+           stage_name = excluded.stage_name`
+        ).run(childSessionId, parentSessionId, toolCallId, stageName);
+      }
+      /** Every link recorded for one parent session's children, keyed by child session id. */
+      forParent(parentSessionId) {
+        const rows = db().prepare(
+          "SELECT child_session_id, tool_call_id, stage_name FROM subagent_links WHERE parent_session_id = ?"
+        ).all(parentSessionId);
+        const out = /* @__PURE__ */ new Map();
+        for (const r of rows) out.set(r.child_session_id, { toolCallId: r.tool_call_id, stageName: r.stage_name });
+        return out;
+      }
+    };
+  }
+});
+
 // server/src/session/SessionManager.ts
 import fs10 from "node:fs";
 import path11 from "node:path";
@@ -1585,6 +1738,22 @@ function mapNotification(n) {
       return null;
   }
 }
+function notificationSessionId(n) {
+  const params = n.params;
+  return params?.sessionId;
+}
+function subagentCallStages(update) {
+  if (update.sessionUpdate !== "tool_call") return null;
+  const meta = update._meta;
+  if (meta?.kiro?.toolName !== "subagent") return null;
+  const toolCallId = update.toolCallId;
+  const rawInput = update.rawInput;
+  if (typeof toolCallId !== "string" || !Array.isArray(rawInput?.stages)) return null;
+  const stages = rawInput.stages.filter(
+    (s) => typeof s === "object" && s !== null && typeof s.name === "string"
+  );
+  return { toolCallId, stages };
+}
 function newerOf(a, b) {
   return a && a.localeCompare(b) > 0 ? a : b;
 }
@@ -1607,38 +1776,34 @@ var init_SessionManager = __esm({
     init_KiroProcess();
     init_EventStore();
     init_TurnState();
+    init_SubagentTracker();
+    init_subagentResult();
+    init_subagentFallbackMatch();
     init_kiroFiles();
     init_chatStore();
+    init_subagentLinks();
     Session = class {
       sessionId;
       store;
       turnState = new TurnState();
+      subagents = new SubagentTracker();
       cwd;
       agentId;
       modelId;
       currentModeId;
       availableModes = [];
-      /** Empty until something names it; resolveSessionTitle owns the fallback. */
       title = "";
       createdAt = (/* @__PURE__ */ new Date()).toISOString();
       updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       lastActivity = Date.now();
       running = false;
-      // True once kiro has created or loaded this session id.
       everLive = false;
       proc;
-      // In-flight spawn, so concurrent actions share one process.
       spawning;
-      /**
-       * Set while this session's process is being replaced, and resolved when the
-       * replacement is ready. Claimed synchronously with the reload's guard, so an
-       * action arriving during one waits for the new process instead of acting on the
-       * one about to be disposed.
-       */
+      // An action during a reload waits on this instead of acting on the process
+      // about to be disposed.
       reloading;
-      // True while kiro is replaying history during session/load. The transcript is
-      // already hydrated from disk, so replayed notifications must not be appended
-      // to the live store (doing so floods the chat with duplicate tool calls).
+      // True while kiro replays history during session/load.
       replaying = false;
       constructor(sessionId, store, cwd) {
         this.sessionId = sessionId;
@@ -1651,12 +1816,7 @@ var init_SessionManager = __esm({
       get hasBeenLive() {
         return this.everLive;
       }
-      /**
-       * Single append path: fold the event into the live snapshot AND persist/fan
-       * it out. Using this everywhere keeps turnState in sync with the event log,
-       * so a client that refetches mid-turn sees turnStatus 'running' rather than
-       * a stale 'idle'.
-       */
+      // Folds the event into the live snapshot and persists it in one call.
       record(payload) {
         this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.turnState.apply(payload);
@@ -1668,15 +1828,13 @@ var init_SessionManager = __esm({
       sessions = /* @__PURE__ */ new Map();
       log;
       store = new ChatStore();
+      subagentLinks = new SubagentLinkStore();
       spawnProcess;
       constructor(log, opts = {}) {
         this.log = log;
         this.spawnProcess = opts.spawn ?? ((o, l) => new KiroProcess(o, l));
       }
-      /**
-       * What a session is called, from every read path. The folder is skipped for a workspace of
-       * ours, whose name is a uuid.
-       */
+      /** What a session is called, from every read path. */
       titleOf(chat, parts) {
         return resolveSessionTitle({
           override: chat.title ?? void 0,
@@ -1691,10 +1849,8 @@ var init_SessionManager = __esm({
         const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         if (s) s.title = clean || s.title;
       }
-      /**
-       * Re-point a session at a different working directory. Any live process was spawned with the
-       * old cwd, so it is disposed and the next turn respawns in the new one, transcript intact.
-       */
+      // A live process was spawned with the old cwd, so it's disposed and the next
+      // turn respawns.
       async setChatCwd(chatId, input) {
         const resolved = resolveCwd(input);
         const s = await this.ensureOpen(chatId);
@@ -1716,15 +1872,8 @@ var init_SessionManager = __esm({
         }
         return resolved;
       }
-      /**
-       * Restart the session's kiro child, so what kiro reads only at startup is read again: the
-       * agent definition, the workspace's `.kiro`, and the MCP servers kiro launches itself.
-       * Replacing the process is the only way - no ACP method does it, and `session/set_mode`
-       * leaves those MCP servers alone.
-       *
-       * The old child must be awaited out first: kiro flushes its session file on shutdown and
-       * the replacement reads that file to reload the conversation.
-       */
+      /** Restarts the session's kiro child so startup-only state (agent definition,
+       *  workspace `.kiro`, MCP servers) is read again. */
       async reloadChat(chatId) {
         const s = await this.ensureOpen(chatId);
         if (s.running) {
@@ -1747,7 +1896,7 @@ var init_SessionManager = __esm({
           ready();
         }
       }
-      /** The reload itself. Only ever called with the session's reload claim held. */
+      /** The reload itself, called with the session's reload claim held. */
       async replaceProcess(chatId, s) {
         if (!await hasRecordedTurns(s.sessionId)) {
           throw new Error(
@@ -1769,10 +1918,6 @@ var init_SessionManager = __esm({
         this.log.info({ sessionId: s.sessionId, cwd: s.cwd }, "session reloaded");
         return this.getDetail(chatId);
       }
-      /**
-       * Wait out a reload before touching the session's process. Without this an action
-       * can be handed the process that the reload is about to dispose.
-       */
       async settleReload(s) {
         if (s.reloading) await s.reloading;
       }
@@ -1781,9 +1926,6 @@ var init_SessionManager = __esm({
         for (const s of this.sessions.values()) if (s.proc) n++;
         return n;
       }
-      // -------------------------------------------------------------------------
-      // Event subscription - works for any opened session, spawned or not.
-      // -------------------------------------------------------------------------
       onEvent(chatId, cb) {
         const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         if (!s) return null;
@@ -1793,12 +1935,12 @@ var init_SessionManager = __esm({
       getStore(chatId) {
         return this.sessions.get(this.store.sessionIdForChat(chatId) ?? "")?.store;
       }
-      /** A chat's working directory. Opens it in memory if needed. */
+      /** A chat's working directory, opened in memory if needed. */
       async getChatCwd(chatId) {
         const s = await this.ensureOpen(chatId);
         return s.cwd;
       }
-      /** Open a chat's session in memory (store + metadata) WITHOUT spawning a process. */
+      /** Opens a chat's session in memory without spawning a process. */
       async ensureOpen(chatId) {
         const sessionId = this.sessionIdOf(chatId);
         const existing = this.sessions.get(sessionId);
@@ -1824,15 +1966,33 @@ var init_SessionManager = __esm({
         this.sessions.set(sessionId, s);
         return s;
       }
-      // -------------------------------------------------------------------------
-      // Lazy process spawning
-      // -------------------------------------------------------------------------
       wire(s, proc) {
         proc.on("notification", (n) => {
           if (s.replaying) return;
-          const payload = mapNotification(n);
-          if (!payload) return;
-          s.record(payload);
+          if (n.method === KIRO_NOTIFICATIONS.subagentListUpdate) {
+            const params = n.params;
+            const resolved = s.subagents.apply(params.subagents);
+            for (const link of resolved) {
+              this.subagentLinks.record(link.sessionId, s.sessionId, link.toolCallId, link.stageName);
+            }
+            s.record({ kind: "subagents_changed", subagents: s.subagents.list() });
+            return;
+          }
+          const notifSessionId = notificationSessionId(n);
+          if (!notifSessionId || notifSessionId === s.sessionId) {
+            const payload = mapNotification(n);
+            if (!payload) return;
+            if (payload.kind === "session_update") {
+              const call = subagentCallStages(payload.update);
+              if (call) s.subagents.callStarted(call.toolCallId, call.stages);
+              const update = payload.update;
+              if (update.sessionUpdate === "tool_call_update" && typeof update.toolCallId === "string" && (update.status === "completed" || update.status === "failed")) {
+                s.subagents.callFinished(update.toolCallId);
+              }
+            }
+            s.record(payload);
+            return;
+          }
         });
         proc.on("exit", (code, signal) => {
           if (s.proc !== proc) return;
@@ -1841,7 +2001,7 @@ var init_SessionManager = __esm({
           s.running = false;
         });
       }
-      /** Get (or spawn + initialize + create/load) the kiro process for a session. */
+      /** Gets or spawns the kiro process for a session. */
       async ensureProc(s) {
         if (s.proc) return s.proc;
         if (s.spawning) return s.spawning;
@@ -1903,10 +2063,7 @@ var init_SessionManager = __esm({
           this.log.warn("at capacity but all processes are busy");
         }
       }
-      // -------------------------------------------------------------------------
-      // Creating / opening
-      // -------------------------------------------------------------------------
-      /** Create a new session. Spawns immediately so we get a real kiro sessionId. */
+      /** Creates a new session. Spawns immediately to get a real kiro sessionId. */
       async createChat(opts) {
         const chatId = isValidChatId(opts.chatId) ? opts.chatId : crypto.randomUUID();
         const cwd = opts.freshWorkspace ? createChatWorkspace(chatId) : resolveCwd(opts.cwd);
@@ -1932,9 +2089,6 @@ var init_SessionManager = __esm({
         }
         return this.buildDetail(this.store.get(chatId), s, []);
       }
-      // -------------------------------------------------------------------------
-      // Actions - these spawn the process lazily.
-      // -------------------------------------------------------------------------
       async runPrompt(chatId, content, attachments) {
         const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
@@ -2003,14 +2157,8 @@ ${tail}` : err.message;
         await proc.execCommand(s.sessionId, command);
         s.lastActivity = Date.now();
       }
-      // -------------------------------------------------------------------------
-      // Listing / detail - never spawns.
-      // -------------------------------------------------------------------------
-      /**
-       * The one place a ChatSummary is assembled: kiro's file and Casper's live state each hold
-       * part of the truth, so every read path projects them through here. `persisted` is absent for
-       * a session with no file yet, `live` for a dormant one, and callers guarantee one of them.
-       */
+      /** The one place a ChatSummary is assembled, since kiro's file and Casper's
+       *  live state each hold part of the truth. */
       summaryOf(chat, live, persisted, transcript) {
         const snap = live?.turnState.get();
         const cwd = live?.cwd ?? chat.cwd ?? persisted?.cwd ?? config.defaultCwd;
@@ -2018,21 +2166,18 @@ ${tail}` : err.message;
           chatId: chat.chatId,
           sessionId: live?.sessionId ?? chat.sessionId ?? void 0,
           title: this.titleOf(chat, {
-            // kiro's file is what kiro called it; the live copy is only a cache of it.
             kiroTitle: persisted?.title || live?.title,
             firstPrompt: transcript && firstPromptText(transcript),
             cwd
           }),
           cwd,
           createdAt: persisted?.createdAt ?? live?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-          // kiro's file and our own activity move separately.
           updatedAt: live ? newerOf(persisted?.updatedAt, live.updatedAt) : persisted?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
           liveness: live?.proc ? "live" : "dormant",
           agentId: live?.agentId ?? persisted?.agentId,
           modelId: live?.modelId ?? persisted?.modelId,
           running: live?.running ?? false,
-          // A live snapshot starts at zero until the first turn reports, so a dormant
-          // session's value comes from kiro's file.
+          // A dormant session falls back to kiro's file.
           contextUsagePercentage: snap?.contextUsagePercentage || persisted?.contextUsagePercentage
         };
       }
@@ -2072,11 +2217,8 @@ ${tail}` : err.message;
         if (!s && !persisted) throw new Error(`Unknown chat: ${chatId}`);
         return this.buildDetail(chat, s, transcript, persisted ?? void 0);
       }
-      /**
-       * A slice of the transcript for lazy "load older on scroll up". Re-hydrates
-       * from disk (fast: ~150ms even for a multi-MB session) and returns the
-       * requested window. offset/limit are clamped to the transcript bounds.
-       */
+      /** A transcript slice for lazy "load older on scroll up". offset/limit are
+       *  clamped to the transcript bounds. */
       async getTranscriptPage(chatId, offset, limit) {
         const transcript = await hydrateTranscript(
           this.sessionIdOf(chatId),
@@ -2086,13 +2228,58 @@ ${tail}` : err.message;
         const end = Math.max(start, Math.min(start + limit, transcript.length));
         return transcript.slice(start, end);
       }
+      /**
+       * A chat's subagents: live ones from the tracker, joined with children found on disk.
+       * A child the tracker never saw falls back to a recorded link or title matching
+       * (subagentFallbackMatch.ts).
+       */
+      async getSubagents(chatId) {
+        const sessionId = this.sessionIdOf(chatId);
+        const s = this.sessions.get(sessionId);
+        const live = s ? s.subagents.list() : [];
+        const liveToolCalls = new Set(live.map((a) => a.toolCallId).filter((id) => !!id));
+        const pending = s ? [...liveToolCalls].flatMap((id) => s.subagents.listForCall(id).filter((a) => a.status === "pending")) : [];
+        const onDisk = await listChildSessions(sessionId);
+        const links = this.subagentLinks.forParent(sessionId);
+        const liveIds = new Set(live.map((a) => a.sessionId));
+        const unresolved = onDisk.filter((c) => !liveIds.has(c.sessionId) && !links.has(c.sessionId));
+        const fallback = unresolved.length ? matchSubagentsFallback(subagentCallsIn(await hydrateTranscript(sessionId)), unresolved) : [];
+        const fallbackByChild = new Map(fallback.map((m) => [m.sessionId, m]));
+        const byId = /* @__PURE__ */ new Map();
+        for (const child of onDisk) {
+          const link = links.get(child.sessionId) ?? fallbackByChild.get(child.sessionId);
+          byId.set(child.sessionId, {
+            sessionId: child.sessionId,
+            stageName: link?.stageName ?? (child.title || child.sessionId),
+            toolCallId: link?.toolCallId,
+            status: "completed",
+            createdAt: child.createdAt,
+            updatedAt: child.updatedAt
+          });
+        }
+        for (const a of live) byId.set(a.sessionId, a);
+        const startedThenPending = [...byId.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        return [...startedThenPending, ...pending];
+      }
+      /** One subagent's own transcript, hydrated the same way a chat's is. */
+      async getSubagentDetail(chatId, childSessionId) {
+        const parentSessionId = this.sessionIdOf(chatId);
+        const subagents = await this.getSubagents(chatId);
+        const summary = subagents.find((a) => a.sessionId === childSessionId);
+        if (!summary) throw new Error(`Unknown subagent: ${childSessionId}`);
+        const onDisk = await listChildSessions(parentSessionId);
+        if (!onDisk.some((c) => c.sessionId === childSessionId)) {
+          throw new Error(`Unknown subagent: ${childSessionId}`);
+        }
+        const transcript = showSummaryAsAnswer(await hydrateTranscript(childSessionId));
+        return { subagent: summary, transcript };
+      }
       /** One projection, so a dormant session and a live one cannot disagree. */
       buildDetail(chat, s, transcript, persisted) {
         return {
           summary: this.summaryOf(chat, s, persisted, transcript),
           modes: s?.availableModes ?? [],
           currentModeId: s?.currentModeId ?? persisted?.agentId,
-          // Only the tail is sent on load; replayHead/title use the full transcript.
           transcript: transcript.slice(-TRANSCRIPT_PAGE_SIZE),
           transcriptTotal: transcript.length,
           observability: s?.turnState.get() ?? {
@@ -2103,9 +2290,8 @@ ${tail}` : err.message;
         };
       }
       /**
-       * The cursor a reconnecting client starts from. Normally the store head, but kiro writes a turn
-       * to its jsonl only once it completes, so a hydrated transcript is missing one in flight:
-       * rewind to just before its turn_started and let the socket replay the whole turn.
+       * The cursor a reconnecting client starts from: the store head, unless the in-flight
+       * turn isn't in kiro's jsonl yet, in which case rewind to its turn_started.
        */
       replayHead(s, transcript) {
         const head = s.store.head();
@@ -2131,9 +2317,6 @@ ${tail}` : err.message;
         }
         return started.seq - 1;
       }
-      // -------------------------------------------------------------------------
-      // Teardown
-      // -------------------------------------------------------------------------
       evict(sessionId) {
         const s = this.sessions.get(sessionId);
         if (!s) return;
@@ -2141,8 +2324,7 @@ ${tail}` : err.message;
         s.proc?.dispose();
         s.store.dispose();
       }
-      // Permanently delete a session: evict it from memory, remove its on-disk
-      // files and the directory the chat owns, and drop any title override.
+      // Evicts from memory, removes on-disk files and the chat's directory.
       async deleteChat(chatId) {
         const sessionId = this.store.sessionIdForChat(chatId);
         const s = sessionId ? this.sessions.get(sessionId) : void 0;
@@ -2946,6 +3128,37 @@ var init_chats2 = __esm({
   }
 });
 
+// server/src/routes/subagents.ts
+function registerSubagentRoutes(app, manager) {
+  app.get(
+    "/api/chats/:id/subagents",
+    async (req, reply) => {
+      try {
+        return { subagents: await manager.getSubagents(req.params.id) };
+      } catch (err) {
+        reply.code(404);
+        return { error: err.message };
+      }
+    }
+  );
+  app.get(
+    "/api/chats/:id/subagents/:subagentId",
+    async (req, reply) => {
+      try {
+        return await manager.getSubagentDetail(req.params.id, req.params.subagentId);
+      } catch (err) {
+        reply.code(404);
+        return { error: err.message };
+      }
+    }
+  );
+}
+var init_subagents = __esm({
+  "server/src/routes/subagents.ts"() {
+    "use strict";
+  }
+});
+
 // server/src/routes/workspace.ts
 import fs14 from "node:fs/promises";
 import { createReadStream as createReadStream3 } from "node:fs";
@@ -3140,9 +3353,6 @@ function registerUploadRoutes(app) {
         const kind = classifyKind(dest);
         const uploaded = {
           name: path17.basename(dest),
-          // Absolute, because the file sits outside the session's workspace: a
-          // relative path would resolve against the wrong root for both the agent
-          // and the image endpoint.
           path: dest,
           size: stat.size,
           mimeType: mimeForExt(ext),
@@ -3421,11 +3631,11 @@ import multipart from "@fastify/multipart";
 async function buildApp() {
   const isProd = process.env.NODE_ENV === "production";
   const app = Fastify({
-    // Honor X-Forwarded-Proto so `secure: 'auto'` cookies detect HTTPS when the
-    // server sits behind a TLS-terminating tunnel or reverse proxy.
+    // Honors X-Forwarded-Proto so secure: 'auto' cookies detect HTTPS behind a
+    // TLS-terminating tunnel or reverse proxy.
     trustProxy: true,
-    // In production, skip the two-lines-per-request access log; our own
-    // logger.info/warn/error calls still fire. Dev keeps it for debugging.
+    // Skip the two-lines-per-request access log in production; logger.info/warn/error
+    // calls still fire. Dev keeps it for debugging.
     disableRequestLogging: isProd,
     logger: {
       level: process.env.LOG_LEVEL ?? "info",
@@ -3446,6 +3656,7 @@ async function buildApp() {
   registerAgentRoutes(app);
   registerFsRoutes(app);
   registerChatRoutes(app, manager);
+  registerSubagentRoutes(app, manager);
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app);
   registerWsGateway(app, manager);
@@ -3482,6 +3693,7 @@ var init_app = __esm({
     init_agents2();
     init_fs();
     init_chats2();
+    init_subagents();
     init_workspace();
     init_uploads();
     init_health();
@@ -4112,7 +4324,7 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.14.4" : "dev";
+    VERSION = true ? "0.15.0" : "dev";
   }
 });
 
@@ -7492,7 +7704,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.14.4" : "dev";
+var VERSION2 = true ? "0.15.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);