@joeyshi12/casper 0.15.7 → 0.17.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(),
@@ -353,6 +350,9 @@ function open() {
   const d = new DatabaseSync(file);
   d.exec("PRAGMA journal_mode = WAL");
   d.exec(SCHEMA);
+  const columns = (table) => d.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name);
+  if (!columns("kiro_models").includes("effort_key")) d.exec("ALTER TABLE kiro_models ADD COLUMN effort_key TEXT");
+  if (!columns("chats").includes("pinned")) d.exec("ALTER TABLE chats ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0");
   restrict(config.casperDataDir, 448);
   for (const f of [file, `${file}-wal`, `${file}-shm`]) restrict(f, 384);
   return d;
@@ -373,7 +373,8 @@ CREATE TABLE IF NOT EXISTS chats (
   chat_id    TEXT PRIMARY KEY,
   session_id TEXT UNIQUE,
   title      TEXT,
-  cwd        TEXT
+  cwd        TEXT,
+  pinned     INTEGER NOT NULL DEFAULT 0
 );
 CREATE TABLE IF NOT EXISTS logins (
   id           TEXT PRIMARY KEY,
@@ -403,13 +404,13 @@ 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 TABLE IF NOT EXISTS kiro_models (
+  model_id    TEXT PRIMARY KEY,
+  name        TEXT,
+  levels      TEXT NOT NULL,
+  recommended TEXT,
+  effort_key  TEXT
 );
-CREATE INDEX IF NOT EXISTS subagent_links_parent ON subagent_links (parent_session_id);
 `;
   }
 });
@@ -639,10 +640,38 @@ 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}`;
+}
+function contextBreakdownOf(raw) {
+  if (!raw || typeof raw !== "object")
+    return void 0;
+  const pct = (key) => {
+    const v = raw[key]?.percent;
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  };
+  return {
+    prompts: pct("yourPrompts"),
+    responses: pct("kiroResponses"),
+    tools: pct("tools"),
+    contextFiles: pct("contextFiles"),
+    sessionFiles: pct("sessionFiles"),
+    memory: pct("memory")
+  };
+}
+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 +679,18 @@ var init_acp = __esm({
       sessionPrompt: "session/prompt",
       sessionCancel: "session/cancel",
       sessionSetMode: "session/set_mode",
-      sessionSetModel: "session/set_model",
+      sessionSetConfigOption: "session/set_config_option",
+      sessionFork: "session/fork",
       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",
+      sessionContext: "_kiro/session/context",
+      accountUsage: "_kiro/account/getUsage",
+      steer: "_session/steer",
+      steerClear: "_session/steer/clear",
+      checkpointRevert: "_kiro/checkpoint/revertMultiple"
     };
+    KIRO_AGENT_NOT_FOUND = "_kiro/customAgent/not_found";
   }
 });
 
@@ -759,7 +787,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 +829,7 @@ var emptyDraft;
 var init_turnFold = __esm({
   "shared/dist/turnFold.js"() {
     "use strict";
+    init_acp();
     emptyDraft = () => ({ items: [], streamingText: "", streamingThought: "" });
   }
 });
@@ -831,10 +860,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 +877,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;
   }
 });
@@ -955,6 +985,62 @@ var init_chats = __esm({
   }
 });
 
