@joeyshi12/casper 0.15.6 → 0.16.0

package/dist/server.js

@@ -118,13 +118,9 @@ function agentConfig(prompt, mcp) {
       casper: mcp ? { command: process.execPath, args: [mcp], env: {}, timeout: 1e4 } : { command: "casper", args: ["mcp"], env: {}, timeout: 1e4 }
     },
     tools: ["*"],
-    toolAliases: {},
-    allowedTools: [],
     resources: [],
-    hooks: {},
-    toolsSettings: {},
-    includeMcpJson: true,
-    model: null
+    hooks: [],
+    includeMcpJson: true
   };
 }
 function installAgentFile(home2, dataDir) {
@@ -317,17 +313,18 @@ var init_config = __esm({
       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, with the widget tools. Falls back to kiro_default
-       *  if missing rather than failing. */
+      /** The agent Casper installs, with the widget tools. kiro falls back to its Default
+       *  mode if it is missing rather than failing. */
       defaultAgent: setting("DEFAULT_AGENT", "defaultAgent", "casper"),
       /** 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", "/")),
+      /** kiro's session store, one directory per workspace. */
       kiroSessionsDir: path5.resolve(
         setting(
           "CASPER_KIRO_SESSIONS_DIR",
           "kiroSessionsDir",
-          path5.join(home, ".kiro", "sessions", "cli")
+          path5.join(home, ".kiro", "sessions")
         )
       ),
       casperDataDir: dataDirPath(),
@@ -403,13 +400,6 @@ CREATE TABLE IF NOT EXISTS turn_endings (
   items      TEXT    NOT NULL
 );
 CREATE INDEX IF NOT EXISTS turn_endings_chat ON turn_endings (chat_id);
-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);
 `;
   }
 });
@@ -639,10 +629,22 @@ function isJsonRpcError(m) {
 function isJsonRpcNotification(m) {
   return !("id" in m) && "method" in m;
 }
-var ACP_METHODS, KIRO_NOTIFICATIONS;
+function kiroToolName(call) {
+  const meta = call._meta?.kiro;
+  if (meta?.kind === "agent-subtask")
+    return SUBAGENT_TOOL;
+  const server = meta?.serverName;
+  if (!server)
+    return void 0;
+  const title = call.title ?? "";
+  const prefix = `@${server}/`;
+  return `${server}/${title.startsWith(prefix) ? title.slice(prefix.length) : title}`;
+}
+var SUBAGENT_TOOL, ACP_METHODS, KIRO_AGENT_NOT_FOUND;
 var init_acp = __esm({
   "shared/dist/acp.js"() {
     "use strict";
+    SUBAGENT_TOOL = "invoke_sub_agent";
     ACP_METHODS = {
       initialize: "initialize",
       sessionNew: "session/new",
@@ -650,19 +652,12 @@ var init_acp = __esm({
       sessionPrompt: "session/prompt",
       sessionCancel: "session/cancel",
       sessionSetMode: "session/set_mode",
-      sessionSetModel: "session/set_model",
+      sessionSetConfigOption: "session/set_config_option",
       sessionUpdate: "session/update",
-      commandsExecute: "_kiro.dev/commands/execute"
-    };
-    KIRO_NOTIFICATIONS = {
-      metadata: "_kiro.dev/metadata",
-      subagentListUpdate: "_kiro.dev/subagent/list_update",
-      mcpServerInitialized: "_kiro.dev/mcp/server_initialized",
-      mcpServerInitFailure: "_kiro.dev/mcp/server_init_failure",
-      commandsAvailable: "_kiro.dev/commands/available",
-      mcpOauthRequest: "_kiro.dev/mcp/oauth_request",
-      compactionStatus: "_kiro.dev/compaction/status"
+      requestPermission: "session/request_permission",
+      compact: "_kiro/session/compact"
     };
+    KIRO_AGENT_NOT_FOUND = "_kiro/customAgent/not_found";
   }
 });
 
@@ -759,7 +754,7 @@ function foldSessionUpdate(draft, u, seq, ts) {
   }
   if (u.sessionUpdate === "tool_call") {
     const tc = u;
-    const toolName = tc._meta?.kiro?.toolName;
+    const toolName = kiroToolName(tc);
     return {
       items: [
         ...commitDraft(draft, `s-${seq}`, ts),
@@ -801,6 +796,7 @@ var emptyDraft;
 var init_turnFold = __esm({
   "shared/dist/turnFold.js"() {
     "use strict";
+    init_acp();
     emptyDraft = () => ({ items: [], streamingText: "", streamingThought: "" });
   }
 });
@@ -831,10 +827,15 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 function invalidateAgents() {
   cache = null;
+  liveModes = null;
+}
+function rememberModes(modes) {
+  if (modes.length > 0) liveModes = modes;
 }
 async function listAgents() {
+  if (liveModes) return liveModes;
   if (cache && Date.now() - cache.at < CACHE_TTL_MS) return cache.agents;
-  const found = /* @__PURE__ */ new Map();
+  const found = /* @__PURE__ */ new Map([[DEFAULT_MODE.id, DEFAULT_MODE]]);
   try {
     const { stdout, stderr } = await execFileAsync(config.kiroBin, ["agent", "list"], {
       cwd: config.defaultCwd,
@@ -843,30 +844,26 @@ async function listAgents() {
     const text2 = (stderr || "") + "\n" + (stdout || "");
     for (const rawLine of text2.split("\n")) {
       const line = rawLine.replace(ANSI, "");
-      const m = /^\s{0,2}(\*\s)?([A-Za-z0-9_-]+)\s{2,}(\(Built-in\)|Global|Workspace|Local)(?:\s|$)/.exec(
-        line
-      );
+      const m = /^\s{0,2}(\*\s)?([A-Za-z0-9_-]+)\s{2,}(Global|Workspace|Local)(?:\s|$)/.exec(line);
       if (!m) continue;
       const id = m[2];
       if (!found.has(id)) found.set(id, { id, name: id });
     }
   } catch {
   }
-  const agents = found.size > 0 ? [...found.values()] : FALLBACK;
-  cache = { at: Date.now(), agents };
+  cache = { at: Date.now(), agents: [...found.values()] };
   return cache.agents;
 }
-var execFileAsync, FALLBACK, CACHE_TTL_MS, cache, ANSI;
+var execFileAsync, DEFAULT_MODE, CACHE_TTL_MS, cache, liveModes, ANSI;
 var init_agents = __esm({
   "server/src/session/agents.ts"() {
     "use strict";
     init_config();
     execFileAsync = promisify(execFile);
-    FALLBACK = [
-      { id: "kiro_default", name: "kiro_default", description: "General-purpose Kiro agent" }
-    ];
+    DEFAULT_MODE = { id: "vibe", name: "Default", description: "General coding assistance" };
     CACHE_TTL_MS = 15e3;
     cache = null;
+    liveModes = null;
     ANSI = /\x1b\[[0-9;]*m/g;
   }
 });
@@ -1072,6 +1069,10 @@ var init_AcpClient = __esm({
         if (this.closed) return;
         this.write({ jsonrpc: "2.0", id, result });
       }
+      respondError(id, code, message) {
+        if (this.closed) return;
+        this.write({ jsonrpc: "2.0", id, error: { code, message } });
+      }
       write(msg) {
         this.writable.write(JSON.stringify(msg) + "\n");
       }
@@ -1093,7 +1094,12 @@ var init_AcpClient = __esm({
 import { spawn } from "node:child_process";
 import { EventEmitter as EventEmitter3 } from "node:events";
 import split22 from "split2";
-var STDERR_KEEP, KiroProcess;
+function permissionOutcome(params) {
+  const options = params?.options ?? [];
+  const pick = options.find((o) => o.kind === "allow_once") ?? options.find((o) => o.kind === "reject_once");
+  return pick ? { outcome: { outcome: "selected", optionId: pick.optionId } } : { outcome: { outcome: "cancelled" } };
+}
+var STDERR_KEEP, COMPACT_TIMEOUT_MS, KiroProcess;
 var init_KiroProcess = __esm({
   "server/src/session/KiroProcess.ts"() {
     "use strict";
@@ -1101,18 +1107,19 @@ var init_KiroProcess = __esm({
     init_config();
     init_AcpClient();
     STDERR_KEEP = 8;
+    COMPACT_TIMEOUT_MS = 10 * 6e4;
     KiroProcess = class extends EventEmitter3 {
       client;
       child;
       log;
       disposed = false;
       recentStderr = [];
+      // kiro's optional methods, as advertised by initialize.
+      extensionMethods = /* @__PURE__ */ new Set();
       constructor(opts, log) {
         super();
         this.log = log;
-        const args = ["acp", "--trust-all-tools"];
-        if (opts.agent) args.push("--agent", opts.agent);
-        if (opts.model) args.push("--model", opts.model);
+        const args = ["acp", "--agent-engine", "v3"];
         this.log.info({ bin: config.kiroBin, args, cwd: opts.cwd }, "spawning kiro-cli acp");
         this.child = spawn(config.kiroBin, args, {
           cwd: opts.cwd,
@@ -1124,8 +1131,12 @@ var init_KiroProcess = __esm({
           this.emit("notification", n);
         });
         this.client.on("serverRequest", (req) => {
-          this.log.debug({ method: req.method }, "acp: unhandled server request");
-          this.client.respond(req.id, {});
+          if (req.method === ACP_METHODS.requestPermission) {
+            this.client.respond(req.id, permissionOutcome(req.params));
+            return;
+          }
+          this.log.debug({ method: req.method }, "acp: unsupported request from kiro");
+          this.client.respondError(req.id, -32601, `Method not found: ${req.method}`);
         });
         const stderrLines = this.child.stderr.pipe(split22());
         stderrLines.on("data", (line) => {
@@ -1157,9 +1168,9 @@ var init_KiroProcess = __esm({
         this.child.stdout.on("error", () => {
         });
       }
-      /** The ACP initialize handshake. kiro's reply is not used. */
+      /** The ACP initialize handshake. Keeps the optional methods kiro advertises. */
       async initialize() {
-        await this.client.request(ACP_METHODS.initialize, {
+        const res = await this.client.request(ACP_METHODS.initialize, {
           protocolVersion: 1,
           clientCapabilities: {
             fs: { readTextFile: false, writeTextFile: false },
@@ -1167,6 +1178,10 @@ var init_KiroProcess = __esm({
           },
           clientInfo: { name: "casper", version: "0.5.0" }
         });
+        const methods = res?.agentCapabilities?._meta?.kiro?.extensionMethods;
+        this.extensionMethods = new Set(
+          Array.isArray(methods) ? methods.filter((m) => typeof m === "string") : []
+        );
       }
       newSession(params) {
         return this.client.request(ACP_METHODS.sessionNew, params);
@@ -1189,14 +1204,19 @@ var init_KiroProcess = __esm({
         return this.client.request(ACP_METHODS.sessionSetMode, { sessionId, modeId });
       }
       setModel(sessionId, modelId) {
-        return this.client.request(ACP_METHODS.sessionSetModel, { sessionId, modelId });
-      }
-      execCommand(sessionId, command) {
-        return this.client.request(ACP_METHODS.commandsExecute, {
+        return this.client.request(ACP_METHODS.sessionSetConfigOption, {
           sessionId,
-          command: { command: command.replace(/^\//, ""), args: {} }
+          configId: "model",
+          value: modelId
         });
       }
+      /** Summarises the conversation so far. Resolves once kiro has finished. */
+      compact(sessionId) {
+        if (!this.extensionMethods.has(ACP_METHODS.compact)) {
+          return Promise.reject(new Error("This kiro-cli does not offer compaction"));
+        }
+        return this.client.request(ACP_METHODS.compact, { sessionId }, COMPACT_TIMEOUT_MS);
+      }
       /** Recent stderr from kiro, for attaching to a failure. */
       stderrTail() {
         return this.recentStderr.join("\n").trim();
@@ -1418,287 +1438,383 @@ 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];
+      constructor(now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+        this.now = now;
+      }
+      byId = /* @__PURE__ */ new Map();
+      /** The tool call that starts a subagent arrived. */
+      started(subagentId, toolCallId, name) {
+        if (this.byId.has(subagentId)) return false;
+        const at = this.now();
+        this.byId.set(subagentId, {
+          sessionId: subagentId,
+          stageName: name,
+          toolCallId,
+          status: "working",
+          createdAt: at,
+          updatedAt: at
+        });
+        return true;
+      }
+      /** One of the subagent's own updates arrived. `activity` is the title of a tool call it
+       *  started, which becomes the row's "what it is doing now". */
+      progressed(subagentId, activity) {
+        const s = this.byId.get(subagentId);
+        if (!s || s.status !== "working") return false;
+        s.updatedAt = this.now();
+        if (!activity || activity === s.activity) return false;
+        s.activity = activity;
+        return true;
+      }
+      /** The call that started a subagent finished. */
+      finished(toolCallId, ok2) {
+        for (const s of this.byId.values()) {
+          if (s.toolCallId !== toolCallId || s.status !== "working") continue;
+          s.status = ok2 ? "completed" : "failed";
+          s.activity = void 0;
+          s.updatedAt = this.now();
+          return true;
         }
-        return void 0;
+        return false;
       }
-      /** 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
-          });
+      /** Called when the parent turn ends. The turn waits on its subagents, so any still
+       *  working was stopped with it, and kiro does not always report that. */
+      turnEnded() {
+        let changed = false;
+        for (const s of this.byId.values()) {
+          if (s.status !== "working") continue;
+          s.status = "failed";
+          s.activity = "Stopped";
+          s.updatedAt = this.now();
+          changed = true;
         }
-        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];
+        return changed;
       }
+      /** Copies, so a recorded event keeps the state it was recorded with. */
       list() {
-        return [...this.byChild.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        return [...this.byId.values()].map((s) => ({ ...s })).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
       }
-      get(sessionId) {
-        return this.byChild.get(sessionId);
+      get(subagentId) {
+        const s = this.byId.get(subagentId);
+        return s && { ...s };
       }
     };
   }
 });
 
-// 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
+// server/src/session/kiroV3Files.ts
 import fs9 from "node:fs/promises";
 import path10 from "node:path";
-function isContentBlock(v) {
-  return isRecord(v) && typeof v.kind === "string";
-}
-function toolUseData(b) {
-  if (b.kind !== "toolUse" || !isRecord(b.data)) return null;
-  const { toolUseId, name, input } = b.data;
-  if (typeof toolUseId !== "string") return null;
-  return { toolUseId, name: typeof name === "string" ? name : void 0, input };
-}
-function toolResultData(b) {
-  if (b.kind !== "toolResult" || !isRecord(b.data)) return null;
-  const { toolUseId, status, content } = b.data;
-  if (typeof toolUseId !== "string") return null;
-  return { toolUseId, status: typeof status === "string" ? status : void 0, content };
-}
-function contentBlocks(content) {
-  return Array.isArray(content) ? content.filter(isContentBlock) : [];
-}
-function blockText(c) {
-  if (typeof c.data === "string") return c.data;
-  if (isRecord(c.data) && typeof c.data.text === "string") return c.data.text;
-  return "";
+function iso(value) {
+  if (!value) return void 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? value : new Date(ms).toISOString();
 }
-function renderableBlocks(content) {
-  return contentBlocks(content).filter((b) => b.kind !== "image");
+async function workspaceDirs() {
+  const root = config.kiroSessionsDir;
+  try {
+    const entries = await fs9.readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== V2_STORE).map((e) => path10.join(root, e.name));
+  } catch {
+    return [];
+  }
 }
-function summarize(j) {
-  const state = j.session_state;
-  const turns = state?.conversation_metadata?.user_turn_metadatas ?? [];
-  const contextUsagePercentage = state?.rts_model_state?.context_usage_percentage ?? turns[turns.length - 1]?.context_usage_percentage;
-  return {
-    sessionId: j.session_id,
-    title: j.title?.trim() ?? "",
-    cwd: j.cwd,
-    createdAt: j.created_at,
-    updatedAt: j.updated_at,
-    agentId: state?.agent_name,
-    modelId: state?.rts_model_state?.model_info?.model_id,
-    contextUsagePercentage
-  };
+async function v3SessionDirs() {
+  const out = /* @__PURE__ */ new Map();
+  await Promise.all(
+    (await workspaceDirs()).map(async (dir) => {
+      try {
+        for (const e of await fs9.readdir(dir, { withFileTypes: true })) {
+          if (e.isDirectory() && !e.name.startsWith(".") && isValidSessionId(e.name)) {
+            out.set(e.name, path10.join(dir, e.name));
+          }
+        }
+      } catch {
+      }
+    })
+  );
+  return out;
 }
-async function deletePersistedSession(sessionId) {
-  if (!isValidSessionId(sessionId)) return;
-  const targets = [
-    path10.join(config.kiroSessionsDir, `${sessionId}.json`),
-    path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
-    path10.join(config.kiroSessionsDir, `${sessionId}.history`),
-    path10.join(config.kiroSessionsDir, `${sessionId}.lock`),
-    path10.join(config.kiroSessionsDir, sessionId)
-  ];
-  await Promise.all(targets.map((f) => fs9.rm(f, { recursive: true, force: true })));
+async function v3SessionDir(sessionId) {
+  if (!isValidSessionId(sessionId)) return void 0;
+  const found = await Promise.all(
+    (await workspaceDirs()).map(async (dir) => {
+      const candidate = path10.join(dir, sessionId);
+      try {
+        await fs9.access(path10.join(candidate, "session.json"));
+        return candidate;
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return found.find((d) => d !== void 0);
 }
-async function readPersistedSession(sessionId) {
-  if (!isValidSessionId(sessionId)) return null;
+function contextUsageOf(line) {
+  if (!line.includes('"contextUsage"')) return void 0;
   try {
-    const raw = await fs9.readFile(
-      path10.join(config.kiroSessionsDir, `${sessionId}.json`),
-      "utf8"
-    );
-    return summarize(JSON.parse(raw));
+    const p = JSON.parse(line).payload;
+    const value = isRecord(p.value) ? p.value.usagePercentage : void 0;
+    return p.type === "session_metadata" && p.key === "contextUsage" && typeof value === "number" ? value : void 0;
   } catch {
-    return null;
+    return void 0;
   }
 }
-async function withLastWrite(child) {
+async function lastContextUsage(file) {
+  let handle2;
   try {
-    const st = await fs9.stat(path10.join(config.kiroSessionsDir, `${child.sessionId}.jsonl`));
-    const mtime = st.mtime.toISOString();
-    return mtime > child.updatedAt ? { ...child, updatedAt: mtime } : child;
+    handle2 = await fs9.open(file, "r");
   } catch {
-    return child;
+    return void 0;
   }
-}
-async function readChildSession(childSessionId, parentSessionId) {
-  if (!isValidSessionId(childSessionId)) return null;
   try {
-    const raw = await fs9.readFile(path10.join(config.kiroSessionsDir, `${childSessionId}.json`), "utf8");
-    const j = JSON.parse(raw);
-    return j.parent_session_id === parentSessionId ? await withLastWrite({ ...summarize(j), parentSessionId }) : null;
-  } catch {
-    return null;
+    const { size } = await handle2.stat();
+    let end = size;
+    let tail = "";
+    while (end > 0 && size - end < CONTEXT_TAIL_BYTES) {
+      const start = Math.max(0, end - CONTEXT_CHUNK_BYTES);
+      const buf = Buffer.alloc(end - start);
+      await handle2.read(buf, 0, buf.length, start);
+      end = start;
+      const lines = (buf.toString("utf8") + tail).split("\n");
+      tail = end > 0 ? lines.shift() : "";
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const value = contextUsageOf(lines[i]);
+        if (value !== void 0) return value;
+      }
+    }
+    return tail ? contextUsageOf(tail) : void 0;
+  } finally {
+    await handle2.close();
   }
 }
-async function listChildSessions(parentSessionId) {
-  if (!isValidSessionId(parentSessionId)) return [];
-  let names;
+async function readV3Session(dir) {
+  let j;
   try {
-    names = await fs9.readdir(config.kiroSessionsDir);
+    j = JSON.parse(await fs9.readFile(path10.join(dir, "session.json"), "utf8"));
   } catch {
-    return [];
+    return null;
   }
-  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(await withLastWrite({ ...summarize(j), parentSessionId }));
-        }
-      } catch {
-      }
-    })
-  );
-  return out;
-}
-async function promptCount(sessionId) {
-  const entries = await readJsonlEntries(sessionId);
-  return entries.filter((e) => e.kind === "Prompt").length;
+  const title = j.title?.trim() ?? "";
+  const createdAt = iso(j.createdAt) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  return {
+    sessionId: j.id,
+    title: title === PLACEHOLDER_TITLE ? "" : title,
+    cwd: j.workspacePaths?.[0] ?? "",
+    createdAt,
+    updatedAt: iso(j.lastModifiedAt) ?? createdAt,
+    agentId: j.agentMode,
+    modelId: j.modelId,
+    contextUsagePercentage: await lastContextUsage(path10.join(dir, "messages.jsonl"))
+  };
 }
-async function readJsonlEntries(sessionId) {
-  if (!isValidSessionId(sessionId)) return [];
+async function readLines(file, filter) {
   let raw;
   try {
-    raw = await fs9.readFile(path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`), "utf8");
+    raw = await fs9.readFile(file, "utf8");
   } catch {
     return [];
   }
