@joeyshi12/casper 0.16.0 → 0.17.0

package/dist/server.js

@@ -350,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;
@@ -370,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,
@@ -400,6 +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 kiro_models (
+  model_id    TEXT PRIMARY KEY,
+  name        TEXT,
+  levels      TEXT NOT NULL,
+  recommended TEXT,
+  effort_key  TEXT
+);
 `;
   }
 });
@@ -640,6 +651,22 @@ function kiroToolName(call) {
   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"() {
@@ -653,9 +680,15 @@ var init_acp = __esm({
       sessionCancel: "session/cancel",
       sessionSetMode: "session/set_mode",
       sessionSetConfigOption: "session/set_config_option",
+      sessionFork: "session/fork",
       sessionUpdate: "session/update",
       requestPermission: "session/request_permission",
-      compact: "_kiro/session/compact"
+      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";
   }
@@ -952,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);
@@ -1116,6 +1205,8 @@ var init_KiroProcess = __esm({
       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;
@@ -1182,6 +1273,7 @@ var init_KiroProcess = __esm({
         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);
@@ -1189,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(
@@ -1210,6 +1305,50 @@ var init_KiroProcess = __esm({
           value: modelId
         });
       }
+      setEffort(sessionId, effortLevel) {
+        return this.client.request(ACP_METHODS.sessionSetConfigOption, {
+          sessionId,
+          configId: "effortLevel",
+          value: effortLevel
+        });
+      }
+      /** 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,
+          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)) {
@@ -1344,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":
@@ -1375,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"() {
@@ -1410,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. */
@@ -1550,40 +1696,45 @@ async function v3SessionDir(sessionId) {
   );
   return found.find((d) => d !== void 0);
 }
-function contextUsageOf(line) {
-  if (!line.includes('"contextUsage"')) return void 0;
+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 p = JSON.parse(line).payload;
+    const l = JSON.parse(line);
+    const p = l.payload;
     const value = isRecord(p.value) ? p.value.usagePercentage : void 0;
-    return p.type === "session_metadata" && p.key === "contextUsage" && typeof value === "number" ? value : void 0;
+    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 void 0;
   }
 }
-async function lastContextUsage(file) {
+async function readTail(file) {
+  const facts = {};
+  const done = () => facts.contextUsage !== void 0 && facts.lastPromptAt !== void 0;
   let handle2;
   try {
     handle2 = await fs9.open(file, "r");
   } catch {
-    return void 0;
+    return facts;
   }
   try {
     const { size } = await handle2.stat();
     let end = size;
     let tail = "";
-    while (end > 0 && size - end < CONTEXT_TAIL_BYTES) {
+    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; i--) {
-        const value = contextUsageOf(lines[i]);
-        if (value !== void 0) return value;
-      }
+      for (let i = lines.length - 1; i >= 0 && !done(); i--) readTailLine(lines[i], facts);
     }
-    return tail ? contextUsageOf(tail) : void 0;
+    if (tail && !done()) readTailLine(tail, facts);
+    return facts;
   } finally {
     await handle2.close();
   }
@@ -1597,15 +1748,19 @@ async function readV3Session(dir) {
   }
   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,
-    updatedAt: iso(j.lastModifiedAt) ?? 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,
-    contextUsagePercentage: await lastContextUsage(path10.join(dir, "messages.jsonl"))
+    effortLevel: j.effortLevel,
+    contextUsagePercentage: tail.contextUsage
   };
 }
 async function readLines(file, filter) {
@@ -1626,6 +1781,20 @@ async function readLines(file, filter) {
   }
   return out;
 }
+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 "";
@@ -1655,6 +1824,7 @@ async function readV3Entries(file) {
     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);
@@ -1663,9 +1833,45 @@ async function readV3Entries(file) {
     const parsed = line.timestamp ? Date.parse(line.timestamp) : NaN;
     const at = Number.isNaN(parsed) ? void 0 : parsed;
     switch (p.type) {
-      case "user":
+      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;
@@ -1813,8 +2019,15 @@ 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 readEntries(sessionId)).filter((e) => e.kind === "prompt").length;
+  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}-`;
@@ -1856,7 +2069,7 @@ function mergeTranscript(entries, attachments, endings) {
     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 } });
+      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));
@@ -1896,18 +2109,26 @@ var init_kiroFiles = __esm({
 });
 
 // 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);