+// server/src/session/kiroModels.ts
+function rememberKiroModels(options) {
+  const choices = options?.find((o) => o.id === "model")?.options;
+  if (!choices?.length) return;
+  const rows = [];
+  for (const c of choices) {
+    if (typeof c.value !== "string" || !c.value) continue;
+    const kiro = c._meta?.kiro;
+    const levels = Array.isArray(kiro?.effortLevels) ? kiro.effortLevels.filter((l) => typeof l === "string") : [];
+    const recommended = typeof kiro?.defaultEffortLevel === "string" ? kiro.defaultEffortLevel : null;
+    const effortKey = typeof kiro?.effortSchemaPath === "string" && kiro.effortSchemaPath ? kiro.effortSchemaPath : null;
+    rows.push([c.value, typeof c.name === "string" && c.name ? c.name : null, JSON.stringify(levels), recommended, effortKey]);
+  }
+  const key = JSON.stringify(rows);
+  if (key === lastWritten) return;
+  const d = db();
+  d.exec("BEGIN");
+  try {
+    d.prepare("DELETE FROM kiro_models").run();
+    const insert = d.prepare(
+      "INSERT INTO kiro_models (model_id, name, levels, recommended, effort_key) VALUES (?, ?, ?, ?, ?)"
+    );
+    for (const r of rows) insert.run(...r);
+    d.exec("COMMIT");
+    lastWritten = key;
+  } catch (err) {
+    d.exec("ROLLBACK");
+    throw err;
+  }
+}
+function kiroModels() {
+  const rows = db().prepare("SELECT model_id, name, levels, recommended, effort_key FROM kiro_models").all();
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    try {
+      const levels = JSON.parse(r.levels);
+      out.set(r.model_id, {
+        ...r.name ? { name: r.name } : {},
+        levels,
+        ...r.recommended ? { recommended: r.recommended } : {},
+        ...r.effort_key ? { effortKey: r.effort_key } : {}
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+var lastWritten;
+var init_kiroModels = __esm({
+  "server/src/session/kiroModels.ts"() {
+    "use strict";
+    init_db();
+    lastWritten = "";
+  }
+});
+
 // server/src/acp/errors.ts
 function describeError(error) {
   const detail = detailText(error.data);
@@ -1072,6 +1158,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 +1183,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 +1196,21 @@ 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();
+      // Whether kiro can rewind a session to before one of its prompts.
+      checkpoints = false;
       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 +1222,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 +1259,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 +1269,11 @@ 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") : []
+        );
+        this.checkpoints = res?.agentCapabilities?._meta?.kiro?.checkpoints === true;
       }
       newSession(params) {
         return this.client.request(ACP_METHODS.sessionNew, params);
@@ -1174,6 +1281,9 @@ var init_KiroProcess = __esm({
       loadSession(params) {
         return this.client.request(ACP_METHODS.sessionLoad, params);
       }
+      forkSession(params) {
+        return this.client.request(ACP_METHODS.sessionFork, params);
+      }
       /** Runs a prompt turn to completion. */
       prompt(params) {
         return this.client.request(
@@ -1189,13 +1299,62 @@ 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 });
+        return this.client.request(ACP_METHODS.sessionSetConfigOption, {
+          sessionId,
+          configId: "model",
+          value: modelId
+        });
+      }
+      setEffort(sessionId, effortLevel) {
+        return this.client.request(ACP_METHODS.sessionSetConfigOption, {
+          sessionId,
+          configId: "effortLevel",
+          value: effortLevel
+        });
       }
-      execCommand(sessionId, command) {
-        return this.client.request(ACP_METHODS.commandsExecute, {
+      /** Sends a message into the running turn. kiro passes it to the model at its next step,
+       *  reporting that as `steering_injected`. Resolves with kiro's id for it. */
+      async steer(sessionId, message, messageId) {
+        const res = await this.client.request(ACP_METHODS.steer, {
           sessionId,
-          command: { command: command.replace(/^\//, ""), args: {} }
+          message,
+          messageId
         });
+        if (res?.queued !== true) throw new Error("kiro did not take the message");
+        return typeof res.messageId === "string" ? res.messageId : void 0;
+      }
+      /** Drops the messages sent into a turn that the model has not read yet. */
+      clearSteers(sessionId) {
+        return this.client.request(ACP_METHODS.steerClear, { sessionId });
+      }
+      /**
+       * Rewinds the session to before the prompt `messageId`, removing it and everything after.
+       * kiro also restores the files changed since, so this is only for a turn that changed
+       * nothing. False when kiro cannot or did not.
+       */
+      async revertTo(sessionId, messageId) {
+        if (!this.checkpoints) return false;
+        const res = await this.client.request(ACP_METHODS.checkpointRevert, { sessionId, messageId });
+        return res?.success === true;
+      }
+      /** What the session's context holds, as kiro's `/context show` reports it. */
+      async contextBreakdown(sessionId) {
+        const res = await this.client.request(
+          ACP_METHODS.sessionContext,
+          { sessionId, subcommand: "show" }
+        );
+        return res?.breakdown;
+      }
+      /** The user's plan and its use this billing cycle. Not session-scoped. */
+      accountUsage() {
+        return this.client.request(ACP_METHODS.accountUsage, {});
+      }
+      /** 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() {
@@ -1324,7 +1483,9 @@ var init_TurnState = __esm({
           case "metadata":
             this.snapshot = {
               ...s,
-              contextUsagePercentage: payload.params.contextUsagePercentage ?? s.contextUsagePercentage
+              contextUsagePercentage: payload.params.contextUsagePercentage ?? s.contextUsagePercentage,
+              contextBreakdown: payload.params.contextBreakdown ?? s.contextBreakdown,
+              sessionCredits: payload.params.sessionCredits ?? s.sessionCredits
             };
             break;
           case "compaction":
@@ -1355,6 +1516,9 @@ function cap(value) {
   }
   return value;
 }
+function steerMessage(text2, seq, ts) {
+  return { type: "message", message: { id: `s-${seq}`, role: "user", text: text2, timestamp: ts, steer: true } };
+}
 var MAX_STRING, isImage, bounded, TurnRecorder;
 var init_TurnRecorder = __esm({
   "server/src/session/TurnRecorder.ts"() {
@@ -1390,6 +1554,8 @@ var init_TurnRecorder = __esm({
           );
         } else if (p.kind === "session_update" && this.draft) {
           this.draft = foldSessionUpdate(this.draft, p.update, e.seq, e.ts);
+        } else if (p.kind === "steer_injected" && this.draft) {
+          this.draft = { ...emptyDraft(), items: [...commitDraft(this.draft, `s-${e.seq}`, e.ts), steerMessage(p.text, e.seq, e.ts)] };
         }
       }
       /** Null when no turn was being followed. */
@@ -1418,302 +1584,450 @@ var init_SubagentTracker = __esm({
   "server/src/session/SubagentTracker.ts"() {
     "use strict";
     SubagentTracker = class {
-      byChild = /* @__PURE__ */ new Map();
-      pendingCalls = [];
-      callStarted(toolCallId, stages) {
-        this.pendingCalls.push({ toolCallId, stages });
-      }
-      callFinished(toolCallId) {
-        const i = this.pendingCalls.findIndex((c) => c.toolCallId === toolCallId);
-        if (i >= 0) this.pendingCalls.splice(i, 1);
-      }
-      callFor(stageName) {
-        for (let i = this.pendingCalls.length - 1; i >= 0; i--) {
-          if (this.pendingCalls[i].stages.some((s) => s.name === stageName)) return this.pendingCalls[i];
-        }
-        return void 0;
-      }
-      /** Folds a list_update into the tracked state, returning links newly resolved
-       *  this call, so the caller persists each one once. */
-      apply(subagents, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
-        const resolved = [];
-        for (const info of subagents) {
-          const existing = this.byChild.get(info.sessionId);
-          const nowIso = now();
-          const toolCallId = existing?.toolCallId ?? this.callFor(info.sessionName)?.toolCallId;
-          if (toolCallId && !existing?.toolCallId) {
-            resolved.push({ sessionId: info.sessionId, toolCallId, stageName: info.sessionName });
-          }
-          this.byChild.set(info.sessionId, {
-            sessionId: info.sessionId,
-            stageName: info.sessionName,
-            toolCallId,
-            status: info.status.type === "terminated" ? "completed" : "working",
-            activity: info.status.message,
-            createdAt: existing?.createdAt ?? nowIso,
-            updatedAt: nowIso
-          });
+      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 resolved;
+        return false;
       }
-      /** Called when the parent turn ends. The `subagent` tool call blocks the turn, so
-       *  any subagent still working was stopped with it, and kiro does not always send a
-       *  list_update saying so. Returns whether anything changed. */
-      turnEnded(now = () => (/* @__PURE__ */ new Date()).toISOString()) {
-        let changed = this.pendingCalls.length > 0;
-        this.pendingCalls.length = 0;
-        for (const s of this.byChild.values()) {
+      /** 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 = now();
+          s.updatedAt = this.now();
           changed = true;
         }
         return changed;
       }
-      /** 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];
-      }
+      /** 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 readTailLine(line, facts) {
+  const usage = facts.contextUsage === void 0 && line.includes('"contextUsage"');
+  const prompt = facts.lastPromptAt === void 0 && line.includes('"user"');
+  if (!usage && !prompt) return;
   try {
-    const raw = await fs9.readFile(
-      path10.join(config.kiroSessionsDir, `${sessionId}.json`),
-      "utf8"
-    );
-    return summarize(JSON.parse(raw));
+    const l = JSON.parse(line);
+    const p = l.payload;
+    const value = isRecord(p.value) ? p.value.usagePercentage : void 0;
+    if (usage && p.type === "session_metadata" && p.key === "contextUsage" && typeof value === "number") {
+      facts.contextUsage = value;
+    }
+    if (prompt && p.type === "user" && typeof l.timestamp === "string") facts.lastPromptAt = iso(l.timestamp);
   } catch {
-    return null;
   }
 }
-async function withLastWrite(child) {
+async function readTail(file) {
+  const facts = {};
+  const done = () => facts.contextUsage !== void 0 && facts.lastPromptAt !== void 0;
+  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 facts;
   }
-}
-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 && !done()) {
+      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 && !done(); i--) readTailLine(lines[i], facts);
+    }
+    if (tail && !done()) readTailLine(tail, facts);
+    return facts;
+  } 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();
+  const tail = await readTail(path10.join(dir, "messages.jsonl"));
+  return {
+    sessionId: j.id,
+    title: title === PLACEHOLDER_TITLE ? "" : title,
+    cwd: j.workspacePaths?.[0] ?? "",
+    createdAt,
+    // The latest prompt, not lastModifiedAt: kiro's 2.x-to-V3 migration set lastModifiedAt,
+    // and the time on every reply, to the moment it ran. Prompts kept their real times.
+    updatedAt: tail.lastPromptAt ?? iso(j.lastModifiedAt) ?? createdAt,
+    agentId: j.agentMode,
+    modelId: j.modelId,
+    effortLevel: j.effortLevel,
+    contextUsagePercentage: tail.contextUsage
+  };
 }
-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;
+async function readV3Credits(dir) {
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  for (const line of await readLines(path10.join(dir, "messages.jsonl"), '"usage_summary"')) {
+    const p = line.payload;
+    if (p.type !== "usage_summary" || seen.has(line.id)) continue;
+    seen.add(line.id);
+    for (const s of Array.isArray(p.promptTurnSummaries) ? p.promptTurnSummaries : []) {
+      const usage = isRecord(s) ? s.usage : void 0;
+      if (typeof usage === "number" && Number.isFinite(usage)) total += usage;
+    }
+  }
+  return total;
+}
+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();
+  const steers = /* @__PURE__ */ new Map();
+  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": {
+        if (p.source === "steer") {
+          const text2 = userText(p.content);
+          if (text2.trim()) steers.set(line.id, text2);
+          break;
+        }
+        const kiro = isRecord(p._meta) && isRecord(p._meta.kiro) ? p._meta.kiro : void 0;
+        if (kiro?.syntheticUserMessageReason !== void 0) {
+          const ids = Array.isArray(kiro.steeringConsumedIds) ? kiro.steeringConsumedIds : [];
+          for (const id of ids) {
+            const text2 = typeof id === "string" ? steers.get(id) : void 0;
+            if (text2 === void 0) continue;
+            out.push({ kind: "item", item: { type: "message", message: { id: `s-${id}`, role: "user", text: text2, timestamp: at, steer: true } } });
+          }
+          break;
+        }
+        out.push({ kind: "prompt", id: line.id, text: userText(p.content), atMs: at, timestamp: at });
+        break;
+      }
+      case "tombstone": {
+        const from = p.kind === "checkpoint_revert" ? str2(p.effectiveFromMessageId) : void 0;
+        const at2 = from ? out.findIndex((e) => e.kind === "prompt" && e.id === from) : -1;
+        if (at2 >= 0) out.length = at2;
+        break;
+      }
+      case "usage_summary": {
+        const credits = (Array.isArray(p.promptTurnSummaries) ? p.promptTurnSummaries : []).reduce(
+          (sum, s) => sum + (isRecord(s) && typeof s.usage === "number" && Number.isFinite(s.usage) ? s.usage : 0),
+          0
+        );
+        const elapsedMs = typeof p.elapsedTime === "number" && p.elapsedTime > 0 ? p.elapsedTime : void 0;
+        if (credits > 0 || elapsedMs) {
+          out.push({
+            kind: "item",
+            item: { type: "turn_stats", id: `u-${line.id}`, ...elapsedMs ? { elapsedMs } : {}, ...credits > 0 ? { credits } : {} }
+          });
+        }
+        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 sessionCredits(sessionId) {
+  const dir = await v3SessionDir(sessionId);
+  return dir ? readV3Credits(dir) : void 0;
+}
+async function promptCount(sessionId) {
+  return (await promptStamps(sessionId)).length;
+}
+async function promptStamps(sessionId) {
+  return (await readEntries(sessionId)).flatMap((e) => e.kind === "prompt" ? [{ id: e.id, atMs: e.atMs }] : []);
 }
 function endingItems(e) {
   const prefix = `te${e.id}-`;
@@ -1725,110 +2039,96 @@ 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, messageId: entry.id } });
+    }
+    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;
   }
 });
 
 // server/src/session/chatStore.ts
-var ChatStore;
+var COLUMNS, rowOf, ChatStore;
 var init_chatStore = __esm({
   "server/src/session/chatStore.ts"() {
     "use strict";
     init_db();
+    COLUMNS = "chat_id, session_id, title, cwd, pinned";
+    rowOf = (r) => ({
+      chatId: r.chat_id,
+      sessionId: r.session_id,
+      title: r.title,
+      cwd: r.cwd,
+      pinned: r.pinned === 1
+    });
     ChatStore = class {
       all() {
-        return db().prepare("SELECT chat_id, session_id, title, cwd FROM chats").all().map((r) => ({ chatId: r.chat_id, sessionId: r.session_id, title: r.title, cwd: r.cwd }));
+        return db().prepare(`SELECT ${COLUMNS} FROM chats`).all().map(rowOf);
       }
       get(chatId) {
-        const r = db().prepare("SELECT chat_id, session_id, title, cwd FROM chats WHERE chat_id = ?").get(chatId);
-        return r ? { chatId: r.chat_id, sessionId: r.session_id, title: r.title, cwd: r.cwd } : void 0;
+        const r = db().prepare(`SELECT ${COLUMNS} FROM chats WHERE chat_id = ?`).get(chatId);
+        return r ? rowOf(r) : void 0;
       }
       create(chatId) {
         db().prepare("INSERT INTO chats (chat_id) VALUES (?) ON CONFLICT(chat_id) DO NOTHING").run(chatId);
@@ -1855,6 +2155,11 @@ var init_chatStore = __esm({
       setCwd(chatId, cwd) {
         this.write(chatId, "cwd", cwd);
       }
+      /** Returns false when there is no such chat. */
+      setPinned(chatId, pinned) {
+        const r = db().prepare("UPDATE chats SET pinned = ? WHERE chat_id = ?").run(pinned ? 1 : 0, chatId);
+        return Number(r.changes) > 0;
+      }
       /** What was attached to one prompt, keyed by ordinal (see db.ts). */
       setAttachments(chatId, ordinal, files) {
         if (files.length === 0) return;
@@ -1914,6 +2219,27 @@ var init_chatStore = __esm({
         }
         return out;
       }
+      /**
+       * Copies what a branch keeps of another chat: the attachments of the first `prompts`
+       * prompts, and the turn endings that started before `before` (all of them if unset).
+       * `movePath` gives an attachment's path in the branch.
+       */
+      copyHistory(from, to, keep, movePath) {
+        for (const [ordinal, files] of this.attachmentsByChat(from)) {
+          if (ordinal < keep.prompts) {
+            this.setAttachments(to, ordinal, files.map((f) => ({ ...f, path: movePath(f.path) })));
+          }
+        }
+        for (const e of this.turnEndingsByChat(from)) {
+          if (keep.before === void 0 || e.startedAt < keep.before) this.addTurnEnding(to, e);
+        }
+      }
+      /** Drops what a rewind removes: the attachments from prompt `prompts` on, and the turn
+       *  endings that started at or after `from`. */
+      dropHistory(chatId, drop) {
+        db().prepare("DELETE FROM message_attachments WHERE chat_id = ? AND ordinal >= ?").run(chatId, drop.prompts);
+        db().prepare("DELETE FROM turn_endings WHERE chat_id = ? AND started_at >= ?").run(chatId, drop.from);
+      }
       remove(chatId) {
         db().prepare("DELETE FROM chats WHERE chat_id = ?").run(chatId);
         db().prepare("DELETE FROM message_attachments WHERE chat_id = ?").run(chatId);
@@ -1933,50 +2259,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;
   }
@@ -1984,49 +2278,102 @@ 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": {
+      if (typeof info.usagePercentage !== "number") return null;
+      const contextBreakdown = contextBreakdownOf(info.breakdown);
+      return {
+        kind: "metadata",
+        params: { sessionId, contextUsagePercentage: info.usagePercentage, ...contextBreakdown ? { contextBreakdown } : {} }
+      };
+    }
+    case "focus_update": {
+      const title = sanitizeTitle(info.title ?? "");
+      return title ? { kind: "title_changed", title } : null;
+    }
+    case "session_usage": {
+      const total = (info.credits ?? []).reduce((sum, c) => sum + (typeof c?.usage === "number" ? c.usage : 0), 0);
+      return info.credits?.length ? { kind: "metadata", params: { sessionId, sessionCredits: total } } : null;
+    }
+    case "user_message_id_assigned":
+      return typeof info.userMessageId === "string" && info.userMessageId ? { kind: "prompt_id", messageId: info.userMessageId } : 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 sessionSettings(options) {
+  if (!options) return void 0;
+  return {
+    modelId: options.find((o) => o.id === "model")?.currentValue,
+    effortLevel: options.find((o) => o.id === "effortLevel")?.currentValue ?? null
+  };
 }
-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"
+function turnStatsOf(info) {
+  const credits = (info.promptTurnSummaries ?? []).reduce(
+    (sum, t) => sum + (typeof t?.usage === "number" && Number.isFinite(t.usage) ? t.usage : 0),
+    0
   );
-  return { toolCallId, stages };
+  const elapsedMs = typeof info.elapsedTime === "number" && info.elapsedTime > 0 ? info.elapsedTime : void 0;
+  if (!credits && !elapsedMs) return void 0;
+  return { ...elapsedMs ? { elapsedMs } : {}, ...credits > 0 ? { credits } : {} };
+}
+function accountUsageOf(raw) {
+  const data = raw?.data;
+  if (!data || typeof data.planName !== "string") return void 0;
+  const credits = (Array.isArray(data.usageBreakdowns) ? data.usageBreakdowns : []).find(
+    (b) => b?.resourceType === "CREDIT"
+  );
+  if (!credits || typeof credits.used !== "number") return void 0;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  return {
+    planName: data.planName,
+    used: credits.used,
+    ...credits.hasLimit !== false && num(credits.limit) !== void 0 ? { limit: num(credits.limit) } : {},
+    ...typeof data.billingCycleReset === "string" ? { resetsOn: data.billingCycleReset } : {},
+    ...num(credits.overageCharges) ? { overageCharges: num(credits.overageCharges) } : {},
+    ...typeof credits.currency === "string" ? { currency: credits.currency } : {}
+  };
+}
+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;
 }
 function firstPromptText(transcript) {
-  const first = transcript.find((it) => it.type === "message" && it.message.role === "user");
+  const first = transcript.find((it) => it.type === "message" && it.message.role === "user" && !it.message.steer);
   return first?.type === "message" ? first.message.text : void 0;
 }
 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";
@@ -2034,17 +2381,15 @@ var init_SessionManager = __esm({
     init_config();
     init_agents();
     init_chats();
+    init_kiroModels();
     init_paths2();
     init_KiroProcess();
     init_EventStore();
     init_TurnState();
     init_TurnRecorder();
     init_SubagentTracker();
-    init_subagentResult();
-    init_subagentFallbackMatch();
     init_kiroFiles();
     init_chatStore();
-    init_subagentLinks();
     CANCEL_GRACE_MS = 1e4;
     Session = class {
       sessionId;
@@ -2055,8 +2400,21 @@ var init_SessionManager = __esm({
       cwd;
       agentId;
       modelId;
+      effortLevel;
       currentModeId;
       availableModes = [];
+      // Set on a session that starts as a copy of another's conversation, cut after the
+      // turn of the prompt `messageId`.
+      forkOf;
+      // Credits used, as kiro last reported them.
+      credits;
+      // The latest turn: its prompt's id once kiro names it, whether anything came of it, and
+      // whether it failed. A retry rewinds a failed turn that left nothing.
+      lastTurn;
+      // Messages sent into the running turn that the model has not read yet, by kiro's id.
+      steers = /* @__PURE__ */ new Map();
+      // What the running turn took, from kiro's turn_completion.
+      turnStats;
       title = "";
       createdAt = (/* @__PURE__ */ new Date()).toISOString();
       updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2093,21 +2451,24 @@ 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;
+      defaultEffort;
+      defaultAgent;
       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);
+        this.defaultEffort = opts.defaultEffort ?? (async () => void 0);
+        this.defaultAgent = opts.defaultAgent ?? (async () => void 0);
       }
       /** What a session is called, from every read path. */
       titleOf(chat, parts) {
@@ -2115,7 +2476,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) {
@@ -2124,6 +2485,9 @@ var init_SessionManager = __esm({
         const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         if (s) s.title = clean || s.title;
       }
+      pinChat(chatId, pinned) {
+        if (!this.store.setPinned(chatId, pinned)) throw new Error(`Unknown chat: ${chatId}`);
+      }
       // A live process was spawned with the old cwd, so it's disposed and the next
       // turn respawns.
       async setChatCwd(chatId, input) {
@@ -2173,7 +2537,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."
           );
@@ -2187,9 +2551,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);
       }
@@ -2234,6 +2598,7 @@ var init_SessionManager = __esm({
         s.agentId = persisted.agentId;
         s.currentModeId = persisted.agentId;
         s.modelId = persisted.modelId;
+        s.effortLevel = persisted.effortLevel;
         s.createdAt = persisted.createdAt;
         s.updatedAt = persisted.updatedAt;
         s.markLive();
@@ -2243,31 +2608,70 @@ 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);
+          const replayed = n.params?.update;
+          if (s.replaying || kiroMeta(replayed ?? { sessionUpdate: "" })?.replay) {
+            if (replayed?.sessionUpdate === "session_info_update" && replayed._meta?.kiro?.kind === "session_usage") {
+              const payload = sessionInfoEvent(s.sessionId, replayed);
+              if (payload?.kind === "metadata") s.credits = payload.params.sessionCredits;
+              if (payload) s.record(payload);
             }
-            s.record({ kind: "subagents_changed", subagents: s.subagents.list() });
             return;
           }
-          const notifSessionId = notificationSessionId(n);
-          if (!notifSessionId || notifSessionId === s.sessionId) {
-            const payload = mapNotification(n);
-            if (!payload) return;
-            if (payload.kind === "session_update") {
-              const call = subagentCallStages(payload.update);
-              if (call) s.subagents.callStarted(call.toolCallId, call.stages);
-              const update = payload.update;
-              if (update.sessionUpdate === "tool_call_update" && typeof update.toolCallId === "string" && (update.status === "completed" || update.status === "failed")) {
-                s.subagents.callFinished(update.toolCallId);
-              }
+          if (n.method === KIRO_AGENT_NOT_FOUND) {
+            this.log.warn({ sessionId: s.sessionId, detail: n.params }, "kiro could not use the requested agent");
+            return;
+          }
+          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 info = update._meta?.kiro;
+            if (info?.kind === "steering_injected" || info?.kind === "steering_cleared") {
+              this.steerSettled(s, info.kind === "steering_injected", info.kind === "steering_injected" ? [info.messageId] : info.messageIds ?? []);
+              return;
             }
-            s.record(payload);
+            if (info?.kind === "turn_completion") {
+              s.turnStats = turnStatsOf(info);
+              return;
+            }
+            const payload = sessionInfoEvent(s.sessionId, update);
+            if (payload?.kind === "prompt_id" && s.lastTurn) s.lastTurn.messageId = payload.messageId;
+            if (payload?.kind === "metadata" && payload.params.sessionCredits !== void 0) {
+              s.credits = payload.params.sessionCredits;
+            }
+            if (payload?.kind === "title_changed") {
+              if (payload.title === s.title) return;
+              s.title = payload.title;
+            }
+            if (payload) s.record(payload);
+            return;
+          }
+          if (update.sessionUpdate === "config_option_update") {
+            const options = update.configOptions;
+            rememberKiroModels(options);
+            const settings = sessionSettings(options);
+            if (!settings) return;
+            const modelId = settings.modelId ?? s.modelId;
+            const effortLevel = settings.effortLevel ?? void 0;
+            if (modelId === s.modelId && effortLevel === s.effortLevel) return;
+            s.modelId = modelId;
+            s.effortLevel = effortLevel;
+            s.record({ kind: "settings_changed", modelId, effortLevel: settings.effortLevel });
+            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);
+          if (s.lastTurn) s.lastTurn.output = true;
+          s.record({ kind: "session_update", update });
         });
         proc.on("exit", (code, signal) => {
           if (s.proc !== proc) return;
@@ -2276,28 +2680,64 @@ 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 if (s.forkOf) {
+            const { sessionId } = await proc.forkSession({
+              sessionId: s.forkOf.sessionId,
+              cwd: s.cwd,
+              mcpServers: [],
+              _meta: { kiro: { messageId: s.forkOf.messageId } }
+            });
+            s.replaying = true;
+            try {
+              res = { ...await proc.loadSession({ sessionId, cwd: s.cwd, mcpServers: [] }), sessionId };
             } finally {
               s.replaying = false;
             }
+            res = await this.applyForkSettings(proc, s, res);
           } 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, effortLevel: s.effortLevel } }
+            });
           }
           if (!s.hasBeenLive && res.sessionId !== s.sessionId) {
             this.sessions.delete(s.sessionId);
@@ -2307,6 +2747,13 @@ var init_SessionManager = __esm({
           s.availableModes = res.modes.availableModes;
           s.currentModeId = res.modes.currentModeId;
           s.agentId = res.modes.currentModeId ?? s.agentId;
+          const settings = sessionSettings(res.configOptions);
+          if (settings) {
+            s.modelId = settings.modelId ?? s.modelId;
+            s.effortLevel = settings.effortLevel ?? void 0;
+          }
+          rememberModes(res.modes.availableModes);
+          rememberKiroModels(res.configOptions);
           s.markLive();
           s.proc = proc;
           s.spawning = void 0;
@@ -2319,6 +2766,25 @@ var init_SessionManager = __esm({
           throw err;
         }
       }
+      /** A fork starts on kiro's default mode and model, so the ones the chat had are set
+       *  again. Returns the session as it now is. */
+      async applyForkSettings(proc, s, res) {
+        const got = sessionSettings(res.configOptions);
+        let changed = false;
+        if (s.agentId && res.modes.currentModeId !== s.agentId) {
+          await proc.setMode(res.sessionId, s.agentId);
+          res = { ...res, modes: { ...res.modes, currentModeId: s.agentId } };
+        }
+        if (s.modelId && got?.modelId !== s.modelId) {
+          await proc.setModel(res.sessionId, s.modelId);
+          changed = true;
+        }
+        if (s.effortLevel && (changed || got?.effortLevel !== s.effortLevel)) {
+          await proc.setEffort(res.sessionId, s.effortLevel);
+          changed = true;
+        }
+        return changed ? { ...res, configOptions: void 0 } : res;
+      }
       async ensureCapacity() {
         const liveIds = [...this.sessions.values()].filter((s) => s.proc);
         if (liveIds.length < config.maxLiveSessions) return;
@@ -2338,33 +2804,116 @@ var init_SessionManager = __esm({
           this.log.warn("at capacity but all processes are busy");
         }
       }
-      /** Creates a new session. Spawns immediately to get a real kiro sessionId. */
+      /** Creates a new session. Spawns immediately to get a real kiro sessionId. It has no
+       *  Casper title, so kiro's own title names it once kiro has made one. */
       async createChat(opts) {
         const chatId = isValidChatId(opts.chatId) ? opts.chatId : crypto.randomUUID();
         const cwd = opts.freshWorkspace ? createChatWorkspace(chatId) : resolveCwd(opts.cwd);
-        const tempId = `pending-${Date.now()}-${Math.floor(this.sessions.size)}`;
-        const store = new EventStore(chatId);
+        const modelId = opts.modelId ?? await this.defaultModel();
+        const s = await this.startSession(new EventStore(chatId), cwd, {
+          agentId: opts.agentId ?? await this.defaultAgent() ?? config.defaultAgent,
+          modelId,
+          effortLevel: opts.effortLevel ?? await this.defaultEffort(modelId)
+        });
+        this.store.create(chatId);
+        this.store.bindSession(chatId, s.sessionId);
+        return this.buildDetail(this.store.get(chatId), s, []);
+      }
+      /** Starts a kiro session, new or forked, and holds it in memory under kiro's id. */
+      async startSession(store, cwd, init) {
+        const tempId = `pending-${crypto.randomUUID()}`;
         const s = new Session(tempId, store, cwd);
-        s.agentId = opts.agentId ?? config.defaultAgent;
-        s.currentModeId = s.agentId;
-        s.modelId = opts.modelId;
+        s.agentId = init.agentId;
+        s.currentModeId = init.agentId;
+        s.modelId = init.modelId;
+        s.effortLevel = init.effortLevel;
+        s.forkOf = init.forkOf;
         this.sessions.set(tempId, s);
         try {
           await this.ensureProc(s);
         } catch (err) {
-          this.evict(s.sessionId);
+          this.sessions.delete(s.sessionId);
+          s.proc?.dispose();
           throw err;
         }
-        this.store.create(chatId);
-        this.store.bindSession(chatId, s.sessionId);
-        const name = sanitizeTitle(opts.title ?? "") || (opts.freshWorkspace ? "" : path11.basename(s.cwd));
-        if (name) {
-          this.store.setTitle(chatId, name);
-          s.title = name;
+        return s;
+      }
+      /**
+       * A new chat holding this chat's conversation up to and including the turn of the
+       * prompt `messageId`. A workspace Casper made is copied with it, so either chat can be
+       * deleted without taking the other's files.
+       */
+      async branchChat(chatId, messageId) {
+        const parent = await this.ensureOpen(chatId);
+        await this.settleReload(parent);
+        const prompts = await promptStamps(parent.sessionId);
+        const at = prompts.findIndex((p) => p.id === messageId);
+        if (at < 0) throw new Error(`Unknown message: ${messageId}`);
+        const branchId = crypto.randomUUID();
+        const fromDir = chatDir(chatId);
+        const toDir = chatDir(branchId);
+        const ownWorkspace = parent.cwd === chatWorkspaceDir(chatId);
+        await fs11.promises.cp(fromDir, toDir, { recursive: true }).catch((err) => {
+          if (err.code !== "ENOENT") throw err;
+        });
+        let s;
+        try {
+          s = await this.startSession(new EventStore(branchId), ownWorkspace ? createChatWorkspace(branchId) : parent.cwd, {
+            agentId: parent.agentId,
+            modelId: parent.modelId,
+            effortLevel: parent.effortLevel,
+            forkOf: { sessionId: parent.sessionId, messageId }
+          });
+        } catch (err) {
+          await removeChatDir(branchId);
+          throw err;
         }
-        return this.buildDetail(this.store.get(chatId), s, []);
+        this.store.create(branchId);
+        this.store.bindSession(branchId, s.sessionId);
+        const parentRow = this.store.get(chatId);
+        if (parentRow?.title) this.store.setTitle(branchId, parentRow.title);
+        if (parentRow?.cwd && !ownWorkspace) this.store.setCwd(branchId, parentRow.cwd);
+        const cutAt = prompts[at + 1]?.atMs;
+        this.store.copyHistory(
+          chatId,
+          branchId,
+          { prompts: at + 1, before: cutAt === void 0 ? void 0 : cutAt - STAMP_PAD_MS },
+          (p) => p.startsWith(fromDir + path12.sep) ? toDir + p.slice(fromDir.length) : p
+        );
+        return this.getDetail(branchId);
+      }
+      /**
+       * Cuts this chat back to before the prompt `messageId`, so it can be sent again. kiro
+       * cannot shorten a session, so the chat moves to a new kiro session holding the turns
+       * before it, and the old session stays in kiro's store.
+       */
+      async rewindChat(chatId, messageId) {
+        const s = await this.ensureOpen(chatId);
+        await this.settleReload(s);
+        if (s.running) throw new Error("Cannot rewind while a turn is running");
+        if (s.turnState.get().compacting) throw new Error("Cannot rewind while the conversation is being compacted");
+        const prompts = await promptStamps(s.sessionId);
+        const at = prompts.findIndex((p) => p.id === messageId);
+        if (at < 0) throw new Error(`Unknown message: ${messageId}`);
+        const next = await this.startSession(s.store, s.cwd, {
+          agentId: s.agentId,
+          modelId: s.modelId,
+          effortLevel: s.effortLevel,
+          forkOf: at > 0 ? { sessionId: s.sessionId, messageId: prompts[at - 1].id } : void 0
+        });
+        const old = s.proc;
+        s.proc = void 0;
+        this.sessions.delete(s.sessionId);
+        this.store.bindSession(chatId, next.sessionId);
+        this.store.dropHistory(chatId, { prompts: at, from: (prompts[at].atMs ?? Date.now()) - STAMP_PAD_MS });
+        next.record({ kind: "history_replaced" });
+        this.log.info({ chatId, from: s.sessionId, to: next.sessionId }, "chat rewound");
+        await old?.disposeAndWait().catch(() => {
+        });
+        await this.forgetSession(s.sessionId);
+        return this.getDetail(chatId);
       }
-      async runPrompt(chatId, content, attachments) {
+      async runPrompt(chatId, content, attachments, opts = {}) {
         const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
         if (s.running) throw new Error("A turn is already running for this session");
@@ -2377,13 +2926,9 @@ var init_SessionManager = __esm({
           s.running = false;
           throw err;
         }
-        if (!this.store.getTitle(chatId)) {
-          const title = titleFromPrompt(content);
-          if (title) {
-            this.store.setTitle(chatId, title);
-            s.title = title;
-          }
-        }
+        if (opts.retry) await this.dropFailedTurn(chatId, s, proc);
+        s.lastTurn = { output: false, failed: false };
+        s.turnStats = void 0;
         let recorded;
         if (attachments?.length) {
           const ordinal = await promptCount(s.sessionId);
@@ -2391,11 +2936,18 @@ var init_SessionManager = __esm({
           recorded = attachments;
         }
         s.record({ kind: "turn_started", prompt: content, attachments: recorded });
-        proc.prompt({ sessionId: s.sessionId, prompt: content }).then((res) => {
+        proc.prompt({ sessionId: s.sessionId, prompt: content }).then(async (res) => {
           if (res.stopReason === "cancelled") this.saveEnding(chatId, s.recorder.finish({ kind: "interrupted" }));
           else s.recorder.discard();
-          s.record({ kind: "turn_ended", stopReason: res.stopReason });
-        }).catch((err) => {
+          if (s.lastTurn) s.lastTurn.failed = res.stopReason === "cancelled";
+          await this.dropSteers(s, proc);
+          const stats = s.turnStats;
+          s.turnStats = void 0;
+          s.record({ kind: "turn_ended", stopReason: res.stopReason, ...stats ? { stats } : {} });
+        }).catch(async (err) => {
+          if (s.lastTurn) s.lastTurn.failed = true;
+          s.turnStats = void 0;
+          await this.dropSteers(s, proc);
           if (s.cancelRequested) {
             this.saveEnding(chatId, s.recorder.finish({ kind: "interrupted" }));
             s.record({ kind: "turn_ended", stopReason: "cancelled" });
@@ -2418,6 +2970,67 @@ ${tail}` : err.message;
           if (s.subagents.turnEnded()) s.record({ kind: "subagents_changed", subagents: s.subagents.list() });
         });
       }
+      /** Sends a message into the running turn. It shows in the chat once the model reads it,
+       *  as a `steer_injected` event; one the turn ends without reading comes back as
+       *  `steer_dropped`. */
+      async steer(chatId, text2, clientId) {
+        const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
+        const message = text2.trim();
+        if (!message) throw new Error("The message is empty");
+        const proc = s?.proc;
+        if (!s || !proc || !s.running || s.cancelRequested) throw new Error("No turn is running");
+        const id = crypto.randomUUID();
+        const entry = { text: message, ...clientId ? { clientId } : {} };
+        s.steers.set(id, entry);
+        try {
+          const kiroId = await proc.steer(s.sessionId, message, id);
+          if (kiroId && kiroId !== id && s.steers.delete(id)) s.steers.set(kiroId, entry);
+        } catch (err) {
+          s.steers.delete(id);
+          throw err;
+        }
+      }
+      /** kiro read the steers `ids` into the turn, or dropped them. kiro names a steer
+       *  `steer-<the id it was given>`. */
+      steerSettled(s, injected, ids) {
+        for (const raw of ids) {
+          if (!raw) continue;
+          const id = s.steers.has(raw) ? raw : raw.replace(/^steer-/, "");
+          const entry = s.steers.get(id);
+          if (!entry) continue;
+          s.steers.delete(id);
+          s.record({ kind: injected ? "steer_injected" : "steer_dropped", text: entry.text, ...entry.clientId ? { clientId: entry.clientId } : {} });
+          if (injected && s.lastTurn) s.lastTurn.output = true;
+        }
+      }
+      /** At a turn's end, drops the steers the model never read, so none waits in kiro for a
+       *  later turn the user did not mean it for. */
+      async dropSteers(s, proc) {
+        if (s.steers.size === 0) return;
+        await proc.clearSteers(s.sessionId).catch(() => {
+        });
+        this.steerSettled(s, false, [...s.steers.keys()]);
+      }
+      /**
+       * Before a retry, removes the failed turn it retries when kiro kept nothing of it but the
+       * prompt, so the model does not read that prompt twice. A turn that did anything is left:
+       * kiro's rewind would also undo the files it changed.
+       */
+      async dropFailedTurn(chatId, s, proc) {
+        const last = s.lastTurn;
+        if (!last?.failed || last.output || !last.messageId) return;
+        s.lastTurn = void 0;
+        try {
+          const stamps = await promptStamps(s.sessionId);
+          const ordinal = stamps.findIndex((p) => p.id === last.messageId);
+          if (ordinal < 0 || !await proc.revertTo(s.sessionId, last.messageId)) return;
+          this.store.dropHistory(chatId, { prompts: ordinal, from: (stamps[ordinal].atMs ?? Date.now()) - STAMP_PAD_MS });
+          s.record({ kind: "history_replaced" });
+          this.log.info({ chatId, messageId: last.messageId }, "failed turn removed before its retry");
+        } catch (err) {
+          this.log.warn({ err, chatId }, "could not remove the failed turn before its retry");
+        }
+      }
       saveEnding(chatId, ending) {
         if (!ending) return;
         try {
@@ -2467,12 +3080,65 @@ ${tail}` : err.message;
         s.modelId = modelId;
         s.lastActivity = Date.now();
       }
+      async setEffort(chatId, effortLevel) {
+        const s = await this.ensureOpen(chatId);
+        await this.settleReload(s);
+        const proc = await this.ensureProc(s);
+        await proc.setEffort(s.sessionId, effortLevel);
+        s.effortLevel = effortLevel;
+        s.lastActivity = Date.now();
+      }
+      /**
+       * What the chat has cost and the plan it counts against. Asks kiro for the context
+       * breakdown too, which it reports only during a turn, and records it as metadata. Both
+       * need a kiro process, so a dormant chat is started.
+       */
+      async getUsage(chatId) {
+        const s = await this.ensureOpen(chatId);
+        await this.settleReload(s);
+        const proc = await this.ensureProc(s);
+        s.lastActivity = Date.now();
+        const [raw, account, filed] = await Promise.all([
+          proc.contextBreakdown(s.sessionId).catch(() => void 0),
+          this.accountUsage(proc),
+          sessionCredits(s.sessionId).catch(() => void 0)
+        ]);
+        const contextBreakdown = contextBreakdownOf(raw);
+        if (contextBreakdown) s.record({ kind: "metadata", params: { sessionId: s.sessionId, contextBreakdown } });
+        const credits = Math.max(s.credits ?? 0, filed ?? 0);
+        return { ...s.credits !== void 0 || filed !== void 0 ? { credits } : {}, ...account ? { account } : {} };
+      }
+      // The plan changes slowly and each read is a call to kiro's service, so it is kept a minute.
+      account;
+      async accountUsage(proc) {
+        if (this.account && Date.now() - this.account.at < 6e4) return this.account.value;
+        const value = accountUsageOf(await proc.accountUsage().catch(() => void 0));
+        this.account = { at: Date.now(), value };
+        return value;
+      }
+      /** 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. */
@@ -2483,7 +3149,8 @@ ${tail}` : err.message;
           chatId: chat.chatId,
           sessionId: live?.sessionId ?? chat.sessionId ?? void 0,
           title: this.titleOf(chat, {
-            kiroTitle: persisted?.title || live?.title,
+            // A live session hears kiro's new title before kiro writes its file.
+            kiroTitle: live?.title || persisted?.title,
             firstPrompt: transcript && firstPromptText(transcript),
             cwd
           }),
@@ -2493,20 +3160,22 @@ ${tail}` : err.message;
           liveness: live?.proc ? "live" : "dormant",
           agentId: live?.agentId ?? persisted?.agentId,
           modelId: live?.modelId ?? persisted?.modelId,
+          effortLevel: live ? live.effortLevel : persisted?.effortLevel,
           running: live?.running ?? false,
+          pinned: chat.pinned,
           // A dormant session falls back to kiro's file.
           contextUsagePercentage: snap?.contextUsagePercentage || persisted?.contextUsagePercentage
         };
       }
       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;
@@ -2549,68 +3218,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),
@@ -2619,16 +3256,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--) {
@@ -2637,18 +3277,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 (it.type === "message" && it.message.role === "user" && !it.message.steer) {
+            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);
@@ -2671,14 +3312,159 @@ ${tail}` : err.message;
         await removeChatDir(chatId);
         if (!sessionId) return;
         this.evict(sessionId);
-        await deletePersistedSession(sessionId);
+        await this.forgetSession(sessionId);
+      }
+      /** Deletes a session's files from kiro's store. */
+      async forgetSession(sessionId) {
+        await deletePersistedSession(sessionId).catch((err) => {
+          this.log.warn({ err, sessionId }, "could not delete a kiro session");
+        });
         setTimeout(() => void deletePersistedSession(sessionId).catch(() => {
         }), 2500).unref?.();
       }
       disposeAll() {
         for (const id of [...this.sessions.keys()]) this.evict(id);
       }
-    };
+    };
+  }
+});
+
+// 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 configuredEfforts() {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const { stdout } = await execFileAsync2(config.kiroBin, ["settings", "chat.modelDefaults", "-f", "json"]);
+    const value = JSON.parse(stdout);
+    if (!value || typeof value !== "object") return out;
+    for (const [modelId, settings] of Object.entries(value)) {
+      if (!settings || typeof settings !== "object") continue;
+      for (const section of Object.values(settings)) {
+        const effort = section?.effort;
+        if (typeof effort === "string" && effort) {
+          out.set(modelId, effort);
+          break;
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function withKiroDetails(m, known) {
+  const k = known.get(m.modelId);
+  if (!k) return m;
+  const named = k.name ? { ...m, modelName: k.name } : m;
+  if (k.levels.length === 0) return named;
+  const own = userEfforts.get(m.modelId);
+  const fallback = k.recommended && k.levels.includes(k.recommended) ? k.recommended : void 0;
+  return {
+    ...named,
+    effortLevels: k.levels,
+    recommendedEffort: fallback,
+    defaultEffort: own && k.levels.includes(own) ? own : fallback
+  };
+}
+async function listModels(log) {
+  if (!cache2) await loadModels(log);
+  const known = kiroModels();
+  return cache2.map((m) => withKiroDetails(m, known));
+}
+async function loadModels(log) {
+  const { stdout } = await execFileAsync2(
+    config.kiroBin,
+    ["chat", "--list-models", "-f", "json"],
+    { maxBuffer: 4 * 1024 * 1024 }
+  );
+  const parsed = JSON.parse(stdout);
+  const [configured, efforts] = await Promise.all([configuredDefault(), configuredEfforts()]);
+  userEfforts = efforts;
+  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");
+}
+async function defaultModelId(log) {
+  try {
+    return (await listModels(log)).find((m) => m.isDefault)?.modelId;
+  } catch {
+    return void 0;
+  }
+}
+async function defaultEffortFor(modelId, log) {
+  if (!modelId) return void 0;
+  try {
+    return (await listModels(log)).find((m) => m.modelId === modelId)?.defaultEffort;
+  } catch {
+    return void 0;
+  }
+}
+function invalidateModels() {
+  cache2 = null;
+}
+async function kiroSetting(key, value) {
+  await execFileAsync2(config.kiroBin, ["settings", key, value]);
+}
+async function setDefaultModel(modelId, log) {
+  if (!(await listModels(log)).some((m) => m.modelId === modelId)) throw new Error(`Unknown model: ${modelId}`);
+  await kiroSetting("chat.defaultModel", modelId);
+  invalidateModels();
+}
+async function setDefaultEffort(modelId, level, log) {
+  const model = (await listModels(log)).find((m) => m.modelId === modelId);
+  if (!model?.effortLevels?.includes(level)) throw new Error(`${modelId} has no effort level ${level}`);
+  let all = {};
+  try {
+    const { stdout } = await execFileAsync2(config.kiroBin, ["settings", "chat.modelDefaults", "-f", "json"]);
+    const value = JSON.parse(stdout);
+    if (value && typeof value === "object" && !Array.isArray(value)) all = value;
+  } catch {
+  }
+  const entry = { ...all[modelId] ?? {} };
+  const section = Object.keys(entry).find((k) => typeof entry[k]?.effort === "string") ?? kiroModels().get(modelId)?.effortKey ?? (modelId.startsWith("claude") ? "output_config" : "reasoning");
+  entry[section] = { ...entry[section] ?? {}, effort: level };
+  await kiroSetting("chat.modelDefaults", JSON.stringify({ ...all, [modelId]: entry }));
+  invalidateModels();
+}
+async function kiroVersion() {
+  try {
+    const { stdout } = await execFileAsync2(config.kiroBin, ["--version"]);
+    return stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+var execFileAsync2, cache2, userEfforts;
+var init_models = __esm({
+  "server/src/session/models.ts"() {
+    "use strict";
+    init_config();
+    init_kiroModels();
+    execFileAsync2 = promisify2(execFile2);
+    cache2 = null;
+    userEfforts = /* @__PURE__ */ new Map();
   }
 });
 
@@ -2828,81 +3614,157 @@ 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() {
+// server/src/routes/models.ts
+function registerModelRoutes(app) {
+  app.get("/api/models", async () => {
+    const models = await listModels(app.log);
+    return { models };
+  });
+}
+var init_models2 = __esm({
+  "server/src/routes/models.ts"() {
+    "use strict";
+    init_models();
+  }
+});
+
+// server/src/session/kiroTools.ts
+import { execFile as execFile3 } from "node:child_process";
+import fs12 from "node:fs/promises";
+import path13 from "node:path";
+import { promisify as promisify3 } from "node:util";
+function kiroHome() {
+  return path13.dirname(config.kiroSessionsDir);
+}
+async function readSetting(key) {
   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;
+    const { stdout } = await execFileAsync3(config.kiroBin, ["settings", key, "-f", "json"]);
+    return JSON.parse(stdout);
   } 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
+async function writeSetting(key, value) {
+  await execFileAsync3(config.kiroBin, ["settings", key, value]);
+}
+async function configuredDefaultAgent() {
+  if (agentCache && Date.now() - agentCache.at < 3e4) return agentCache.value;
+  const value = await readSetting("chat.defaultAgent");
+  agentCache = { at: Date.now(), value: typeof value === "string" && value ? value : void 0 };
+  return agentCache.value;
+}
+async function setDefaultAgent(agentId) {
+  await writeSetting("chat.defaultAgent", agentId);
+  agentCache = null;
+}
+async function readMcp() {
+  try {
+    const value = JSON.parse(await fs12.readFile(mcpFile(), "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw new Error(`Could not read ${mcpFile()}: ${err.message}`);
+  }
+}
+async function writeMcp(data) {
+  const file = mcpFile();
+  await fs12.mkdir(path13.dirname(file), { recursive: true });
+  const mode = await fs12.stat(file).then((s) => s.mode & 511, () => 384);
+  const tmp = `${file}.casper-${process.pid}`;
+  await fs12.writeFile(tmp, `${JSON.stringify(data, null, 2)}
+`, { mode });
+  await fs12.rename(tmp, file);
+}
+async function listMcpServers() {
+  const servers = (await readMcp()).mcpServers ?? {};
+  return Object.entries(servers).map(([name, s]) => ({
+    name,
+    ...typeof s.command === "string" ? { command: s.command } : {},
+    ...typeof s.url === "string" ? { url: s.url } : {},
+    args: strings(s.args),
+    envKeys: s.env && typeof s.env === "object" ? Object.keys(s.env) : [],
+    disabled: s.disabled === true
   }));
-  log.info({ count: cache2.length, default: preferred }, "loaded model list");
-  return cache2;
 }
-async function kiroVersion() {
+async function addMcpServer(input) {
+  const name = String(input.name ?? "").trim();
+  if (!SERVER_NAME.test(name)) throw new Error("A name is letters, digits, dots, dashes and underscores");
+  const command = typeof input.command === "string" ? input.command.trim() : "";
+  const url4 = typeof input.url === "string" ? input.url.trim() : "";
+  if (!!command === !!url4) throw new Error("Give either a command or a URL");
+  if (url4 && !/^https?:\/\//.test(url4)) throw new Error("The URL must start with http:// or https://");
+  const args = strings(input.args);
+  const env2 = {};
+  for (const [k, v] of Object.entries(input.env ?? {})) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k) || typeof v !== "string") throw new Error(`Bad environment variable: ${k}`);
+    env2[k] = v;
+  }
+  const data = await readMcp();
+  const servers = { ...data.mcpServers ?? {} };
+  if (servers[name]) throw new Error(`A server named ${name} already exists`);
+  servers[name] = { ...url4 ? { url: url4 } : { command, args }, ...Object.keys(env2).length ? { env: env2 } : {} };
+  await writeMcp({ ...data, mcpServers: servers });
+}
+async function setMcpServerDisabled(name, disabled) {
+  const data = await readMcp();
+  const entry = data.mcpServers?.[name];
+  if (!entry) throw new Error(`No server named ${name}`);
+  const next = { ...entry };
+  if (disabled) next.disabled = true;
+  else delete next.disabled;
+  await writeMcp({ ...data, mcpServers: { ...data.mcpServers, [name]: next } });
+}
+async function removeMcpServer(name) {
+  const data = await readMcp();
+  if (!data.mcpServers?.[name]) throw new Error(`No server named ${name}`);
+  const { [name]: _removed, ...rest } = data.mcpServers;
+  await writeMcp({ ...data, mcpServers: rest });
+}
+function frontMatter(text2) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text2);
+  const out = {};
+  for (const line of m?.[1]?.split(/\r?\n/) ?? []) {
+    const kv = /^([A-Za-z_-]+):\s*(.*)$/.exec(line);
+    if (kv) out[kv[1]] = kv[2].replace(/^["']|["']$/g, "").trim();
+  }
+  return out;
+}
+async function listSkills() {
+  const dir = path13.join(kiroHome(), "skills");
+  let entries;
   try {
-    const { stdout } = await execFileAsync2(config.kiroBin, ["--version"]);
-    return stdout.trim();
+    entries = (await fs12.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
   } catch {
-    return void 0;
+    return [];
   }
-}
-var execFileAsync2, cache2;
-var init_models = __esm({
-  "server/src/session/models.ts"() {
-    "use strict";
-    init_config();
-    execFileAsync2 = promisify2(execFile2);
-    cache2 = null;
+  const out = [];
+  for (const name of entries.sort()) {
+    const file = path13.join(dir, name, "SKILL.md");
+    try {
+      const meta = frontMatter(await fs12.readFile(file, "utf8"));
+      out.push({ name: meta.name || name, description: meta.description ?? "", path: file });
+    } catch {
+    }
   }
-});
-
-// server/src/routes/models.ts
-function registerModelRoutes(app) {
-  app.get("/api/models", async () => {
-    const models = await listModels(app.log);
-    return { models };
-  });
+  return out;
 }
-var init_models2 = __esm({
-  "server/src/routes/models.ts"() {
+var execFileAsync3, mcpFile, agentCache, strings, SERVER_NAME;
+var init_kiroTools = __esm({
+  "server/src/session/kiroTools.ts"() {
     "use strict";
-    init_models();
+    init_config();
+    execFileAsync3 = promisify3(execFile3);
+    mcpFile = () => path13.join(kiroHome(), "settings", "mcp.json");
+    agentCache = null;
+    strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+    SERVER_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
   }
 });
 
 // server/src/routes/agents.ts
 function registerAgentRoutes(app) {
   app.get("/api/agents", async () => {
-    return { agents: await listAgents(), defaultAgentId: config.defaultAgent };
+    return { agents: await listAgents(), defaultAgentId: await configuredDefaultAgent() ?? config.defaultAgent };
   });
 }
 var init_agents2 = __esm({
@@ -2910,12 +3772,13 @@ var init_agents2 = __esm({
     "use strict";
     init_agents();
     init_config();
+    init_kiroTools();
   }
 });
 
 // server/src/util/confinedFile.ts
-import fs11 from "node:fs/promises";
-import path12 from "node:path";
+import fs13 from "node:fs/promises";
+import path14 from "node:path";
 async function resolveConfined(input, spec) {
   let target = null;
   for (const root of spec.lexical) {
@@ -2931,7 +3794,7 @@ async function resolveConfined(input, spec) {
   if (!real) return { ok: false, ...await spec.notFound() };
   let stat;
   try {
-    stat = await fs11.stat(real);
+    stat = await fs13.stat(real);
   } catch {
     return { ok: false, ...await spec.notFound() };
   }
@@ -2970,7 +3833,7 @@ async function resolveChatPath(sessions, sessionId, requestedPath, require2) {
 async function workspaceNotFound(cwd) {
   let missing;
   try {
-    missing = !(await fs11.stat(cwd)).isDirectory();
+    missing = !(await fs13.stat(cwd)).isDirectory();
   } catch {
     missing = true;
   }
@@ -2990,7 +3853,7 @@ async function resolveAbsolutePath(input, require2) {
   });
 }
 async function classifyDirent(parentReal, entry, realRoots) {
-  const absolute = path12.join(parentReal, entry.name);
+  const absolute = path14.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;
@@ -2998,7 +3861,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 fs13.stat(real);
       if (stat.isDirectory()) return { kind: "directory", real };
       if (stat.isFile()) return { kind: "file", real };
     } catch {
@@ -3016,7 +3879,7 @@ var init_confinedFile = __esm({
 });
 
 // server/src/util/filekind.ts
-import path13 from "node:path";
+import path15 from "node:path";
 function mimeForExt(ext) {
   return MIME_MAP[ext.toLowerCase()] ?? "application/octet-stream";
 }
@@ -3036,7 +3899,7 @@ function looksBinary(buf) {
   return control / buf.length > 0.3;
 }
 function classifyKind(name) {
-  const ext = path13.extname(name).toLowerCase();
+  const ext = path15.extname(name).toLowerCase();
   if (ext in IMAGE_EXTS) return "image";
   if (TEXT_EXTS.has(ext)) return "text";
   return "binary";
@@ -3146,9 +4009,9 @@ var init_filekind = __esm({
 });
 
 // server/src/routes/filePreview.ts
-import fs12 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import path14 from "node:path";
+import path16 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)`
@@ -3175,7 +4038,7 @@ function hexdump(buf) {
   return lines.join("\n");
 }
 async function sendFilePreview(req, reply, realTarget, stat) {
-  const ext = path14.extname(realTarget).toLowerCase();
+  const ext = path16.extname(realTarget).toLowerCase();
   const mime = mimeForExt(ext);
   const isImage2 = mime.startsWith("image/");
   const isPdf = mime === "application/pdf";
@@ -3220,7 +4083,7 @@ async function sendFilePreview(req, reply, realTarget, stat) {
   if (kind === "binary") {
     let fh;
     try {
-      fh = await fs12.open(realTarget, "r");
+      fh = await fs14.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);
@@ -3264,9 +4127,9 @@ var init_filePreview = __esm({
 });
 
 // server/src/routes/fs.ts
-import fs13 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import { createReadStream as createReadStream2 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 function registerFsRoutes(app) {
   app.get(
     "/api/fs/dirs",
@@ -3274,10 +4137,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 ? path17.resolve(base, input) : base;
+      const dir = endsWithSep || !input ? resolved : path17.dirname(resolved);
+      const prefix = endsWithSep || !input ? "" : path17.basename(resolved);
+      const targetKind = await fs15.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);
@@ -3286,7 +4149,7 @@ function registerFsRoutes(app) {
       const realDir = listing.real;
       let entries = [];
       try {
-        const dirents = await fs13.readdir(realDir, { withFileTypes: true });
+        const dirents = await fs15.readdir(realDir, { withFileTypes: true });
         const checks2 = await Promise.all(
           dirents.map(async (d) => {
             const target = await classifyDirent(realDir, d, absoluteRoots());
@@ -3297,7 +4160,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) => path17.join(dir, name));
       } catch {
         entries = [];
       }
@@ -3312,7 +4175,7 @@ function registerFsRoutes(app) {
         reply.code(400);
         return { error: "path parameter is required" };
       }
-      if (!path15.isAbsolute(filePath)) {
+      if (!path17.isAbsolute(filePath)) {
         reply.code(400);
         return { error: "path must be absolute" };
       }
@@ -3322,7 +4185,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="${path17.basename(resolved.real).replace(/"/g, "")}"`
         );
         reply.header("Content-Length", resolved.stat.size);
         return reply.send(createReadStream2(resolved.real));
@@ -3352,8 +4215,8 @@ function registerChatRoutes(app, manager) {
         cwd: body.cwd,
         agentId: body.agentId,
         modelId: body.modelId,
+        effortLevel: body.effortLevel,
         freshWorkspace: body.freshWorkspace,
-        title: body.title,
         // Not optional in practice: the client's chat already owns any file uploaded before
         // the session existed, so dropping it here strands those files under an id nothing
         // refers to again.
@@ -3412,6 +4275,47 @@ function registerChatRoutes(app, manager) {
       return { ok: true };
     }
   );
+  app.post(
+    "/api/chats/:id/effort",
+    async (req) => {
+      await manager.setEffort(req.params.id, req.body.effortLevel);
+      return { ok: true };
+    }
+  );
+  app.get("/api/chats/:id/usage", async (req, reply) => {
+    try {
+      return await manager.getUsage(req.params.id);
+    } catch (err) {
+      reply.code(400);
+      return { error: err.message };
+    }
+  });
+  app.post("/api/chats/:id/branch", async (req, reply) => {
+    const messageId = req.body?.messageId;
+    if (typeof messageId !== "string" || !messageId) {
+      reply.code(400);
+      return { error: "messageId is required" };
+    }
+    try {
+      return await manager.branchChat(req.params.id, messageId);
+    } catch (err) {
+      reply.code(400);
+      return { error: err.message };
+    }
+  });
+  app.post("/api/chats/:id/rewind", async (req, reply) => {
+    const messageId = req.body?.messageId;
+    if (typeof messageId !== "string" || !messageId) {
+      reply.code(400);
+      return { error: "messageId is required" };
+    }
+    try {
+      return await manager.rewindChat(req.params.id, messageId);
+    } catch (err) {
+      reply.code(400);
+      return { error: err.message };
+    }
+  });
   app.post(
     "/api/chats/:id/mode",
     async (req) => {
@@ -3426,6 +4330,22 @@ function registerChatRoutes(app, manager) {
       return { ok: true };
     }
   );
+  app.post(
+    "/api/chats/:id/pin",
+    async (req, reply) => {
+      if (typeof req.body?.pinned !== "boolean") {
+        reply.code(400);
+        return { error: "pinned must be true or false" };
+      }
+      try {
+        manager.pinChat(req.params.id, req.body.pinned);
+        return { ok: true };
+      } catch (err) {
+        reply.code(404);
+        return { error: err.message };
+      }
+    }
+  );
   app.post(
     "/api/chats/:id/cwd",
     async (req, reply) => {
@@ -3493,9 +4413,9 @@ var init_subagents = __esm({
 });
 
 // server/src/routes/workspace.ts
-import fs14 from "node:fs/promises";
+import fs16 from "node:fs/promises";
 import { createReadStream as createReadStream3 } from "node:fs";
-import path16 from "node:path";
+import path18 from "node:path";
 function registerWorkspaceRoutes(app, manager) {
   app.get(
     "/api/chats/:id/tree",
@@ -3510,7 +4430,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 fs16.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return replyWith(reply, await workspaceNotFound(cwd));
       }
@@ -3524,7 +4444,7 @@ function registerWorkspaceRoutes(app, manager) {
           continue;
         }
         try {
-          const stat = await fs14.stat(target.real);
+          const stat = await fs16.stat(target.real);
           entries.push({
             name: d.name,
             path: entryRelative,
@@ -3553,8 +4473,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 = path18.extname(realTarget);
+      const filename = path18.basename(realTarget);
       const asciiName = filename.replace(/[^\w.\-]/g, "_");
       reply.header("Content-Type", mimeForExt(ext));
       reply.header(
@@ -3589,27 +4509,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 fs17 from "node:fs/promises";
+import path19 from "node:path";
 import crypto4 from "node:crypto";
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
 function sanitizeName(raw) {
-  const base = path17.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
+  const base = path19.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 = path19.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 fs17.access(path19.join(dir, candidate));
       candidate = `${stem} (${n++})${ext}`;
     } catch {
-      return path17.join(dir, candidate);
+      return path19.join(dir, candidate);
     }
   }
 }
@@ -3621,7 +4541,7 @@ function sha256File(absPath) {
 }
 function fileType(absPath) {
   return new Promise((resolve) => {
-    execFile3("file", ["-b", absPath], { timeout: 5e3 }, (err, stdout) => {
+    execFile4("file", ["-b", absPath], { timeout: 5e3 }, (err, stdout) => {
       resolve(err ? "" : stdout.trim());
     });
   });
@@ -3629,7 +4549,7 @@ function fileType(absPath) {
 async function sampleStrings(absPath, limit = 40) {
   let fh;
   try {
-    fh = await fs15.open(absPath, "r");
+    fh = await fs17.open(absPath, "r");
     const buf = Buffer.alloc(STRINGS_SCAN_BYTES);
     const { bytesRead } = await fh.read(buf, 0, STRINGS_SCAN_BYTES, 0);
     const out = [];
@@ -3661,7 +4581,7 @@ function registerUploadRoutes(app) {
         return { error: "Invalid chat id" };
       }
       const uploadDir = chatUploadsDir(req.params.chatId);
-      await fs15.mkdir(uploadDir, { recursive: true, mode: 448 });
+      await fs17.mkdir(uploadDir, { recursive: true, mode: 448 });
       const results = [];
       const parts = req.files();
       for await (const part of parts) {
@@ -3675,24 +4595,24 @@ function registerUploadRoutes(app) {
           return { error: `Failed to store ${name}` };
         }
         if (part.file.truncated) {
-          await fs15.rm(dest, { force: true });
+          await fs17.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 fs17.stat(dest);
+        const ext = path19.extname(dest);
         const kind = classifyKind(dest);
         const uploaded = {
-          name: path17.basename(dest),
+          name: path19.basename(dest),
           path: dest,
           size: stat.size,
           mimeType: mimeForExt(ext),
           kind
         };
         if (kind === "binary") {
-          const [type, sha2562, strings] = await Promise.all([
+          const [type, sha2562, strings2] = await Promise.all([
             fileType(dest),
             sha256File(dest),
             sampleStrings(dest)
@@ -3700,7 +4620,7 @@ function registerUploadRoutes(app) {
           uploaded.triage = {
             fileType: type || void 0,
             sha256: sha2562,
-            strings: strings.length ? strings : void 0
+            strings: strings2.length ? strings2 : void 0
           };
         }
         results.push(uploaded);
@@ -3722,6 +4642,78 @@ var init_uploads = __esm({
   }
 });
 
+// server/src/routes/settings.ts
+function registerSettingsRoutes(app, manager, startedAt) {
+  app.get("/api/settings", async () => ({
+    defaultAgentId: await configuredDefaultAgent() ?? config.defaultAgent,
+    // The token is left out: it is a secret, and the page has no use for it.
+    server: {
+      version: VERSION,
+      kiroVersion: await kiroVersion(),
+      kiroBin: config.kiroBin,
+      host: config.host,
+      port: config.port,
+      authEnabled: Boolean(config.token),
+      fileRoot: config.fileRoot,
+      defaultCwd: config.defaultCwd,
+      dataDir: config.casperDataDir,
+      configFile: config.configFile,
+      maxLiveSessions: config.maxLiveSessions,
+      liveSessions: manager.liveCount,
+      uptimeMs: Date.now() - startedAt
+    }
+  }));
+  app.put(
+    "/api/settings/defaults",
+    (req, reply) => answer(reply, async () => {
+      const body = req.body ?? {};
+      if (body.agentId !== void 0) {
+        const agentId = String(body.agentId);
+        if (!(await listAgents()).some((a) => a.id === agentId)) throw new Error(`Unknown agent: ${agentId}`);
+        await setDefaultAgent(agentId);
+      }
+      if (body.modelId !== void 0) await setDefaultModel(String(body.modelId), app.log);
+      if (body.effort) await setDefaultEffort(String(body.effort.modelId), String(body.effort.level), app.log);
+    })
+  );
+  app.get("/api/tools", async () => {
+    const [mcpServers, skills] = await Promise.all([listMcpServers(), listSkills()]);
+    return { mcpServers, skills };
+  });
+  app.post(
+    "/api/tools/mcp",
+    (req, reply) => answer(reply, () => addMcpServer(req.body ?? { name: "" }))
+  );
+  app.put(
+    "/api/tools/mcp/:name",
+    (req, reply) => answer(reply, () => setMcpServerDisabled(req.params.name, req.body?.disabled === true))
+  );
+  app.delete(
+    "/api/tools/mcp/:name",
+    (req, reply) => answer(reply, () => removeMcpServer(req.params.name))
+  );
+}
+async function answer(reply, fn) {
+  try {
+    await fn();
+    return { ok: true };
+  } catch (err) {
+    reply.code(400);
+    return { error: err.message };
+  }
+}
+var VERSION;
+var init_settings2 = __esm({
+  "server/src/routes/settings.ts"() {
+    "use strict";
+    init_config();
+    init_agents();
+    init_models();
+    init_kiroTools();
+    VERSION = true ? "0.17.0" : "dev";
+  }
+});
+
 // server/src/routes/health.ts
 function registerHealthRoute(app, manager, startedAt) {
   app.get("/api/health", async () => {
@@ -3741,7 +4733,7 @@ var init_health = __esm({
 });
 
 // server/src/ws/dirWatchers.ts
-import fs16 from "node:fs";
+import fs18 from "node:fs";
 function diffWatchSet(current, next) {
   const have = new Set(current);
   const want = new Set(next.slice(0, MAX_WATCHES));
@@ -3765,7 +4757,7 @@ function createDirWatchers(opts) {
     const target = await opts.resolve(relative);
     if (!target || closed) return;
     try {
-      const watcher = fs16.watch(target, { persistent: false }, () => {
+      const watcher = fs18.watch(target, { persistent: false }, () => {
         const existing = timers.get(relative);
         if (existing) clearTimeout(existing);
         timers.set(
@@ -3823,7 +4815,7 @@ function handleConnection(socket, manager, chatId, startCursor) {
         return null;
       }
     },
-    onChange: (path20) => send(socket, { type: "fs_changed", path: path20 })
+    onChange: (path22) => send(socket, { type: "fs_changed", path: path22 })
   });
   const forward = (event) => {
     if (event.seq <= cursor) return;
@@ -3874,13 +4866,20 @@ function handleConnection(socket, manager, chatId, startCursor) {
       case "watch_paths":
         return watchers.sync(msg.paths);
       case "prompt":
-        return ack("prompt", () => manager.runPrompt(chatId, msg.content, msg.attachments));
+        return ack("prompt", () => manager.runPrompt(chatId, msg.content, msg.attachments, { retry: msg.retry === true }));
+      case "steer":
+        return ack(
+          "steer",
+          () => manager.steer(chatId, String(msg.text ?? ""), typeof msg.clientId === "string" ? msg.clientId : void 0)
+        );
       case "cancel":
         return ack("cancel", () => manager.cancel(chatId));
       case "set_mode":
         return ack("set_mode", () => manager.setMode(chatId, msg.modeId));
       case "set_model":
         return ack("set_model", () => manager.setModel(chatId, msg.modelId));
+      case "set_effort":
+        return ack("set_effort", () => manager.setEffort(chatId, msg.effortLevel));
       case "exec_command":
         return ack(
           "exec_command",
@@ -3956,7 +4955,7 @@ var init_gateway = __esm({
 });
 
 // server/src/app.ts
-import fs17 from "node:fs";
+import fs19 from "node:fs";
 import Fastify from "fastify";
 import websocket from "@fastify/websocket";
 import fastifyStatic from "@fastify/static";
@@ -3975,7 +4974,11 @@ 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),
+    defaultEffort: (modelId) => defaultEffortFor(modelId, logger),
+    defaultAgent: configuredDefaultAgent
+  });
   const startedAt = Date.now();
   await app.register(websocket, {
     options: { maxPayload: 16 * 1024 * 1024 }
@@ -3986,6 +4989,7 @@ async function buildApp() {
   await registerAuth(app);
   registerHealthRoute(app, manager, startedAt);
   registerModelRoutes(app);
+  registerSettingsRoutes(app, manager, startedAt);
   registerAgentRoutes(app);
   registerFsRoutes(app);
   registerChatRoutes(app, manager);
@@ -3993,20 +4997,20 @@ async function buildApp() {
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app);
   registerWsGateway(app, manager);
-  if (fs17.existsSync(config.webDist)) {
+  if (fs19.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 path22 = req.url.split("?")[0] ?? "";
+      if (path22 === "/manifest.json" || path22.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 path22 = req.url.split("?")[0] ?? "";
+      const looksLikeAsset = path22.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path22);
+      if (path22.startsWith("/api/") || path22.startsWith("/ws") || looksLikeAsset) {
         reply.code(404).send({ error: "Not found" });
         return;
       }
@@ -4021,6 +5025,7 @@ var init_app = __esm({
     init_config();
     init_logger();
     init_SessionManager();
+    init_models();
     init_auth();
     init_models2();
     init_agents2();
@@ -4029,6 +5034,8 @@ var init_app = __esm({
     init_subagents();
     init_workspace();
     init_uploads();
+    init_settings2();
+    init_kiroTools();
     init_health();
     init_gateway();
   }
@@ -4077,19 +5084,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 fs20 from "node:fs";
+import os4 from "node:os";
+import path20 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 fs20.existsSync(bin) ? bin : void 0;
+  for (const dir of (process.env.PATH ?? "").split(path20.delimiter)) {
     if (dir === "") continue;
-    const candidate = path18.join(dir, bin);
+    const candidate = path20.join(dir, bin);
     try {
-      fs18.accessSync(candidate, fs18.constants.X_OK);
+      fs20.accessSync(candidate, fs20.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -4113,11 +5123,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 && !fs20.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({
@@ -4133,7 +5160,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,
@@ -4145,7 +5175,7 @@ function checks() {
   const settings = readSettings(config.configFile);
   const hasToken = typeof settings.token === "string" && settings.token !== "";
   out.push(
-    fs18.existsSync(config.configFile) ? {
+    fs20.existsSync(config.configFile) ? {
       ok: hasToken,
       name: "settings",
       detail: hasToken ? `${config.configFile} (token set)` : `${config.configFile} exists but has no token - auth is DISABLED`
@@ -4155,8 +5185,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 (fs20.existsSync(config.configFile)) {
+    const mode = fs20.statSync(config.configFile).mode & 511;
     out.push({
       ok: mode === 384,
       name: "settings mode",
@@ -4164,10 +5194,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` : "";
+    fs20.mkdirSync(config.casperDataDir, { recursive: true });
+    fs20.accessSync(config.casperDataDir, fs20.constants.W_OK);
+    const db2 = path20.join(config.casperDataDir, "casper.db");
+    const size = fs20.existsSync(db2) ? `, casper.db ${(fs20.statSync(db2).size / 1024).toFixed(0)} KB` : "";
     out.push({ ok: true, name: "data dir", detail: `${config.casperDataDir} writable${size}` });
   } catch (err) {
     out.push({
@@ -4178,22 +5208,25 @@ function checks() {
     });
   }
   out.push(
-    fs18.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
+    fs20.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 = path20.join(os4.homedir(), ".kiro", "agents", "casper.json");
+  const hasAgent = fs20.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 = fs20.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;
@@ -4506,7 +5539,7 @@ function handleMessage(req, version) {
       return ok(id, {
         protocolVersion: asked ?? DEFAULT_PROTOCOL_VERSION,
         capabilities: { tools: { listChanged: false } },
-        serverInfo: { name: SERVER_NAME, version }
+        serverInfo: { name: SERVER_NAME2, version }
       });
     }
     case "ping":
@@ -4526,14 +5559,14 @@ function handleMessage(req, version) {
       return { jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown method: ${method}` } };
   }
 }
-var DEFAULT_PROTOCOL_VERSION, SERVER_NAME, MAX_WIDGET_CHARS, TOOLS;
+var DEFAULT_PROTOCOL_VERSION, SERVER_NAME2, MAX_WIDGET_CHARS, TOOLS;
 var init_protocol = __esm({
   "server/src/mcp/protocol.ts"() {
     "use strict";
     init_guidelines();
     init_choice();
     DEFAULT_PROTOCOL_VERSION = "2025-06-18";
-    SERVER_NAME = "casper-generative-ui";
+    SERVER_NAME2 = "casper-generative-ui";
     MAX_WIDGET_CHARS = 256 * 1024;
     TOOLS = [
       {
@@ -4634,7 +5667,7 @@ function runMcpServer() {
       return;
     }
     try {
-      const res = handleMessage(req, VERSION);
+      const res = handleMessage(req, VERSION2);
       if (res) process.stdout.write(JSON.stringify(res) + "\n");
     } catch (err) {
       process.stderr.write(`casper-mcp: ${err.message}
@@ -4652,19 +5685,19 @@ function runMcpServer() {
   });
   rl.on("close", () => process.exit(0));
 }
-var VERSION;
+var VERSION2;
 var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.15.7" : "dev";
+    VERSION2 = true ? "0.17.0" : "dev";
   }
 });
 
 // server/src/cli/program.ts
-import fs19 from "node:fs";
-import os4 from "node:os";
-import path19 from "node:path";
+import fs21 from "node:fs";
+import os5 from "node:os";
+import path21 from "node:path";
 
 // server/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -5255,8 +6288,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.
@@ -5264,11 +6297,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] === "<")
@@ -5276,46 +6309,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.
@@ -5338,8 +6371,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.
@@ -5385,9 +6418,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) => {
@@ -5677,9 +6710,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) {
@@ -5839,14 +6872,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;
@@ -7574,18 +8607,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;
   }
@@ -7596,10 +8629,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;
     }
@@ -7611,9 +8644,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;
   }
   /**
@@ -7661,8 +8694,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);
@@ -7673,7 +8706,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.registeredArguments.length ? args : []
       ).join(" ");
     }
-    this._usage = str2;
+    this._usage = str3;
     return this;
   }
   /**
@@ -7682,9 +8715,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;
   }
   /**
@@ -7777,9 +8810,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(path22) {
+    if (path22 === void 0) return this._executableDir;
+    this._executableDir = path22;
     return this;
   }
   /**
@@ -7818,17 +8851,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 };
   }
@@ -8037,7 +9070,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.15.7" : "dev";
+var VERSION3 = true ? "0.17.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -8050,7 +9083,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}
 `);
@@ -8083,8 +9116,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 = path21.join(dataDirPath(), "casper.db");
+  if (fs21.existsSync(dbFile)) {
     const { LoginStore: LoginStore2 } = await Promise.resolve().then(() => (init_logins(), logins_exports));
     new LoginStore2().revokeAll();
     process.stdout.write("revoked all device sessions\n");
@@ -8101,7 +9134,7 @@ async function resetToken(value) {
 }
 function buildProgram() {
   const program2 = new Command();
-  program2.name("casper").description("Web client for kiro-cli over the Agent Client Protocol").version(VERSION2, "-v, --version").showHelpAfterError().addHelpText("after", `
+  program2.name("casper").description("Web client for kiro-cli over the Agent Client Protocol").version(VERSION3, "-v, --version").showHelpAfterError().addHelpText("after", `
 Settings live in ${configFilePath()}.
 Update with: npm install -g @joeyshi12/casper`);
   program2.command("start").description("run the server in the foreground").action(async () => {