-  const entries = [];
+  const out = [];
   for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
+    if (!line.trim() || filter && !line.includes(filter)) continue;
     try {
-      entries.push(JSON.parse(trimmed));
+      const parsed = JSON.parse(line);
+      if (isRecord(parsed) && isRecord(parsed.payload) && typeof parsed.id === "string") out.push(parsed);
     } catch {
     }
   }
-  return entries;
+  return out;
 }
-async function hasRecordedTurns(sessionId) {
-  if (!isValidSessionId(sessionId)) return false;
-  try {
-    const st = await fs9.stat(path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`));
-    return st.size > 0;
-  } catch {
-    return false;
+function userText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => isRecord(b) && b.type === "text" && typeof b.text === "string" ? b.text : "").join("");
+}
+function resultBlocks(content) {
+  if (typeof content === "string") return content ? [{ type: "text", text: content }] : [];
+  if (Array.isArray(content)) return content.filter((b) => !(isRecord(b) && b.type === "image"));
+  return isRecord(content) ? [{ kind: "json", data: content }] : [];
+}
+function isCompactionCopy(id, seen) {
+  if (!id.startsWith("compact_")) return false;
+  const rest = id.slice("compact_".length);
+  const sep = rest.indexOf("_");
+  return sep >= 0 && seen.has(rest.slice(sep + 1));
+}
+async function readV3Entries(file) {
+  const out = [];
+  const toolsById = /* @__PURE__ */ new Map();
+  const addTool = (tool) => {
+    const seen2 = toolsById.get(tool.id);
+    if (seen2) {
+      Object.assign(seen2, { ...tool, content: seen2.content, output: seen2.output ?? tool.output });
+      return;
+    }
+    toolsById.set(tool.id, tool);
+    out.push({ kind: "item", item: { type: "tool_call", tool } });
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of await readLines(file)) {
+    const copy = isCompactionCopy(line.id, seen);
+    seen.add(line.id);
+    if (copy) continue;
+    const p = line.payload;
+    const parsed = line.timestamp ? Date.parse(line.timestamp) : NaN;
+    const at = Number.isNaN(parsed) ? void 0 : parsed;
+    switch (p.type) {
+      case "user":
+        out.push({ kind: "prompt", id: line.id, text: userText(p.content), atMs: at, timestamp: at });
+        break;
+      case "assistant": {
+        const text2 = str2(p.content) ?? "";
+        if (!text2.trim()) break;
+        if (p.operationType === "Summary") {
+          out.push({ kind: "item", item: { type: "compaction", id: `c-${line.id}`, summary: text2, timestamp: at } });
+        } else if (p.operationType === "Reasoning") {
+          if (text2.trim() !== HIDDEN_REASONING) {
+            out.push({ kind: "item", item: { type: "message", message: { id: `t-${line.id}`, role: "thinking", text: text2.trim(), timestamp: at } } });
+          }
+        } else {
+          out.push({ kind: "item", item: { type: "message", message: { id: `a-${line.id}`, role: "assistant", text: text2, timestamp: at } } });
+        }
+        break;
+      }
+      case "tool_call": {
+        const id = str2(p.toolCallId);
+        if (!id) break;
+        const title = str2(p.title);
+        const meta = isRecord(p._meta) ? p._meta : void 0;
+        const args = p.args;
+        const input = p.toolName === "tool_call" && isRecord(args) && "arguments" in args ? args.arguments : args;
+        addTool({
+          id,
+          // A call kiro copied in from a kiro 2.x session has no kind, only 2.x's tool name,
+          // which the web renders by.
+          name: kiroToolName({ title, _meta: meta }) ?? (p.kind === void 0 ? str2(p.toolName) : void 0),
+          title: title ?? str2(p.toolName) ?? id,
+          kind: str2(p.kind),
+          status: p.status === "failed" ? "failed" : "completed",
+          input,
+          content: []
+        });
+        break;
+      }
+      case "tool_result": {
+        const tool = toolsById.get(str2(p.toolCallId) ?? "");
+        if (!tool) break;
+        tool.status = p.success === false ? "failed" : "completed";
+        tool.content = resultBlocks(p.content);
+        break;
+      }
+      case "sub_agent_start": {
+        const name = str2(p.subAgentName) ?? "subagent";
+        addTool({
+          id: line.id.endsWith(START_SUFFIX) ? line.id.slice(0, -START_SUFFIX.length) : line.id,
+          name: SUBAGENT_TOOL,
+          title: `Sub-agent: ${name}`,
+          kind: "other",
+          // Without a result the parent turn ended while the subagent ran.
+          status: "failed",
+          input: { name, prompt: str2(p.prompt), explanation: str2(p.explanation) },
+          content: []
+        });
+        break;
+      }
+      case "sub_agent_complete": {
+        const tool = toolsById.get(line.id.endsWith(COMPLETE_SUFFIX) ? line.id.slice(0, -COMPLETE_SUFFIX.length) : "");
+        if (!tool) break;
+        tool.status = p.status === "success" ? "completed" : "failed";
+        tool.output = str2(p.response);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+async function readSubExecutions(dir) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const line of await readLines(path10.join(dir, "messages.jsonl"), '"sub_agent_')) {
+    const p = line.payload;
+    const subId = str2(p.subSessionId);
+    if (!subId) continue;
+    const at = iso(line.timestamp) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    if (p.type === "sub_agent_start") {
+      byId.set(subId, {
+        sessionId: subId,
+        name: str2(p.subAgentName) ?? subId,
+        toolCallId: line.id.endsWith(START_SUFFIX) ? line.id.slice(0, -START_SUFFIX.length) : line.id,
+        status: "failed",
+        stopped: true,
+        createdAt: at,
+        updatedAt: at
+      });
+    } else if (p.type === "sub_agent_complete") {
+      const sub = byId.get(subId);
+      if (!sub) continue;
+      sub.status = p.status === "success" ? "completed" : "failed";
+      sub.stopped = false;
+      sub.updatedAt = at;
+    }
   }
+  return [...byId.values()];
+}
+function subExecutionFile(dir, subagentId) {
+  return isValidSessionId(subagentId) ? path10.join(dir, "sub-executions", `${subagentId}.jsonl`) : void 0;
+}
+var PLACEHOLDER_TITLE, HIDDEN_REASONING, CONTEXT_TAIL_BYTES, CONTEXT_CHUNK_BYTES, isRecord, str2, V2_STORE, START_SUFFIX, COMPLETE_SUFFIX;
+var init_kiroV3Files = __esm({
+  "server/src/session/kiroV3Files.ts"() {
+    "use strict";
+    init_dist();
+    init_config();
+    init_paths2();
+    PLACEHOLDER_TITLE = "New Session";
+    HIDDEN_REASONING = "...";
+    CONTEXT_TAIL_BYTES = 1024 * 1024;
+    CONTEXT_CHUNK_BYTES = 16 * 1024;
+    isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    str2 = (v) => typeof v === "string" ? v : void 0;
+    V2_STORE = "cli";
+    START_SUFFIX = "-sub-agent-start";
+    COMPLETE_SUFFIX = "-sub-agent-complete";
+  }
+});
+
+// server/src/session/kiroFiles.ts
+import fs10 from "node:fs/promises";
+import path11 from "node:path";
+async function readPersistedSession(sessionId) {
+  const dir = await v3SessionDir(sessionId);
+  return dir ? readV3Session(dir) : null;
+}
+async function readPersistedSessions(sessionIds) {
+  const dirs = await v3SessionDirs();
+  const out = /* @__PURE__ */ new Map();
+  await Promise.all(
+    sessionIds.filter(isValidSessionId).map(async (id) => {
+      const dir = dirs.get(id);
+      const found = dir ? await readV3Session(dir) : null;
+      if (found) out.set(id, found);
+    })
+  );
+  return out;
+}
+async function deletePersistedSession(sessionId) {
+  const dir = await v3SessionDir(sessionId);
+  if (dir) await fs10.rm(dir, { recursive: true, force: true });
+}
+async function isLoadable(sessionId) {
+  return await v3SessionDir(sessionId) !== void 0;
+}
+async function readEntries(sessionId) {
+  const dir = await v3SessionDir(sessionId);
+  return dir ? readV3Entries(path11.join(dir, "messages.jsonl")) : [];
+}
+async function promptCount(sessionId) {
+  return (await readEntries(sessionId)).filter((e) => e.kind === "prompt").length;
 }
 function endingItems(e) {
   const prefix = `te${e.id}-`;
@@ -1710,93 +1826,71 @@ function endingItems(e) {
   );
   return items;
 }
-async function hydrateTranscript(sessionId, attachments, endings = []) {
+function mergeTranscript(entries, attachments, endings) {
   const items = [];
   let userOrdinal = 0;
-  const toolsById = /* @__PURE__ */ new Map();
   const waiting = [...endings];
   let replaced = false;
   const unrecorded = (e) => [
     { type: "message", message: { id: `te${e.id}-u`, role: "user", text: e.prompt, timestamp: e.startedAt } },
     ...endingItems(e)
   ];
-  for (const entry of await readJsonlEntries(sessionId)) {
-    const content = contentBlocks(entry.data.content);
-    const textOf = (kind) => content.filter((c) => c.kind === kind).map(blockText).join("");
-    const baseId = entry.data.message_id ?? `${items.length}`;
-    const ts = entry.data.meta?.timestamp;
-    const pushMsg = (msg) => items.push({ type: "message", message: msg });
-    if (entry.kind === "Prompt") {
-      replaced = false;
-      const text2 = stripAttachmentsLine(textOf("text"));
-      let matched;
-      if (ts !== void 0) {
-        const at = ts * 1e3;
-        matched = waiting.find(
-          (e) => e.prompt.trim() === text2.trim() && at >= e.startedAt - STAMP_PAD_MS && at <= e.endedAt + STAMP_PAD_MS
-        );
-        while (waiting.length && waiting[0] !== matched && waiting[0].endedAt < at - STAMP_PAD_MS) {
-          items.push(...unrecorded(waiting.shift()));
-        }
-        if (matched) waiting.splice(waiting.indexOf(matched), 1);
-      }
-      const attached = attachments?.get(userOrdinal);
-      userOrdinal++;
-      if (text2.trim() || attached?.length)
-        pushMsg({ id: `u-${baseId}`, role: "user", text: text2, timestamp: ts, attachments: attached });
-      if (matched) {
-        items.push(...endingItems(matched));
-        replaced = true;
-      }
-    } else if (entry.kind === "AssistantMessage") {
-      if (replaced) continue;
-      const thinking = textOf("thinking");
-      if (thinking.trim())
-        pushMsg({ id: `t-${baseId}`, role: "thinking", text: thinking.trim(), timestamp: ts });
-      const text2 = textOf("text");
-      if (text2.trim())
-        pushMsg({ id: `a-${baseId}`, role: "assistant", text: text2, timestamp: ts });
-      for (const c of content) {
-        const d = toolUseData(c);
-        if (!d) continue;
-        const tool = {
-          id: d.toolUseId,
-          name: d.name,
-          title: d.name ?? d.toolUseId,
-          status: "completed",
-          input: d.input,
-          content: []
-        };
-        toolsById.set(d.toolUseId, tool);
-        items.push({ type: "tool_call", tool });
-      }
-    } else if (entry.kind === "ToolResults") {
-      if (replaced) continue;
-      for (const c of content) {
-        const d = toolResultData(c);
-        if (!d) continue;
-        const tool = toolsById.get(d.toolUseId);
-        if (!tool) continue;
-        tool.status = d.status === "error" ? "failed" : "completed";
-        tool.content = renderableBlocks(d.content);
+  for (const entry of entries) {
+    if (entry.kind === "item") {
+      if (!replaced || entry.item.type === "compaction") items.push(entry.item);
+      continue;
+    }
+    replaced = false;
+    const text2 = stripAttachmentsLine(entry.text);
+    let matched;
+    const at = entry.atMs;
+    if (at !== void 0) {
+      matched = waiting.find(
+        (e) => e.prompt.trim() === text2.trim() && at >= e.startedAt - STAMP_PAD_MS && at <= e.endedAt + STAMP_PAD_MS
+      );
+      while (waiting.length && waiting[0] !== matched && waiting[0].endedAt < at - STAMP_PAD_MS) {
+        items.push(...unrecorded(waiting.shift()));
       }
-    } else if (entry.kind === "Compaction") {
-      const summary = entry.data.summary ?? "";
-      if (summary.trim())
-        items.push({ type: "compaction", id: `c-${baseId}`, summary, timestamp: ts });
+      if (matched) waiting.splice(waiting.indexOf(matched), 1);
+    }
+    const attached = attachments?.get(userOrdinal);
+    userOrdinal++;
+    if (text2.trim() || attached?.length) {
+      items.push({ type: "message", message: { id: `u-${entry.id}`, role: "user", text: text2, timestamp: entry.timestamp, attachments: attached } });
+    }
+    if (matched) {
+      items.push(...endingItems(matched));
+      replaced = true;
     }
   }
   for (const e of waiting) items.push(...unrecorded(e));
   return items;
 }
-var isRecord, STAMP_PAD_MS;
+async function hydrateTranscript(sessionId, attachments, endings = []) {
+  return mergeTranscript(await readEntries(sessionId), attachments, endings);
+}
+async function listSubExecutions(sessionId) {
+  const dir = await v3SessionDir(sessionId);
+  return dir ? readSubExecutions(dir) : null;
+}
+async function hydrateSubExecution(sessionId, subagentId) {
+  const dir = await v3SessionDir(sessionId);
+  const file = dir ? subExecutionFile(dir, subagentId) : void 0;
+  if (!file) return null;
+  try {
+    await fs10.access(file);
+  } catch {
+    return null;
+  }
+  return mergeTranscript(await readV3Entries(file), void 0, []);
+}
+var STAMP_PAD_MS;
 var init_kiroFiles = __esm({
   "server/src/session/kiroFiles.ts"() {
     "use strict";
     init_dist();
-    init_config();
     init_paths2();
-    isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    init_kiroV3Files();
     STAMP_PAD_MS = 2e3;
   }
 });
@@ -1918,50 +2012,18 @@ 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";
+import fs11 from "node:fs";
+import path12 from "node:path";
 function resolveCwd(input) {
   const raw = input?.trim();
-  const abs = raw ? path11.resolve(config.defaultCwd, raw) : config.defaultCwd;
+  const abs = raw ? path12.resolve(config.defaultCwd, raw) : config.defaultCwd;
   if (!isWithinRoot(config.fileRoot, abs)) {
     throw new Error(`Working directory is outside the allowed root: ${abs}`);
   }
   let stat;
   try {
-    stat = fs10.statSync(abs);
+    stat = fs11.statSync(abs);
   } catch {
     stat = void 0;
   }
@@ -1969,37 +2031,44 @@ function resolveCwd(input) {
     throw new Error(`Working directory path is a file, not a directory: ${abs}`);
   }
   if (!stat) {
-    fs10.mkdirSync(abs, { recursive: true });
+    fs11.mkdirSync(abs, { recursive: true });
   }
   return abs;
 }
-function mapNotification(n) {
-  switch (n.method) {
-    case "session/update":
-      return { kind: "session_update", update: n.params.update };
-    case KIRO_NOTIFICATIONS.metadata:
-      return { kind: "metadata", params: n.params };
-    case KIRO_NOTIFICATIONS.compactionStatus:
-      return { kind: "compaction", params: n.params };
+function kiroMeta(update) {
+  return update._meta?.kiro;
+}
+function sessionInfoEvent(sessionId, update) {
+  const info = update._meta?.kiro;
+  switch (info?.kind) {
+    case "context_usage":
+      return typeof info.usagePercentage === "number" ? { kind: "metadata", params: { sessionId, contextUsagePercentage: info.usagePercentage } } : null;
+    case "summarization_started":
+      return { kind: "compaction", params: { sessionId, status: { type: "started" }, summary: null } };
+    case "summarization_completed":
+      return {
+        kind: "compaction",
+        params: { sessionId, status: { type: "completed" }, summary: info.conversationSummary ?? null }
+      };
+    case "summarization_failed":
+      return { kind: "compaction", params: { sessionId, status: { type: "failed" }, summary: null } };
     default:
       return null;
   }
 }
-function notificationSessionId(n) {
-  const params = n.params;
-  return params?.sessionId;
+function sessionModel(res) {
+  return res.configOptions?.find((o) => o.id === "model")?.currentValue;
 }
-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 subExecutionSummary(sub) {
+  return {
+    sessionId: sub.sessionId,
+    stageName: sub.name,
+    toolCallId: sub.toolCallId,
+    status: sub.status,
+    activity: sub.stopped ? "Stopped" : void 0,
+    createdAt: sub.createdAt,
+    updatedAt: sub.updatedAt
+  };
 }
 function newerOf(a, b) {
   return a && a.localeCompare(b) > 0 ? a : b;
@@ -2011,7 +2080,7 @@ function firstPromptText(transcript) {
 function isGhost(s, hasFile) {
   return !hasFile && s.hasBeenLive && !s.proc;
 }
-var CANCEL_GRACE_MS, Session, TRANSCRIPT_PAGE_SIZE, SessionManager;
+var CANCEL_GRACE_MS, Session, TRANSCRIPT_UPDATES, TRANSCRIPT_PAGE_SIZE, SessionManager;
 var init_SessionManager = __esm({
   "server/src/session/SessionManager.ts"() {
     "use strict";
@@ -2025,11 +2094,8 @@ var init_SessionManager = __esm({
     init_TurnState();
     init_TurnRecorder();
     init_SubagentTracker();
-    init_subagentResult();
-    init_subagentFallbackMatch();
     init_kiroFiles();
     init_chatStore();
-    init_subagentLinks();
     CANCEL_GRACE_MS = 1e4;
     Session = class {
       sessionId;
@@ -2078,21 +2144,20 @@ var init_SessionManager = __esm({
         return event;
       }
     };
+    TRANSCRIPT_UPDATES = /* @__PURE__ */ new Set(["agent_message_chunk", "agent_thought_chunk", "tool_call", "tool_call_update"]);
     TRANSCRIPT_PAGE_SIZE = 80;
     SessionManager = class {
       sessions = /* @__PURE__ */ new Map();
       log;
       store = new ChatStore();
-      subagentLinks = new SubagentLinkStore();
-      // Children the title fallback already tried and could not match. Matching hydrates the
-      // whole parent transcript (145 MB in one chat), so each child is tried once per process.
-      unmatchedChildren = /* @__PURE__ */ new Map();
       spawnProcess;
       cancelGraceMs;
+      defaultModel;
       constructor(log, opts = {}) {
         this.log = log;
         this.spawnProcess = opts.spawn ?? ((o, l) => new KiroProcess(o, l));
         this.cancelGraceMs = opts.cancelGraceMs ?? CANCEL_GRACE_MS;
+        this.defaultModel = opts.defaultModel ?? (async () => void 0);
       }
       /** What a session is called, from every read path. */
       titleOf(chat, parts) {
@@ -2100,7 +2165,7 @@ var init_SessionManager = __esm({
           override: chat.title ?? void 0,
           kiroTitle: parts.kiroTitle,
           firstPrompt: parts.firstPrompt,
-          folder: isManagedWorkspace(parts.cwd) ? void 0 : path11.basename(parts.cwd)
+          folder: isManagedWorkspace(parts.cwd) ? void 0 : path12.basename(parts.cwd)
         });
       }
       renameChat(chatId, title) {
@@ -2158,7 +2223,7 @@ var init_SessionManager = __esm({
       }
       /** The reload itself, called with the session's reload claim held. */
       async replaceProcess(chatId, s) {
-        if (!await hasRecordedTurns(s.sessionId)) {
+        if (!await isLoadable(s.sessionId)) {
           throw new Error(
             "kiro has not saved this session yet. Send a message first, then reload."
           );
@@ -2172,9 +2237,9 @@ var init_SessionManager = __esm({
           });
         }
         s.availableModes = [];
+        invalidateAgents();
         await this.ensureProc(s);
         s.lastActivity = Date.now();
-        invalidateAgents();
         this.log.info({ sessionId: s.sessionId, cwd: s.cwd }, "session reloaded");
         return this.getDetail(chatId);
       }
@@ -2229,30 +2294,30 @@ var init_SessionManager = __esm({
       wire(s, proc) {
         proc.on("notification", (n) => {
           if (s.replaying) return;
-          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() });
+          if (n.method === KIRO_AGENT_NOT_FOUND) {
+            this.log.warn({ sessionId: s.sessionId, detail: n.params }, "kiro could not use the requested agent");
             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);
+          if (n.method !== ACP_METHODS.sessionUpdate) return;
+          const params = n.params;
+          if (!params?.update || params.sessionId && params.sessionId !== s.sessionId) return;
+          const { update } = params;
+          const meta = kiroMeta(update);
+          if (meta?.replay) return;
+          if (update.sessionUpdate === "session_info_update") {
+            const payload = sessionInfoEvent(s.sessionId, update);
+            if (payload) s.record(payload);
+            return;
+          }
+          if (!TRANSCRIPT_UPDATES.has(update.sessionUpdate)) return;
+          const subagentId = meta?.agentSubtaskId;
+          if (subagentId && meta.kind !== "agent-subtask") {
+            const title = update.sessionUpdate === "tool_call" ? update.title : void 0;
+            if (s.subagents.progressed(subagentId, title)) this.recordSubagents(s);
             return;
           }
+          if (subagentId) this.trackSubagentCall(s, subagentId, update);
+          s.record({ kind: "session_update", update });
         });
         proc.on("exit", (code, signal) => {
           if (s.proc !== proc) return;
@@ -2261,28 +2326,50 @@ var init_SessionManager = __esm({
           s.running = false;
         });
       }
+      /** Follows the tool call that starts a subagent, from its start to its result. */
+      trackSubagentCall(s, subagentId, update) {
+        const call = update;
+        if (typeof call.toolCallId !== "string") return;
+        let changed = false;
+        if (call.sessionUpdate === "tool_call") {
+          const name = typeof call.rawInput?.name === "string" ? call.rawInput.name : call.title ?? subagentId;
+          changed = s.subagents.started(subagentId, call.toolCallId, name);
+        } else if (call.status === "completed" || call.status === "failed") {
+          changed = s.subagents.finished(call.toolCallId, call.status === "completed");
+        }
+        if (changed) this.recordSubagents(s);
+      }
+      recordSubagents(s) {
+        s.record({ kind: "subagents_changed", subagents: s.subagents.list() });
+      }
       /** Gets or spawns the kiro process for a session. */
       async ensureProc(s) {
         if (s.proc) return s.proc;
         if (s.spawning) return s.spawning;
         s.spawning = (async () => {
           await this.ensureCapacity();
-          const proc = this.spawnProcess(
-            { cwd: s.cwd, agent: s.agentId, model: s.modelId },
-            this.log
-          );
+          const proc = this.spawnProcess({ cwd: s.cwd }, this.log);
           this.wire(s, proc);
           await proc.initialize();
           let res;
           if (s.hasBeenLive) {
             s.replaying = true;
             try {
-              res = await proc.loadSession({ sessionId: s.sessionId, cwd: s.cwd, mcpServers: [] });
+              res = await proc.loadSession({
+                sessionId: s.sessionId,
+                cwd: s.cwd,
+                mcpServers: [],
+                ...s.modelId ? { _meta: { kiro: { modelId: s.modelId } } } : {}
+              });
             } finally {
               s.replaying = false;
             }
           } else {
-            res = await proc.newSession({ cwd: s.cwd, mcpServers: [] });
+            res = await proc.newSession({
+              cwd: s.cwd,
+              mcpServers: [],
+              _meta: { kiro: { modeId: s.agentId, modelId: s.modelId } }
+            });
           }
           if (!s.hasBeenLive && res.sessionId !== s.sessionId) {
             this.sessions.delete(s.sessionId);
@@ -2292,6 +2379,8 @@ var init_SessionManager = __esm({
           s.availableModes = res.modes.availableModes;
           s.currentModeId = res.modes.currentModeId;
           s.agentId = res.modes.currentModeId ?? s.agentId;
+          s.modelId = sessionModel(res) ?? s.modelId;
+          rememberModes(res.modes.availableModes);
           s.markLive();
           s.proc = proc;
           s.spawning = void 0;
@@ -2332,7 +2421,7 @@ var init_SessionManager = __esm({
         const s = new Session(tempId, store, cwd);
         s.agentId = opts.agentId ?? config.defaultAgent;
         s.currentModeId = s.agentId;
-        s.modelId = opts.modelId;
+        s.modelId = opts.modelId ?? await this.defaultModel();
         this.sessions.set(tempId, s);
         try {
           await this.ensureProc(s);
@@ -2342,7 +2431,7 @@ var init_SessionManager = __esm({
         }
         this.store.create(chatId);
         this.store.bindSession(chatId, s.sessionId);
-        const name = sanitizeTitle(opts.title ?? "") || (opts.freshWorkspace ? "" : path11.basename(s.cwd));
+        const name = sanitizeTitle(opts.title ?? "") || (opts.freshWorkspace ? "" : path12.basename(s.cwd));
         if (name) {
           this.store.setTitle(chatId, name);
           s.title = name;
@@ -2400,6 +2489,7 @@ ${tail}` : err.message;
           s.cancelTimer = void 0;
           s.running = false;
           s.lastActivity = Date.now();
+          if (s.subagents.turnEnded()) s.record({ kind: "subagents_changed", subagents: s.subagents.list() });
         });
       }
       saveEnding(chatId, ending) {
@@ -2451,12 +2541,29 @@ ${tail}` : err.message;
         s.modelId = modelId;
         s.lastActivity = Date.now();
       }
+      /** Runs one of kiro's slash commands. Compaction is the only one Casper offers. It
+       *  returns once kiro has started; its progress arrives as compaction events. */
       async execCommand(chatId, command) {
+        if (command.replace(/^\//, "") !== "compact") throw new Error(`Unsupported command: ${command}`);
         const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
+        if (s.turnState.get().compacting) throw new Error("The conversation is already being compacted");
         const proc = await this.ensureProc(s);
-        await proc.execCommand(s.sessionId, command);
         s.lastActivity = Date.now();
+        const status = (type) => ({
+          kind: "compaction",
+          params: { sessionId: s.sessionId, status: { type }, summary: null }
+        });
+        s.record(status("started"));
+        proc.compact(s.sessionId).then(
+          () => {
+            if (s.turnState.get().compacting && s.proc === proc) s.record(status("completed"));
+          },
+          (err) => {
+            this.log.warn({ err, sessionId: s.sessionId }, "compaction failed");
+            if (s.turnState.get().compacting && s.proc === proc) s.record(status("failed"));
+          }
+        );
       }
       /** The one place a ChatSummary is assembled, since kiro's file and Casper's
        *  live state each hold part of the truth. */
@@ -2484,13 +2591,13 @@ ${tail}` : err.message;
       }
       async listChats() {
         const rows = this.store.all();
-        const files = await Promise.all(
-          rows.map((r) => r.sessionId ? readPersistedSession(r.sessionId) : null)
+        const files = await readPersistedSessions(
+          rows.map((r) => r.sessionId).filter((id) => !!id)
         );
         const out = [];
-        rows.forEach((row, i) => {
+        rows.forEach((row) => {
           const live = row.sessionId ? this.sessions.get(row.sessionId) : void 0;
-          const persisted = files[i] ?? void 0;
+          const persisted = row.sessionId ? files.get(row.sessionId) : void 0;
           if (live && isGhost(live, !!persisted)) {
             this.evict(live.sessionId);
             return;
@@ -2533,68 +2640,36 @@ ${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).
-       */
+      /** A chat's subagents: the ones kiro recorded in the session's file, and live ones from
+       *  the tracker. A live row wins over the file's until the file records how it ended. */
       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 tried = this.unmatchedChildren.get(sessionId) ?? /* @__PURE__ */ new Set();
-        const unresolved = onDisk.filter(
-          (c) => !liveIds.has(c.sessionId) && !links.has(c.sessionId) && !tried.has(c.sessionId)
-        );
-        const fallback = unresolved.length ? matchSubagentsFallback(subagentCallsIn(await hydrateTranscript(sessionId)), unresolved) : [];
-        const fallbackByChild = new Map(fallback.map((m) => [m.sessionId, m]));
-        for (const m of fallback) this.subagentLinks.record(m.sessionId, sessionId, m.toolCallId, m.stageName);
-        for (const c of unresolved) if (!fallbackByChild.has(c.sessionId)) tried.add(c.sessionId);
-        this.unmatchedChildren.set(sessionId, tried);
+        const live = this.sessions.get(sessionId)?.subagents.list() ?? [];
         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
-          });
+        const finished = /* @__PURE__ */ new Set();
+        for (const sub of await listSubExecutions(sessionId) ?? []) {
+          byId.set(sub.sessionId, subExecutionSummary(sub));
+          if (!sub.stopped) finished.add(sub.sessionId);
         }
-        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];
+        for (const a of live) if (!finished.has(a.sessionId)) byId.set(a.sessionId, a);
+        return [...byId.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
       }
       /** One subagent's own transcript, hydrated the same way a chat's is. */
-      // Polled while a subagent runs, so it reads only the child's own files.
-      async getSubagentDetail(chatId, childSessionId) {
+      // Polled while a subagent runs, so it reads only the subagent's own files.
+      async getSubagentDetail(chatId, subagentId) {
         const parentSessionId = this.sessionIdOf(chatId);
-        const child = await readChildSession(childSessionId, parentSessionId);
-        if (!child) throw new Error(`Unknown subagent: ${childSessionId}`);
-        const live = this.sessions.get(parentSessionId)?.subagents.list().find((a) => a.sessionId === childSessionId);
-        const link = this.subagentLinks.forParent(parentSessionId).get(childSessionId);
-        const summary = live ?? {
-          sessionId: childSessionId,
-          stageName: link?.stageName ?? (child.title || childSessionId),
-          toolCallId: link?.toolCallId,
-          status: "completed",
-          createdAt: child.createdAt,
-          updatedAt: child.updatedAt
-        };
-        const transcript = showSummaryAsAnswer(await hydrateTranscript(childSessionId));
-        return { subagent: summary, transcript };
+        const live = this.sessions.get(parentSessionId)?.subagents.get(subagentId);
+        const recorded = (await listSubExecutions(parentSessionId))?.find((x) => x.sessionId === subagentId);
+        if (!live && !recorded) throw new Error(`Unknown subagent: ${subagentId}`);
+        const transcript = await hydrateSubExecution(parentSessionId, subagentId) ?? [];
+        const subagent = recorded && (!live || !recorded.stopped) ? subExecutionSummary(recorded) : live;
+        return { subagent, transcript };
       }
       /** One projection, so a dormant session and a live one cannot disagree. */
-      buildDetail(chat, s, transcript, persisted) {
+      buildDetail(chat, s, hydrated, persisted) {
+        const { transcript, head } = this.resumePoint(s, hydrated);
         return {
-          summary: this.summaryOf(chat, s, persisted, transcript),
+          summary: this.summaryOf(chat, s, persisted, hydrated),
           modes: s?.availableModes ?? [],
           currentModeId: s?.currentModeId ?? persisted?.agentId,
           transcript: transcript.slice(-TRANSCRIPT_PAGE_SIZE),
@@ -2603,16 +2678,19 @@ ${tail}` : err.message;
             ...emptyObservabilitySnapshot(),
             contextUsagePercentage: persisted?.contextUsagePercentage ?? 0
           },
-          head: s ? this.replayHead(s, transcript) : 0
+          head
         };
       }
       /**
-       * 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.
+       * Where a reconnecting client picks up: the transcript, and the cursor its events replay
+       * after. A turn in flight replays whole from its turn_started and is left out of the
+       * transcript, since kiro writes the prompt at once but a tool call only once it ends, so
+       * kiro's copy of the turn lacks whatever is still running.
        */
-      replayHead(s, transcript) {
+      resumePoint(s, transcript) {
+        if (!s) return { transcript, head: 0 };
         const head = s.store.head();
-        if (!s.running) return head;
+        if (!s.running) return { transcript, head };
         const { events } = s.store.getSince(0);
         let started;
         for (let i = events.length - 1; i >= 0; i--) {
@@ -2621,18 +2699,19 @@ ${tail}` : err.message;
             break;
           }
         }
-        if (!started || started.payload.kind !== "turn_started") return head;
+        if (!started || started.payload.kind !== "turn_started") return { transcript, head };
         const promptText = stripAttachmentsLine(
           started.payload.prompt.filter((b) => b.type === "text").map((b) => b.text).join("")
         ).trim();
+        let cut = transcript.length;
         for (let i = transcript.length - 1; i >= 0; i--) {
           const it = transcript[i];
           if (it.type === "message" && it.message.role === "user") {
-            if (promptText && it.message.text.trim() === promptText) return head;
+            if (promptText && it.message.text.trim() === promptText) cut = i;
             break;
           }
         }
-        return started.seq - 1;
+        return { transcript: transcript.slice(0, cut), head: started.seq - 1 };
       }
       evict(sessionId) {
         const s = this.sessions.get(sessionId);
@@ -2666,6 +2745,70 @@ ${tail}` : err.message;
   }
 });
 
+// server/src/session/models.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+async function configuredDefault() {
+  try {
+    const { stdout } = await execFileAsync2(config.kiroBin, [
+      "settings",
+      "chat.defaultModel",
+      "-f",
+      "json"
+    ]);
+    const value = JSON.parse(stdout);
+    return typeof value === "string" && value ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function listModels(log) {
+  if (cache2) return cache2;
+  const { stdout } = await execFileAsync2(
+    config.kiroBin,
+    ["chat", "--list-models", "-f", "json"],
+    { maxBuffer: 4 * 1024 * 1024 }
+  );
+  const parsed = JSON.parse(stdout);
+  const configured = await configuredDefault();
+  const preferred = parsed.models.some((m) => m.model_id === configured) ? configured : parsed.default_model;
+  cache2 = parsed.models.map((m, i) => ({
+    modelId: m.model_id,
+    modelName: m.model_name,
+    description: m.description,
+    contextWindowTokens: m.context_window_tokens,
+    rateMultiplier: m.rate_multiplier,
+    rateUnit: m.rate_unit,
+    isDefault: preferred ? m.model_id === preferred : m.default_model ?? i === 0
+  }));
+  log.info({ count: cache2.length, default: preferred }, "loaded model list");
+  return cache2;
+}
+async function defaultModelId(log) {
+  try {
+    return (await listModels(log)).find((m) => m.isDefault)?.modelId;
+  } catch {
+    return void 0;
+  }
+}
+async function kiroVersion() {
+  try {
+    const { stdout } = await execFileAsync2(config.kiroBin, ["--version"]);
+    return stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+var execFileAsync2, cache2;
+var init_models = __esm({
+  "server/src/session/models.ts"() {
+    "use strict";
+    init_config();
+    execFileAsync2 = promisify2(execFile2);
+    cache2 = null;
+  }
+});
+
 // server/src/util/rateLimit.ts
 var AttemptLimiter;
 var init_rateLimit = __esm({
@@ -2812,63 +2955,6 @@ var init_auth = __esm({
   }
 });
 
-// server/src/session/models.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-async function configuredDefault() {
-  try {
-    const { stdout } = await execFileAsync2(config.kiroBin, [
-      "settings",
-      "chat.defaultModel",
-      "-f",
-      "json"
-    ]);
-    const value = JSON.parse(stdout);
-    return typeof value === "string" && value ? value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function listModels(log) {
-  if (cache2) return cache2;
-  const { stdout } = await execFileAsync2(
-    config.kiroBin,
-    ["chat", "--list-models", "-f", "json"],
-    { maxBuffer: 4 * 1024 * 1024 }
-  );
-  const parsed = JSON.parse(stdout);
-  const configured = await configuredDefault();
-  const preferred = parsed.models.some((m) => m.model_id === configured) ? configured : parsed.default_model;
-  cache2 = parsed.models.map((m, i) => ({
-    modelId: m.model_id,
-    modelName: m.model_name,
-    description: m.description,
-    contextWindowTokens: m.context_window_tokens,
-    rateMultiplier: m.rate_multiplier,
-    rateUnit: m.rate_unit,
-    isDefault: preferred ? m.model_id === preferred : m.default_model ?? i === 0
-  }));
-  log.info({ count: cache2.length, default: preferred }, "loaded model list");
-  return cache2;
-}
-async function kiroVersion() {
-  try {
-    const { stdout } = await execFileAsync2(config.kiroBin, ["--version"]);
-    return stdout.trim();
-  } catch {
-    return void 0;
-  }
-}
-var execFileAsync2, cache2;
-var init_models = __esm({
-  "server/src/session/models.ts"() {
-    "use strict";
-    init_config();
-    execFileAsync2 = promisify2(execFile2);
-    cache2 = null;
-  }
-});
-
 // server/src/routes/models.ts
 function registerModelRoutes(app) {
   app.get("/api/models", async () => {
@@ -2898,8 +2984,8 @@ var init_agents2 = __esm({
 });
 
 // server/src/util/confinedFile.ts
-import fs11 from "node:fs/promises";
-import path12 from "node:path";
+import fs12 from "node:fs/promises";
+import path13 from "node:path";
 async function resolveConfined(input, spec) {
   let target = null;
   for (const root of spec.lexical) {
@@ -2915,7 +3001,7 @@ async function resolveConfined(input, spec) {
   if (!real) return { ok: false, ...await spec.notFound() };
   let stat;
   try {
-    stat = await fs11.stat(real);
+    stat = await fs12.stat(real);
   } catch {
     return { ok: false, ...await spec.notFound() };
   }
@@ -2954,7 +3040,7 @@ async function resolveChatPath(sessions, sessionId, requestedPath, require2) {
 async function workspaceNotFound(cwd) {
   let missing;
   try {
-    missing = !(await fs11.stat(cwd)).isDirectory();
+    missing = !(await fs12.stat(cwd)).isDirectory();
   } catch {
     missing = true;
   }
@@ -2974,7 +3060,7 @@ async function resolveAbsolutePath(input, require2) {
   });
 }
 async function classifyDirent(parentReal, entry, realRoots) {
-  const absolute = path12.join(parentReal, entry.name);
+  const absolute = path13.join(parentReal, entry.name);
   if (entry.isDirectory()) return { kind: "directory", real: absolute };
   if (entry.isFile()) return { kind: "file", real: absolute };
   if (!entry.isSymbolicLink()) return null;
@@ -2982,7 +3068,7 @@ async function classifyDirent(parentReal, entry, realRoots) {
     const real = await realConfineToRoot(root, absolute);
     if (!real) continue;
     try {
-      const stat = await fs11.stat(real);
+      const stat = await fs12.stat(real);
       if (stat.isDirectory()) return { kind: "directory", real };
       if (stat.isFile()) return { kind: "file", real };
     } catch {
@@ -3000,7 +3086,7 @@ var init_confinedFile = __esm({
 });
 
 // server/src/util/filekind.ts
-import path13 from "node:path";
+import path14 from "node:path";
 function mimeForExt(ext) {
   return MIME_MAP[ext.toLowerCase()] ?? "application/octet-stream";
 }
@@ -3020,7 +3106,7 @@ function looksBinary(buf) {
   return control / buf.length > 0.3;
 }
 function classifyKind(name) {
-  const ext = path13.extname(name).toLowerCase();
+  const ext = path14.extname(name).toLowerCase();
   if (ext in IMAGE_EXTS) return "image";
   if (TEXT_EXTS.has(ext)) return "text";
   return "binary";
@@ -3130,9 +3216,9 @@ var init_filekind = __esm({
 });
 
 // server/src/routes/filePreview.ts
-import fs12 from "node:fs/promises";
+import fs13 from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 function tooLargeForPreview(size, maxBytes) {
   return {
     error: `File too large for preview (${(size / 1024 / 1024).toFixed(1)} MB, max ${maxBytes / 1024 / 1024} MB)`
@@ -3159,7 +3245,7 @@ function hexdump(buf) {
   return lines.join("\n");
 }
 async function sendFilePreview(req, reply, realTarget, stat) {
-  const ext = path14.extname(realTarget).toLowerCase();
+  const ext = path15.extname(realTarget).toLowerCase();
   const mime = mimeForExt(ext);
   const isImage2 = mime.startsWith("image/");
   const isPdf = mime === "application/pdf";
@@ -3204,7 +3290,7 @@ async function sendFilePreview(req, reply, realTarget, stat) {
   if (kind === "binary") {
     let fh;
     try {
-      fh = await fs12.open(realTarget, "r");
+      fh = await fs13.open(realTarget, "r");
       const buf = Buffer.alloc(Math.min(HEXDUMP_BYTES, stat.size));
       const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
       const head = buf.subarray(0, bytesRead);
@@ -3248,9 +3334,9 @@ var init_filePreview = __esm({
 });
 
 // server/src/routes/fs.ts
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import { createReadStream as createReadStream2 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function registerFsRoutes(app) {
   app.get(
     "/api/fs/dirs",
@@ -3258,10 +3344,10 @@ function registerFsRoutes(app) {
       const input = (req.query.path ?? "").trim();
       const base = config.defaultCwd;
       const endsWithSep = input.endsWith("/");
-      const resolved = input ? path15.resolve(base, input) : base;
-      const dir = endsWithSep || !input ? resolved : path15.dirname(resolved);
-      const prefix = endsWithSep || !input ? "" : path15.basename(resolved);
-      const targetKind = await fs13.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
+      const resolved = input ? path16.resolve(base, input) : base;
+      const dir = endsWithSep || !input ? resolved : path16.dirname(resolved);
+      const prefix = endsWithSep || !input ? "" : path16.basename(resolved);
+      const targetKind = await fs14.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
       const listing = await resolveAbsolutePath(dir, "directory");
       if (!listing.ok) {
         if (listing.status === 403) return replyWith(reply, listing);
@@ -3270,7 +3356,7 @@ function registerFsRoutes(app) {
       const realDir = listing.real;
       let entries = [];
       try {
-        const dirents = await fs13.readdir(realDir, { withFileTypes: true });
+        const dirents = await fs14.readdir(realDir, { withFileTypes: true });
         const checks2 = await Promise.all(
           dirents.map(async (d) => {
             const target = await classifyDirent(realDir, d, absoluteRoots());
@@ -3281,7 +3367,7 @@ function registerFsRoutes(app) {
         entries = checks2.filter((name) => name !== null).filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase())).sort((a, b) => {
           if (isDot(a) !== isDot(b)) return isDot(a) ? 1 : -1;
           return a.localeCompare(b);
-        }).slice(0, 500).map((name) => path15.join(dir, name));
+        }).slice(0, 500).map((name) => path16.join(dir, name));
       } catch {
         entries = [];
       }
@@ -3296,7 +3382,7 @@ function registerFsRoutes(app) {
         reply.code(400);
         return { error: "path parameter is required" };
       }
-      if (!path15.isAbsolute(filePath)) {
+      if (!path16.isAbsolute(filePath)) {
         reply.code(400);
         return { error: "path must be absolute" };
       }
@@ -3306,7 +3392,7 @@ function registerFsRoutes(app) {
         reply.header("Content-Type", "application/octet-stream");
         reply.header(
           "Content-Disposition",
-          `attachment; filename="${path15.basename(resolved.real).replace(/"/g, "")}"`
+          `attachment; filename="${path16.basename(resolved.real).replace(/"/g, "")}"`
         );
         reply.header("Content-Length", resolved.stat.size);
         return reply.send(createReadStream2(resolved.real));
@@ -3477,9 +3563,9 @@ var init_subagents = __esm({
 });
 
 // server/src/routes/workspace.ts
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import { createReadStream as createReadStream3 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 function registerWorkspaceRoutes(app, manager) {
   app.get(
     "/api/chats/:id/tree",
@@ -3494,7 +3580,7 @@ function registerWorkspaceRoutes(app, manager) {
       const { cwd, relative, real: realTarget } = resolved;
       let dirents;
       try {
-        dirents = await fs14.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
+        dirents = await fs15.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return replyWith(reply, await workspaceNotFound(cwd));
       }
@@ -3508,7 +3594,7 @@ function registerWorkspaceRoutes(app, manager) {
           continue;
         }
         try {
-          const stat = await fs14.stat(target.real);
+          const stat = await fs15.stat(target.real);
           entries.push({
             name: d.name,
             path: entryRelative,
@@ -3537,8 +3623,8 @@ function registerWorkspaceRoutes(app, manager) {
         reply.code(413);
         return { error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB, max 100 MB)` };
       }
-      const ext = path16.extname(realTarget);
-      const filename = path16.basename(realTarget);
+      const ext = path17.extname(realTarget);
+      const filename = path17.basename(realTarget);
       const asciiName = filename.replace(/[^\w.\-]/g, "_");
       reply.header("Content-Type", mimeForExt(ext));
       reply.header(
@@ -3573,27 +3659,27 @@ var init_workspace = __esm({
 
 // server/src/routes/uploads.ts
 import { createReadStream as createReadStream4, createWriteStream } from "node:fs";
-import fs15 from "node:fs/promises";
-import path17 from "node:path";
+import fs16 from "node:fs/promises";
+import path18 from "node:path";
 import crypto4 from "node:crypto";
 import { execFile as execFile3 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
 function sanitizeName(raw) {
-  const base = path17.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
+  const base = path18.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
   if (!base || base === "." || base === "..") return `upload-${Date.now()}`;
   return base.replace(/^\.+/, "") || `upload-${Date.now()}`;
 }
 async function uniquePath(dir, name) {
-  const ext = path17.extname(name);
+  const ext = path18.extname(name);
   const stem = name.slice(0, name.length - ext.length);
   let candidate = name;
   let n = 1;
   while (true) {
     try {
-      await fs15.access(path17.join(dir, candidate));
+      await fs16.access(path18.join(dir, candidate));
       candidate = `${stem} (${n++})${ext}`;
     } catch {
-      return path17.join(dir, candidate);
+      return path18.join(dir, candidate);
     }
   }
 }
@@ -3613,7 +3699,7 @@ function fileType(absPath) {
 async function sampleStrings(absPath, limit = 40) {
   let fh;
   try {
-    fh = await fs15.open(absPath, "r");
+    fh = await fs16.open(absPath, "r");
     const buf = Buffer.alloc(STRINGS_SCAN_BYTES);
     const { bytesRead } = await fh.read(buf, 0, STRINGS_SCAN_BYTES, 0);
     const out = [];
@@ -3645,7 +3731,7 @@ function registerUploadRoutes(app) {
         return { error: "Invalid chat id" };
       }
       const uploadDir = chatUploadsDir(req.params.chatId);
-      await fs15.mkdir(uploadDir, { recursive: true, mode: 448 });
+      await fs16.mkdir(uploadDir, { recursive: true, mode: 448 });
       const results = [];
       const parts = req.files();
       for await (const part of parts) {
@@ -3659,17 +3745,17 @@ function registerUploadRoutes(app) {
           return { error: `Failed to store ${name}` };
         }
         if (part.file.truncated) {
-          await fs15.rm(dest, { force: true });
+          await fs16.rm(dest, { force: true });
           reply.code(413);
           return {
             error: `${name} exceeds the max upload size (${Math.round(config.maxUploadBytes / 1024 / 1024)} MB)`
           };
         }
-        const stat = await fs15.stat(dest);
-        const ext = path17.extname(dest);
+        const stat = await fs16.stat(dest);
+        const ext = path18.extname(dest);
         const kind = classifyKind(dest);
         const uploaded = {
-          name: path17.basename(dest),
+          name: path18.basename(dest),
           path: dest,
           size: stat.size,
           mimeType: mimeForExt(ext),
@@ -3725,7 +3811,7 @@ var init_health = __esm({
 });
 
 // server/src/ws/dirWatchers.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 function diffWatchSet(current, next) {
   const have = new Set(current);
   const want = new Set(next.slice(0, MAX_WATCHES));
@@ -3749,7 +3835,7 @@ function createDirWatchers(opts) {
     const target = await opts.resolve(relative);
     if (!target || closed) return;
     try {
-      const watcher = fs16.watch(target, { persistent: false }, () => {
+      const watcher = fs17.watch(target, { persistent: false }, () => {
         const existing = timers.get(relative);
         if (existing) clearTimeout(existing);
         timers.set(
@@ -3807,7 +3893,7 @@ function handleConnection(socket, manager, chatId, startCursor) {
         return null;
       }
     },
-    onChange: (path20) => send(socket, { type: "fs_changed", path: path20 })
+    onChange: (path21) => send(socket, { type: "fs_changed", path: path21 })
   });
   const forward = (event) => {
     if (event.seq <= cursor) return;
@@ -3940,7 +4026,7 @@ var init_gateway = __esm({
 });
 
 // server/src/app.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import Fastify from "fastify";
 import websocket from "@fastify/websocket";
 import fastifyStatic from "@fastify/static";
@@ -3959,7 +4045,7 @@ async function buildApp() {
       transport: isProd ? void 0 : { target: "pino/file", options: { destination: 2 } }
     }
   });
-  const manager = new SessionManager(logger);
+  const manager = new SessionManager(logger, { defaultModel: () => defaultModelId(logger) });
   const startedAt = Date.now();
   await app.register(websocket, {
     options: { maxPayload: 16 * 1024 * 1024 }
@@ -3977,20 +4063,20 @@ async function buildApp() {
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app);
   registerWsGateway(app, manager);
-  if (fs17.existsSync(config.webDist)) {
+  if (fs18.existsSync(config.webDist)) {
     await app.register(fastifyStatic, {
       root: config.webDist
     });
     app.addHook("onSend", async (req, reply) => {
-      const path20 = req.url.split("?")[0] ?? "";
-      if (path20 === "/manifest.json" || path20.startsWith("/icons/")) {
+      const path21 = req.url.split("?")[0] ?? "";
+      if (path21 === "/manifest.json" || path21.startsWith("/icons/")) {
         reply.header("cache-control", "public, max-age=300");
       }
     });
     app.setNotFoundHandler((req, reply) => {
-      const path20 = req.url.split("?")[0] ?? "";
-      const looksLikeAsset = path20.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path20);
-      if (path20.startsWith("/api/") || path20.startsWith("/ws") || looksLikeAsset) {
+      const path21 = req.url.split("?")[0] ?? "";
+      const looksLikeAsset = path21.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path21);
+      if (path21.startsWith("/api/") || path21.startsWith("/ws") || looksLikeAsset) {
         reply.code(404).send({ error: "Not found" });
         return;
       }
@@ -4005,6 +4091,7 @@ var init_app = __esm({
     init_config();
     init_logger();
     init_SessionManager();
+    init_models();
     init_auth();
     init_models2();
     init_agents2();
@@ -4061,19 +4148,22 @@ var init_server = __esm({
 // server/src/cli/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
+  agentFormat: () => agentFormat,
   doctor: () => doctor,
+  kiroMajor: () => kiroMajor,
   mcpWiring: () => mcpWiring
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs18 from "node:fs";
-import path18 from "node:path";
+import fs19 from "node:fs";
+import os4 from "node:os";
+import path19 from "node:path";
 function which(bin) {
-  if (bin.includes("/")) return fs18.existsSync(bin) ? bin : void 0;
-  for (const dir of (process.env.PATH ?? "").split(path18.delimiter)) {
+  if (bin.includes("/")) return fs19.existsSync(bin) ? bin : void 0;
+  for (const dir of (process.env.PATH ?? "").split(path19.delimiter)) {
     if (dir === "") continue;
-    const candidate = path18.join(dir, bin);
+    const candidate = path19.join(dir, bin);
     try {
-      fs18.accessSync(candidate, fs18.constants.X_OK);
+      fs19.accessSync(candidate, fs19.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -4097,11 +4187,28 @@ function mcpWiring(agentJson, resolve) {
     return { ok: false, detail: `${command || "(no command)"} not found - widgets are unavailable` };
   }
   const script = args.find((a) => a.endsWith(".js"));
-  if (script && !fs18.existsSync(script)) {
+  if (script && !fs19.existsSync(script)) {
     return { ok: false, detail: `${script} is gone - delete the agent file and restart to rewrite it` };
   }
   return { ok: true, detail: script ?? `${command} ${args.join(" ")}` };
 }
+function agentFormat(agentJson) {
+  let agent;
+  try {
+    agent = JSON.parse(agentJson);
+  } catch {
+    return { ok: false, detail: "the agent file is not valid JSON" };
+  }
+  const v2Fields = ["allowedTools", "toolsSettings"].filter((f) => f in agent);
+  return v2Fields.length === 0 ? { ok: true, detail: "in the kiro V3 format" } : {
+    ok: false,
+    detail: `has ${v2Fields.join(" and ")}, so kiro V3 skips it - delete the file and restart to rewrite it`
+  };
+}
+function kiroMajor(versionOutput) {
+  const m = /(\d+)\.\d+\.\d+/.exec(versionOutput);
+  return m ? Number(m[1]) : void 0;
+}
 function checks() {
   const out = [];
   out.push({
@@ -4117,7 +4224,10 @@ function checks() {
     } catch {
       version = "(version unavailable)";
     }
-    out.push({ ok: true, name: "kiro-cli", detail: `${version} at ${kiro}` });
+    const major = kiroMajor(version);
+    out.push(
+      major === void 0 || major >= 3 ? { ok: true, name: "kiro-cli", detail: `${version} at ${kiro}` } : { ok: false, name: "kiro-cli", detail: `${version} at ${kiro} - Casper needs kiro-cli 3.0 or later` }
+    );
   } else {
     out.push({
       ok: false,
@@ -4129,7 +4239,7 @@ function checks() {
   const settings = readSettings(config.configFile);
   const hasToken = typeof settings.token === "string" && settings.token !== "";
   out.push(
-    fs18.existsSync(config.configFile) ? {
+    fs19.existsSync(config.configFile) ? {
       ok: hasToken,
       name: "settings",
       detail: hasToken ? `${config.configFile} (token set)` : `${config.configFile} exists but has no token - auth is DISABLED`
@@ -4139,8 +4249,8 @@ function checks() {
       detail: `${config.configFile} not found; a token is generated on first run`
     }
   );
-  if (fs18.existsSync(config.configFile)) {
-    const mode = fs18.statSync(config.configFile).mode & 511;
+  if (fs19.existsSync(config.configFile)) {
+    const mode = fs19.statSync(config.configFile).mode & 511;
     out.push({
       ok: mode === 384,
       name: "settings mode",
@@ -4148,10 +4258,10 @@ function checks() {
     });
   }
   try {
-    fs18.mkdirSync(config.casperDataDir, { recursive: true });
-    fs18.accessSync(config.casperDataDir, fs18.constants.W_OK);
-    const db2 = path18.join(config.casperDataDir, "casper.db");
-    const size = fs18.existsSync(db2) ? `, casper.db ${(fs18.statSync(db2).size / 1024).toFixed(0)} KB` : "";
+    fs19.mkdirSync(config.casperDataDir, { recursive: true });
+    fs19.accessSync(config.casperDataDir, fs19.constants.W_OK);
+    const db2 = path19.join(config.casperDataDir, "casper.db");
+    const size = fs19.existsSync(db2) ? `, casper.db ${(fs19.statSync(db2).size / 1024).toFixed(0)} KB` : "";
     out.push({ ok: true, name: "data dir", detail: `${config.casperDataDir} writable${size}` });
   } catch (err) {
     out.push({
@@ -4162,22 +4272,25 @@ function checks() {
     });
   }
   out.push(
-    fs18.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
+    fs19.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
       ok: false,
       fatal: true,
       name: "web app",
       detail: `${config.webDist} not found - the package is incomplete or CASPER_WEB_DIST is wrong`
     }
   );
-  const agent = path18.join(config.kiroSessionsDir, "..", "..", "agents", "casper.json");
-  const hasAgent = fs18.existsSync(agent);
+  const agent = path19.join(os4.homedir(), ".kiro", "agents", "casper.json");
+  const hasAgent = fs19.existsSync(agent);
   out.push({
     ok: hasAgent,
     name: "casper agent",
     detail: hasAgent ? agent : `${agent} missing - it is installed on first run`
   });
   if (hasAgent) {
-    const wiring = mcpWiring(fs18.readFileSync(agent, "utf8"), which);
+    const json = fs19.readFileSync(agent, "utf8");
+    const format = agentFormat(json);
+    out.push({ ok: format.ok, name: "agent format", detail: format.detail });
+    const wiring = mcpWiring(json, which);
     out.push({ ok: wiring.ok, name: "casper mcp", detail: wiring.detail });
   }
   return out;
@@ -4641,14 +4754,14 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.15.6" : "dev";
+    VERSION = true ? "0.16.0" : "dev";
   }
 });
 
 // server/src/cli/program.ts
-import fs19 from "node:fs";
-import os4 from "node:os";
-import path19 from "node:path";
+import fs20 from "node:fs";
+import os5 from "node:os";
+import path20 from "node:path";
 
 // server/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -5239,8 +5352,8 @@ var Help = class {
    * @param {string} str
    * @returns {number}
    */
-  displayWidth(str2) {
-    return stripVTControlCharacters(str2).length;
+  displayWidth(str3) {
+    return stripVTControlCharacters(str3).length;
   }
   /**
    * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
@@ -5248,11 +5361,11 @@ var Help = class {
    * @param {string} str
    * @returns {string}
    */
-  styleTitle(str2) {
-    return str2;
+  styleTitle(str3) {
+    return str3;
   }
-  styleUsage(str2) {
-    return str2.split(" ").map((word) => {
+  styleUsage(str3) {
+    return str3.split(" ").map((word) => {
       if (word === "[options]") return this.styleOptionText(word);
       if (word === "[command]") return this.styleSubcommandText(word);
       if (word[0] === "[" || word[0] === "<")
@@ -5260,46 +5373,46 @@ var Help = class {
       return this.styleCommandText(word);
     }).join(" ");
   }
-  styleCommandDescription(str2) {
-    return this.styleDescriptionText(str2);
+  styleCommandDescription(str3) {
+    return this.styleDescriptionText(str3);
   }
-  styleOptionDescription(str2) {
-    return this.styleDescriptionText(str2);
+  styleOptionDescription(str3) {
+    return this.styleDescriptionText(str3);
   }
-  styleSubcommandDescription(str2) {
-    return this.styleDescriptionText(str2);
+  styleSubcommandDescription(str3) {
+    return this.styleDescriptionText(str3);
   }
-  styleArgumentDescription(str2) {
-    return this.styleDescriptionText(str2);
+  styleArgumentDescription(str3) {
+    return this.styleDescriptionText(str3);
   }
-  styleDescriptionText(str2) {
-    return str2;
+  styleDescriptionText(str3) {
+    return str3;
   }
-  styleOptionTerm(str2) {
-    return this.styleOptionText(str2);
+  styleOptionTerm(str3) {
+    return this.styleOptionText(str3);
   }
-  styleSubcommandTerm(str2) {
-    return str2.split(" ").map((word) => {
+  styleSubcommandTerm(str3) {
+    return str3.split(" ").map((word) => {
       if (word === "[options]") return this.styleOptionText(word);
       if (word[0] === "[" || word[0] === "<")
         return this.styleArgumentText(word);
       return this.styleSubcommandText(word);
     }).join(" ");
   }
-  styleArgumentTerm(str2) {
-    return this.styleArgumentText(str2);
+  styleArgumentTerm(str3) {
+    return this.styleArgumentText(str3);
   }
-  styleOptionText(str2) {
-    return str2;
+  styleOptionText(str3) {
+    return str3;
   }
-  styleArgumentText(str2) {
-    return str2;
+  styleArgumentText(str3) {
+    return str3;
   }
-  styleSubcommandText(str2) {
-    return str2;
+  styleSubcommandText(str3) {
+    return str3;
   }
-  styleCommandText(str2) {
-    return str2;
+  styleCommandText(str3) {
+    return str3;
   }
   /**
    * Calculate the pad width from the maximum term length.
@@ -5322,8 +5435,8 @@ var Help = class {
    * @param {string} str
    * @returns {boolean}
    */
-  preformatted(str2) {
-    return /\n[^\S\r\n]/.test(str2);
+  preformatted(str3) {
+    return /\n[^\S\r\n]/.test(str3);
   }
   /**
    * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
@@ -5369,9 +5482,9 @@ ${itemIndentStr}`);
    * @param {number} width
    * @returns {string}
    */
-  boxWrap(str2, width) {
-    if (width < this.minWidthToWrap) return str2;
-    const rawLines = str2.split(/\r\n|\n/);
+  boxWrap(str3, width) {
+    if (width < this.minWidthToWrap) return str3;
+    const rawLines = str3.split(/\r\n|\n/);
     const chunkPattern = /[\s]*[^\s]+/g;
     const wrappedLines = [];
     rawLines.forEach((line) => {
@@ -5661,9 +5774,9 @@ var DualOptions = class {
     return option.negate === (negativeValue === value);
   }
 };
-function camelcase(str2) {
-  return str2.split("-").reduce((str3, word) => {
-    return str3 + word[0].toUpperCase() + word.slice(1);
+function camelcase(str3) {
+  return str3.split("-").reduce((str4, word) => {
+    return str4 + word[0].toUpperCase() + word.slice(1);
   });
 }
 function splitOptionFlags(flags) {
@@ -5823,14 +5936,14 @@ var Command = class _Command extends EventEmitter {
     this._showSuggestionAfterError = true;
     this._savedState = null;
     this._outputConfiguration = {
-      writeOut: (str2) => process2.stdout.write(str2),
-      writeErr: (str2) => process2.stderr.write(str2),
-      outputError: (str2, write) => write(str2),
+      writeOut: (str3) => process2.stdout.write(str3),
+      writeErr: (str3) => process2.stderr.write(str3),
+      outputError: (str3, write) => write(str3),
       getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
       getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
       getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
       getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-      stripColor: (str2) => stripVTControlCharacters2(str2)
+      stripColor: (str3) => stripVTControlCharacters2(str3)
     };
     this._hidden = false;
     this._helpOption = void 0;
@@ -7558,18 +7671,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments
    */
-  version(str2, flags, description) {
-    if (str2 === void 0) return this._version;
-    this._version = str2;
+  version(str3, flags, description) {
+    if (str3 === void 0) return this._version;
+    this._version = str3;
     flags = flags || "-V, --version";
     description = description || "output the version number";
     const versionOption = this.createOption(flags, description);
     this._versionOptionName = versionOption.attributeName();
     this._registerOption(versionOption);
     this.on("option:" + versionOption.name(), () => {
-      this._outputConfiguration.writeOut(`${str2}
+      this._outputConfiguration.writeOut(`${str3}
 `);
-      this._exit(0, "commander.version", str2);
+      this._exit(0, "commander.version", str3);
     });
     return this;
   }
@@ -7580,10 +7693,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {object} [argsDescription]
    * @return {(string|Command)}
    */
-  description(str2, argsDescription) {
-    if (str2 === void 0 && argsDescription === void 0)
+  description(str3, argsDescription) {
+    if (str3 === void 0 && argsDescription === void 0)
       return this._description;
-    this._description = str2;
+    this._description = str3;
     if (argsDescription) {
       this._argsDescription = argsDescription;
     }
@@ -7595,9 +7708,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [str]
    * @return {(string|Command)}
    */
-  summary(str2) {
-    if (str2 === void 0) return this._summary;
-    this._summary = str2;
+  summary(str3) {
+    if (str3 === void 0) return this._summary;
+    this._summary = str3;
     return this;
   }
   /**
@@ -7645,8 +7758,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [str]
    * @return {(string|Command)}
    */
-  usage(str2) {
-    if (str2 === void 0) {
+  usage(str3) {
+    if (str3 === void 0) {
       if (this._usage) return this._usage;
       const args = this.registeredArguments.map((arg) => {
         return humanReadableArgName(arg);
@@ -7657,7 +7770,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.registeredArguments.length ? args : []
       ).join(" ");
     }
-    this._usage = str2;
+    this._usage = str3;
     return this;
   }
   /**
@@ -7666,9 +7779,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [str]
    * @return {(string|Command)}
    */
-  name(str2) {
-    if (str2 === void 0) return this._name;
-    this._name = str2;
+  name(str3) {
+    if (str3 === void 0) return this._name;
+    this._name = str3;
     return this;
   }
   /**
@@ -7761,9 +7874,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path20) {
-    if (path20 === void 0) return this._executableDir;
-    this._executableDir = path20;
+  executableDir(path21) {
+    if (path21 === void 0) return this._executableDir;
+    this._executableDir = path21;
     return this;
   }
   /**
@@ -7802,17 +7915,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
     let hasColors;
     let helpWidth;
     if (error) {
-      baseWrite = (str2) => this._outputConfiguration.writeErr(str2);
+      baseWrite = (str3) => this._outputConfiguration.writeErr(str3);
       hasColors = this._outputConfiguration.getErrHasColors();
       helpWidth = this._outputConfiguration.getErrHelpWidth();
     } else {
-      baseWrite = (str2) => this._outputConfiguration.writeOut(str2);
+      baseWrite = (str3) => this._outputConfiguration.writeOut(str3);
       hasColors = this._outputConfiguration.getOutHasColors();
       helpWidth = this._outputConfiguration.getOutHelpWidth();
     }
-    const write = (str2) => {
-      if (!hasColors) str2 = this._outputConfiguration.stripColor(str2);
-      return baseWrite(str2);
+    const write = (str3) => {
+      if (!hasColors) str3 = this._outputConfiguration.stripColor(str3);
+      return baseWrite(str3);
     };
     return { error, write, hasColors, helpWidth };
   }
@@ -8021,7 +8134,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.15.6" : "dev";
+var VERSION2 = true ? "0.16.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -8034,7 +8147,7 @@ async function bootstrap() {
 `);
   }
   const { installAgentFile: installAgentFile2 } = await Promise.resolve().then(() => (init_agentFile(), agentFile_exports));
-  const agent = installAgentFile2(os4.homedir(), dataDirPath());
+  const agent = installAgentFile2(os5.homedir(), dataDirPath());
   if (agent.action === "installed" || agent.action === "updated") {
     process.stdout.write(`casper agent ${agent.action}: ${agent.target}
 `);
@@ -8067,8 +8180,8 @@ async function resetToken(value) {
   updateSettings(file, { token });
   process.stdout.write(`wrote a new token to ${file}
 `);
-  const dbFile = path19.join(dataDirPath(), "casper.db");
-  if (fs19.existsSync(dbFile)) {
+  const dbFile = path20.join(dataDirPath(), "casper.db");
+  if (fs20.existsSync(dbFile)) {
     const { LoginStore: LoginStore2 } = await Promise.resolve().then(() => (init_logins(), logins_exports));
     new LoginStore2().revokeAll();
     process.stdout.write("revoked all device sessions\n");