@@ -1934,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;
@@ -1993,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);
@@ -2041,8 +2288,24 @@ function kiroMeta(update) {
 function sessionInfoEvent(sessionId, update) {
   const info = update._meta?.kiro;
   switch (info?.kind) {
-    case "context_usage":
-      return typeof info.usagePercentage === "number" ? { kind: "metadata", params: { sessionId, contextUsagePercentage: info.usagePercentage } } : null;
+    case "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":
@@ -2056,8 +2319,38 @@ function sessionInfoEvent(sessionId, update) {
       return null;
   }
 }
-function sessionModel(res) {
-  return res.configOptions?.find((o) => o.id === "model")?.currentValue;
+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 turnStatsOf(info) {
+  const credits = (info.promptTurnSummaries ?? []).reduce(
+    (sum, t) => sum + (typeof t?.usage === "number" && Number.isFinite(t.usage) ? t.usage : 0),
+    0
+  );
+  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 {
@@ -2074,7 +2367,7 @@ 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) {
@@ -2088,6 +2381,7 @@ var init_SessionManager = __esm({
     init_config();
     init_agents();
     init_chats();
+    init_kiroModels();
     init_paths2();
     init_KiroProcess();
     init_EventStore();
@@ -2106,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();
@@ -2153,11 +2460,15 @@ var init_SessionManager = __esm({
       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) {
@@ -2174,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) {
@@ -2284,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();
@@ -2293,7 +2608,15 @@ var init_SessionManager = __esm({
       }
       wire(s, proc) {
         proc.on("notification", (n) => {
-          if (s.replaying) return;
+          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);
+            }
+            return;
+          }
           if (n.method === KIRO_AGENT_NOT_FOUND) {
             this.log.warn({ sessionId: s.sessionId, detail: n.params }, "kiro could not use the requested agent");
             return;
@@ -2305,10 +2628,40 @@ var init_SessionManager = __esm({
           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;
+            }
+            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") {
@@ -2317,6 +2670,7 @@ var init_SessionManager = __esm({
             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) => {
@@ -2364,11 +2718,25 @@ var init_SessionManager = __esm({
             } 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: [],
-              _meta: { kiro: { modeId: s.agentId, modelId: s.modelId } }
+              _meta: { kiro: { modeId: s.agentId, modelId: s.modelId, effortLevel: s.effortLevel } }
             });
           }
           if (!s.hasBeenLive && res.sessionId !== s.sessionId) {
@@ -2379,8 +2747,13 @@ var init_SessionManager = __esm({
           s.availableModes = res.modes.availableModes;
           s.currentModeId = res.modes.currentModeId;
           s.agentId = res.modes.currentModeId ?? s.agentId;
-          s.modelId = sessionModel(res) ?? s.modelId;
+          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;
@@ -2393,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;
@@ -2412,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 ?? await this.defaultModel();
+        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 ? "" : path12.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);
       }
-      async runPrompt(chatId, content, attachments) {
+      /**
+       * 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, 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");
@@ -2451,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);
@@ -2465,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" });
@@ -2492,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 {
@@ -2541,6 +3080,42 @@ ${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) {
@@ -2574,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
           }),
@@ -2584,7 +3160,9 @@ ${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
         };
@@ -2706,7 +3284,7 @@ ${tail}` : err.message;
         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 (it.type === "message" && it.message.role === "user" && !it.message.steer) {
             if (promptText && it.message.text.trim() === promptText) cut = i;
             break;
           }
@@ -2734,7 +3312,13 @@ ${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?.();
       }
@@ -2762,15 +3346,54 @@ async function configuredDefault() {
     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) return cache2;
+  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 = await configuredDefault();
+  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,
@@ -2782,7 +3405,6 @@ async function listModels(log) {
     isDefault: preferred ? m.model_id === preferred : m.default_model ?? i === 0
   }));
   log.info({ count: cache2.length, default: preferred }, "loaded model list");
-  return cache2;
 }
 async function defaultModelId(log) {
   try {
@@ -2791,6 +3413,41 @@ async function defaultModelId(log) {
     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"]);
@@ -2799,13 +3456,15 @@ async function kiroVersion() {
     return void 0;
   }
 }
-var execFileAsync2, cache2;
+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();
   }
 });
 
@@ -2969,10 +3628,143 @@ var init_models2 = __esm({
   }
 });
 
+// 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 execFileAsync3(config.kiroBin, ["settings", key, "-f", "json"]);
+    return JSON.parse(stdout);
+  } catch {
+    return void 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
+  }));
+}
+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 {
+    entries = (await fs12.readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  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 {
+    }
+  }
+  return out;
+}
+var execFileAsync3, mcpFile, agentCache, strings, SERVER_NAME;
+var init_kiroTools = __esm({
+  "server/src/session/kiroTools.ts"() {
+    "use strict";
+    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({
@@ -2980,12 +3772,13 @@ var init_agents2 = __esm({
     "use strict";
     init_agents();
     init_config();
+    init_kiroTools();
   }
 });
 
 // server/src/util/confinedFile.ts
-import fs12 from "node:fs/promises";
-import path13 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) {
@@ -3001,7 +3794,7 @@ async function resolveConfined(input, spec) {
   if (!real) return { ok: false, ...await spec.notFound() };
   let stat;
   try {
-    stat = await fs12.stat(real);
+    stat = await fs13.stat(real);
   } catch {
     return { ok: false, ...await spec.notFound() };
   }
@@ -3040,7 +3833,7 @@ async function resolveChatPath(sessions, sessionId, requestedPath, require2) {
 async function workspaceNotFound(cwd) {
   let missing;
   try {
-    missing = !(await fs12.stat(cwd)).isDirectory();
+    missing = !(await fs13.stat(cwd)).isDirectory();
   } catch {
     missing = true;
   }
@@ -3060,7 +3853,7 @@ async function resolveAbsolutePath(input, require2) {
   });
 }
 async function classifyDirent(parentReal, entry, realRoots) {
-  const absolute = path13.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;
@@ -3068,7 +3861,7 @@ async function classifyDirent(parentReal, entry, realRoots) {
     const real = await realConfineToRoot(root, absolute);
     if (!real) continue;
     try {
-      const stat = await fs12.stat(real);
+      const stat = await fs13.stat(real);
       if (stat.isDirectory()) return { kind: "directory", real };
       if (stat.isFile()) return { kind: "file", real };
     } catch {
@@ -3086,7 +3879,7 @@ var init_confinedFile = __esm({
 });
 
 // server/src/util/filekind.ts
-import path14 from "node:path";
+import path15 from "node:path";
 function mimeForExt(ext) {
   return MIME_MAP[ext.toLowerCase()] ?? "application/octet-stream";
 }
@@ -3106,7 +3899,7 @@ function looksBinary(buf) {
   return control / buf.length > 0.3;
 }
 function classifyKind(name) {
-  const ext = path14.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";
@@ -3216,9 +4009,9 @@ var init_filekind = __esm({
 });
 
 // server/src/routes/filePreview.ts
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import path15 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)`
@@ -3245,7 +4038,7 @@ function hexdump(buf) {
   return lines.join("\n");
 }
 async function sendFilePreview(req, reply, realTarget, stat) {
-  const ext = path15.extname(realTarget).toLowerCase();
+  const ext = path16.extname(realTarget).toLowerCase();
   const mime = mimeForExt(ext);
   const isImage2 = mime.startsWith("image/");
   const isPdf = mime === "application/pdf";
@@ -3290,7 +4083,7 @@ async function sendFilePreview(req, reply, realTarget, stat) {
   if (kind === "binary") {
     let fh;
     try {
-      fh = await fs13.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);
@@ -3334,9 +4127,9 @@ var init_filePreview = __esm({
 });
 
 // server/src/routes/fs.ts
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import { createReadStream as createReadStream2 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 function registerFsRoutes(app) {
   app.get(
     "/api/fs/dirs",
@@ -3344,10 +4137,10 @@ function registerFsRoutes(app) {
       const input = (req.query.path ?? "").trim();
       const base = config.defaultCwd;
       const endsWithSep = input.endsWith("/");
-      const resolved = input ? path16.resolve(base, input) : base;
-      const dir = endsWithSep || !input ? resolved : path16.dirname(resolved);
-      const prefix = endsWithSep || !input ? "" : path16.basename(resolved);
-      const targetKind = await fs14.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
+      const 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);
@@ -3356,7 +4149,7 @@ function registerFsRoutes(app) {
       const realDir = listing.real;
       let entries = [];
       try {
-        const dirents = await fs14.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());
@@ -3367,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) => path16.join(dir, name));
+        }).slice(0, 500).map((name) => path17.join(dir, name));
       } catch {
         entries = [];
       }
@@ -3382,7 +4175,7 @@ function registerFsRoutes(app) {
         reply.code(400);
         return { error: "path parameter is required" };
       }
-      if (!path16.isAbsolute(filePath)) {
+      if (!path17.isAbsolute(filePath)) {
         reply.code(400);
         return { error: "path must be absolute" };
       }
@@ -3392,7 +4185,7 @@ function registerFsRoutes(app) {
         reply.header("Content-Type", "application/octet-stream");
         reply.header(
           "Content-Disposition",
-          `attachment; filename="${path16.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));
@@ -3422,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.
@@ -3482,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) => {
@@ -3496,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) => {
@@ -3563,9 +4413,9 @@ var init_subagents = __esm({
 });
 
 // server/src/routes/workspace.ts
-import fs15 from "node:fs/promises";
+import fs16 from "node:fs/promises";
 import { createReadStream as createReadStream3 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 function registerWorkspaceRoutes(app, manager) {
   app.get(
     "/api/chats/:id/tree",
@@ -3580,7 +4430,7 @@ function registerWorkspaceRoutes(app, manager) {
       const { cwd, relative, real: realTarget } = resolved;
       let dirents;
       try {
-        dirents = await fs15.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
+        dirents = await fs16.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return replyWith(reply, await workspaceNotFound(cwd));
       }
@@ -3594,7 +4444,7 @@ function registerWorkspaceRoutes(app, manager) {
           continue;
         }
         try {
-          const stat = await fs15.stat(target.real);
+          const stat = await fs16.stat(target.real);
           entries.push({
             name: d.name,
             path: entryRelative,
@@ -3623,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 = path17.extname(realTarget);
-      const filename = path17.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(
@@ -3659,27 +4509,27 @@ var init_workspace = __esm({
 
 // server/src/routes/uploads.ts
 import { createReadStream as createReadStream4, createWriteStream } from "node:fs";
-import fs16 from "node:fs/promises";
-import path18 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 = path18.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 = path18.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 fs16.access(path18.join(dir, candidate));
+      await fs17.access(path19.join(dir, candidate));
       candidate = `${stem} (${n++})${ext}`;
     } catch {
-      return path18.join(dir, candidate);
+      return path19.join(dir, candidate);
     }
   }
 }
@@ -3691,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());
     });
   });
@@ -3699,7 +4549,7 @@ function fileType(absPath) {
 async function sampleStrings(absPath, limit = 40) {
   let fh;
   try {
-    fh = await fs16.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 = [];
@@ -3731,7 +4581,7 @@ function registerUploadRoutes(app) {
         return { error: "Invalid chat id" };
       }
       const uploadDir = chatUploadsDir(req.params.chatId);
-      await fs16.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) {
@@ -3745,24 +4595,24 @@ function registerUploadRoutes(app) {
           return { error: `Failed to store ${name}` };
         }
         if (part.file.truncated) {
-          await fs16.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 fs16.stat(dest);
-        const ext = path18.extname(dest);
+        const stat = await fs17.stat(dest);
+        const ext = path19.extname(dest);
         const kind = classifyKind(dest);
         const uploaded = {
-          name: path18.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)
@@ -3770,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);
@@ -3792,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 () => {
@@ -3811,7 +4733,7 @@ var init_health = __esm({
 });
 
 // server/src/ws/dirWatchers.ts
-import fs17 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));
@@ -3835,7 +4757,7 @@ function createDirWatchers(opts) {
     const target = await opts.resolve(relative);
     if (!target || closed) return;
     try {
-      const watcher = fs17.watch(target, { persistent: false }, () => {
+      const watcher = fs18.watch(target, { persistent: false }, () => {
         const existing = timers.get(relative);
         if (existing) clearTimeout(existing);
         timers.set(
@@ -3893,7 +4815,7 @@ function handleConnection(socket, manager, chatId, startCursor) {
         return null;
       }
     },
-    onChange: (path21) => send(socket, { type: "fs_changed", path: path21 })
+    onChange: (path22) => send(socket, { type: "fs_changed", path: path22 })
   });
   const forward = (event) => {
     if (event.seq <= cursor) return;
@@ -3944,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",
@@ -4026,7 +4955,7 @@ var init_gateway = __esm({
 });
 
 // server/src/app.ts
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import Fastify from "fastify";
 import websocket from "@fastify/websocket";
 import fastifyStatic from "@fastify/static";
@@ -4045,7 +4974,11 @@ async function buildApp() {
       transport: isProd ? void 0 : { target: "pino/file", options: { destination: 2 } }
     }
   });
-  const manager = new SessionManager(logger, { defaultModel: () => defaultModelId(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 }
@@ -4056,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);
@@ -4063,20 +4997,20 @@ async function buildApp() {
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app);
   registerWsGateway(app, manager);
-  if (fs18.existsSync(config.webDist)) {
+  if (fs19.existsSync(config.webDist)) {
     await app.register(fastifyStatic, {
       root: config.webDist
     });
     app.addHook("onSend", async (req, reply) => {
-      const path21 = req.url.split("?")[0] ?? "";
-      if (path21 === "/manifest.json" || path21.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 path21 = req.url.split("?")[0] ?? "";
-      const looksLikeAsset = path21.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path21);
-      if (path21.startsWith("/api/") || path21.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;
       }
@@ -4100,6 +5034,8 @@ var init_app = __esm({
     init_subagents();
     init_workspace();
     init_uploads();
+    init_settings2();
+    init_kiroTools();
     init_health();
     init_gateway();
   }
@@ -4154,16 +5090,16 @@ __export(doctor_exports, {
   mcpWiring: () => mcpWiring
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import os4 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 function which(bin) {
-  if (bin.includes("/")) return fs19.existsSync(bin) ? bin : void 0;
-  for (const dir of (process.env.PATH ?? "").split(path19.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 = path19.join(dir, bin);
+    const candidate = path20.join(dir, bin);
     try {
-      fs19.accessSync(candidate, fs19.constants.X_OK);
+      fs20.accessSync(candidate, fs20.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -4187,7 +5123,7 @@ 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 && !fs19.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(" ")}` };
@@ -4239,7 +5175,7 @@ function checks() {
   const settings = readSettings(config.configFile);
   const hasToken = typeof settings.token === "string" && settings.token !== "";
   out.push(
-    fs19.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`
@@ -4249,8 +5185,8 @@ function checks() {
       detail: `${config.configFile} not found; a token is generated on first run`
     }
   );
-  if (fs19.existsSync(config.configFile)) {
-    const mode = fs19.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",
@@ -4258,10 +5194,10 @@ function checks() {
     });
   }
   try {
-    fs19.mkdirSync(config.casperDataDir, { recursive: true });
-    fs19.accessSync(config.casperDataDir, fs19.constants.W_OK);
-    const db2 = path19.join(config.casperDataDir, "casper.db");
-    const size = fs19.existsSync(db2) ? `, casper.db ${(fs19.statSync(db2).size / 1024).toFixed(0)} KB` : "";
+    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({
@@ -4272,22 +5208,22 @@ function checks() {
     });
   }
   out.push(
-    fs19.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 = path19.join(os4.homedir(), ".kiro", "agents", "casper.json");
-  const hasAgent = fs19.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 json = fs19.readFileSync(agent, "utf8");
+    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);
@@ -4603,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":
@@ -4623,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 = [
       {
@@ -4731,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}
@@ -4749,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.16.0" : "dev";
+    VERSION2 = true ? "0.17.0" : "dev";
   }
 });
 
 // server/src/cli/program.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os5 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // server/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -7874,9 +8810,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path21) {
-    if (path21 === void 0) return this._executableDir;
-    this._executableDir = path21;
+  executableDir(path22) {
+    if (path22 === void 0) return this._executableDir;
+    this._executableDir = path22;
     return this;
   }
   /**
@@ -8134,7 +9070,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.16.0" : "dev";
+var VERSION3 = true ? "0.17.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -8180,8 +9116,8 @@ async function resetToken(value) {
   updateSettings(file, { token });
   process.stdout.write(`wrote a new token to ${file}
 `);
-  const dbFile = path20.join(dataDirPath(), "casper.db");
-  if (fs20.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");
@@ -8198,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 () => {