@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/worktrees.ts

@@ -0,0 +1,138 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { listSessions } from "@anthropic-ai/claude-agent-sdk";
+import type { WorktreeInfo, WorktreeList, WorktreeSession } from "../shared/project.ts";
+import { db } from "./db.ts";
+import { setSessionCwd } from "./session-dirs.ts";
+import { HttpError, createDraftSession, sessions } from "./sessions.ts";
+import { git, projectWorktrees, repoOf, worktreesDir } from "./worktree-git.ts";
+
+/**
+ * git worktrees as sub-workspaces of a project (decided design, see NOTES.md "worktree"):
+ * the server runs `git worktree add` itself in the CLI's layout and starts sessions with the
+ * worktree as their cwd. Sessions in a worktree are listed with the project, tagged with the
+ * worktree's name, so one project keeps one session list.
+ */
+
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
+async function sessionsIn(cwd: string): Promise<WorktreeSession[]> {
+  const infos = await listSessions({ dir: cwd, includeWorktrees: false }).catch(() => []);
+  const out: WorktreeSession[] = infos.map((s) => ({ id: s.sessionId, title: s.customTitle ?? s.summary ?? "", lastModified: s.lastModified, draft: false }));
+  const seen = new Set(out.map((s) => s.id));
+  const drafts = db
+    .prepare("SELECT c.session_id AS id FROM session_cwd c JOIN session_view v ON v.session_id = c.session_id WHERE c.cwd = ? AND v.btw_parent IS NULL")
+    .all(cwd) as { id: string }[];
+  for (const d of drafts) if (!seen.has(d.id)) out.push({ id: d.id, title: "", lastModified: sessions.get(d.id)?.lastActivity ?? Date.now(), draft: true });
+  return out.sort((a, b) => b.lastModified - a.lastModified);
+}
+
+async function pathExists(p: string) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function listWorktrees(projectPath: string): Promise<WorktreeList> {
+  const found = await projectWorktrees(projectPath);
+  if (!found) return { isRepo: false };
+  const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+  const worktrees: WorktreeInfo[] = [];
+  for (const w of found.worktrees) {
+    const exists = await pathExists(w.path);
+    let changes = 0;
+    if (exists) {
+      const st = await git(["status", "--porcelain", "-uall"], w.path);
+      changes = st.stdout.split("\n").filter(Boolean).length;
+    }
+    worktrees.push({
+      name: w.name,
+      path: w.path,
+      cwd: w.cwd,
+      branch: w.branch,
+      head: w.head.slice(0, 12),
+      dirty: changes > 0,
+      changes,
+      locked: w.locked,
+      exists,
+      sessions: exists ? await sessionsIn(w.cwd) : [],
+    });
+  }
+  return { isRepo: true, root: found.repo.top, branch: branch.code === 0 ? branch.stdout.trim() : null, worktrees };
+}
+
+/** Keep `.claude/worktrees/` out of the main checkout's `git status` (repo-local, no tracked file changes). */
+async function excludeWorktreesDir(projectPath: string, top: string) {
+  const probe = await git(["check-ignore", "-q", "--no-index", "--", ".claude/worktrees/x"], top);
+  if (probe.code === 0) return;
+  const common = await git(["rev-parse", "--git-common-dir"], projectPath);
+  if (common.code !== 0) return;
+  const file = path.join(path.resolve(projectPath, common.stdout.trim()), "info", "exclude");
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const cur = (await pathExists(file)) ? await fs.readFile(file, "utf8") : "";
+  await fs.appendFile(file, `${cur && !cur.endsWith("\n") ? "\n" : ""}# claude-ide / claude --worktree checkouts\n/.claude/worktrees/\n`);
+}
+
+export async function createWorktree(projectPath: string, rawName: string): Promise<WorktreeInfo> {
+  const name = rawName.trim();
+  if (!NAME.test(name) || name.endsWith(".lock") || name.includes("..")) {
+    throw new HttpError(400, "名称只能包含字母、数字、点、下划线和连字符（最多 64 个字符）");
+  }
+  const repo = await repoOf(projectPath);
+  if (!repo) throw new HttpError(409, "这个项目不是 git 仓库");
+  if ((await git(["rev-parse", "--verify", "-q", "HEAD"], projectPath)).code !== 0) throw new HttpError(409, "仓库还没有任何提交，无法创建 worktree");
+  const wtPath = path.join(worktreesDir(repo.top), name);
+  if (await pathExists(wtPath)) throw new HttpError(409, `已经存在：${wtPath}`);
+  const branch = `worktree-${name}`;
+  const hasBranch = (await git(["rev-parse", "--verify", "-q", `refs/heads/${branch}`], projectPath)).code === 0;
+  await excludeWorktreesDir(projectPath, repo.top);
+  const r = await git(hasBranch ? ["worktree", "add", wtPath, branch] : ["worktree", "add", "-b", branch, wtPath, "HEAD"], repo.top);
+  if (r.code !== 0) throw new HttpError(409, r.stderr.trim() || "git worktree add 失败");
+  const info = (await listWorktrees(projectPath)) as Extract<WorktreeList, { isRepo: true }>;
+  const created = info.worktrees.find((w) => w.name === name);
+  if (!created) throw new HttpError(409, "worktree 已创建，但没有出现在 git worktree list 里");
+  sessions.notifyChanged(projectPath);
+  return created;
+}
+
+async function findWorktree(projectPath: string, name: string): Promise<WorktreeInfo> {
+  const list = await listWorktrees(projectPath);
+  const wt = list.isRepo ? list.worktrees.find((w) => w.name === name) : undefined;
+  if (!wt) throw new HttpError(404, "找不到这个 worktree");
+  return wt;
+}
+
+/** A new session whose cwd is the worktree. */
+export async function createWorktreeSession(projectPath: string, name: string): Promise<string> {
+  const wt = await findWorktree(projectPath, name);
+  if (!wt.exists) throw new HttpError(409, "worktree 目录已不存在");
+  const id = createDraftSession(projectPath);
+  setSessionCwd(id, wt.cwd);
+  sessions.notifyChanged(projectPath);
+  return id;
+}
+
+/**
+ * `git worktree remove`. Uncommitted changes need `force` (the UI confirms twice). The branch is
+ * kept so commits made in the worktree are not lost; session transcripts stay in ~/.claude.
+ */
+export async function removeWorktree(projectPath: string, name: string, force: boolean) {
+  const wt = await findWorktree(projectPath, name);
+  if (wt.dirty && !force) throw new HttpError(409, `worktree 里有 ${wt.changes} 个未提交的改动，确认后才能删除`);
+  for (const s of wt.sessions) await sessions.drop(s.id);
+  const repo = await repoOf(projectPath);
+  const cwd = repo?.top ?? projectPath;
+  // The CLI's --worktree leaves a lock ("claude session …") behind; the user asked to remove it.
+  if (wt.locked) await git(["worktree", "unlock", wt.path], cwd);
+  if (wt.exists) {
+    const r = await git(["worktree", "remove", ...(force ? ["--force"] : []), wt.path], cwd);
+    if (r.code !== 0) throw new HttpError(409, r.stderr.trim() || "git worktree remove 失败");
+  } else {
+    await git(["worktree", "prune"], cwd);
+  }
+  sessions.notifyChanged(projectPath);
+  return { ok: true, branch: wt.branch };
+}

package/server/ws.test.ts

@@ -0,0 +1,195 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { WSContext } from "hono/ws";
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), "cide-ws-unit-"));
+process.env.CLAUDE_IDE_DATA_DIR = path.join(dir, "data");
+process.env.CLAUDE_IDE_PASSWORD = "unit";
+process.env.CLAUDE_CONFIG_DIR = path.join(dir, "claude");
+const { openConn, closeConn, revokeConnections, handleMessage } = await import("./ws.ts");
+const { db } = await import("./db.ts");
+const { refreshAuth } = await import("./auth.ts");
+await refreshAuth();
+function socket() {
+  const sent: string[] = [], closed: number[] = [];
+  return { sent, closed, ws: { send: (message: string) => sent.push(message), close: (code: number) => closed.push(code) } as unknown as WSContext };
+}
+
+test("write preference broadcasts to every subscribed device and survives reconnect snapshots", async () => {
+  const { addProject, sessions, updateSession } = await import("./sessions.ts");
+  const project = await addProject(dir), sid = crypto.randomUUID(), token = crypto.randomUUID();
+  db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const a = socket(), b = socket(), reconnected = socket();
+  const connections = [a, b, reconnected].map((client) => openConn(client.ws, token));
+  try {
+    const subscribe = (index: number) => handleMessage(connections[index]!, JSON.stringify({ t: "sub", sessionId: sid, projectId: project.id }));
+    await Promise.all([subscribe(0), subscribe(1)]);
+    await updateSession(sid, dir, { writeEnabled: false });
+    for (const client of [a, b]) {
+      const messages = client.sent.map((text) => JSON.parse(text));
+      assert.ok(messages.some((message) => message.t === "ev" && message.ev.k === "settings" && message.ev.writeEnabled === false));
+    }
+    await subscribe(2);
+    const snapshot = reconnected.sent.map((text) => JSON.parse(text)).find((message) => message.t === "snapshot");
+    assert.equal(snapshot.live.writeEnabled, false);
+    await updateSession(sid, dir, { writeEnabled: true });
+    for (const client of [a, b, reconnected]) {
+      const message = client.sent.map((text) => JSON.parse(text)).filter((message) => message.t === "ev" && message.ev.k === "settings").at(-1);
+      assert.equal(message.ev.writeEnabled, true);
+    }
+  } finally {
+    connections.forEach(closeConn);
+    await sessions.drop(sid);
+  }
+});
+
+test("revocation closes every socket for that token and ignores already queued messages", async () => {
+  for (const token of ["login-A", "login-B"]) db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const a = socket(), a2 = socket(), b = socket();
+  const conn = openConn(a.ws, "login-A"), peer = openConn(a2.ws, "login-A"), other = openConn(b.ws, "login-B");
+  let subscriptionsRemoved = 0;
+  conn.subs.set("s", () => { subscriptionsRemoved++; });
+  db.prepare("DELETE FROM auth_tokens WHERE token=?").run("login-A");
+  revokeConnections("login-A");
+  assert.deepEqual(a.closed, [4401]); assert.deepEqual(a2.closed, [4401]);
+  assert.deepEqual(b.closed, []); assert.equal(other.closed, false);
+  assert.equal(subscriptionsRemoved, 1); assert.equal(conn.subs.size, 0);
+  await handleMessage(conn, JSON.stringify({ t: "ping" }));
+  assert.equal(a.sent.length, 0, "even a queued ping cannot be dispatched after logout");
+  await handleMessage(other, JSON.stringify({ t: "ping" }));
+  assert.deepEqual(b.sent.map((m) => JSON.parse(m)), [{ t: "pong" }]);
+  closeConn(conn); closeConn(peer); closeConn(other);
+  assert.equal(subscriptionsRemoved, 1, "close is idempotent");
+});
+
+test("handshake finishing after token revocation cannot register a new connection", () => {
+  const s = socket();
+  const conn = openConn(s.ws, "revoked");
+  assert.equal(conn.closed, true);
+  assert.deepEqual(s.closed, [4401]);
+});
+
+test("CACHE-002/004 bounded reconnect restores the active prefix and independent agent state", async () => {
+  const { EPOCH } = await import("./ws.ts");
+  const { addProject, sessions } = await import("./sessions.ts");
+  const { randomUUID } = await import("node:crypto");
+  const project = await addProject(dir);
+  const sid = randomUUID();
+  const session = await sessions.getOrCreate(sid, dir);
+  (session as any).handle({ type: "assistant", uuid: "call", message: { content: [{ type: "tool_use", id: "agent-tool", name: "Agent", input: {} }] } });
+  for (let i = 0; i < 6000; i++) (session as any).emit({ k: "delta", msgId: "stream", index: 0, kind: "text", text: `${i},`, parent: "agent-tool" });
+  const token = "checkpoint-login";
+  db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const client = socket();
+  const conn = openConn(client.ws, token);
+  try {
+    await handleMessage(conn, JSON.stringify({ t: "sub", sessionId: sid, projectId: project.id, bounded: true, epoch: EPOCH, seq: session.seq - 1 }));
+    const snapshot = client.sent.map((message) => JSON.parse(message)).find((message) => message.t === "snapshot");
+    assert.equal(snapshot.reset, true);
+    assert.equal(snapshot.historyRevision, session.historyRevision);
+    assert.ok(snapshot.events.length <= 1500);
+    assert.equal(snapshot.events.find((entry: any) => entry.ev.k === "delta")?.ev.text, Array.from({ length: 6000 }, (_, i) => `${i},`).join(""));
+    assert.equal(snapshot.live.agentTasks.find((task: any) => task.toolUseId === "agent-tool")?.status, "running");
+  } finally {
+    closeConn(conn);
+    await sessions.drop(sid);
+  }
+});
+
+
+test("HTTP and WS share the view revision; actual rewind changes it without starting SDK", async () => {
+  const { EPOCH } = await import("./ws.ts");
+  const { addProject, sessions, sessionHistoryPage } = await import("./sessions.ts");
+  const project = await addProject(dir);
+  const sid = crypto.randomUUID();
+  const session = await sessions.getOrCreate(sid, dir);
+  const original = session.historyRevision;
+  const page = await sessionHistoryPage(sid, dir);
+  assert.equal(page.historyRevision, original);
+  assert.equal(session.isStarted, false);
+  const resets: any[] = [];
+  const unsub = session.subscribe((_seq, ev) => { if (ev.k === "reset") resets.push(ev); });
+  await session.rewindConversation(dir, "anchor", "draft");
+  assert.notEqual(session.historyRevision, original);
+  assert.equal(resets[0]?.historyRevision, session.historyRevision);
+  assert.equal((await sessionHistoryPage(sid, dir)).historyRevision, session.historyRevision);
+  const token = "revision-login";
+  db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const client = socket();
+  const conn = openConn(client.ws, token);
+  try {
+    await handleMessage(conn, JSON.stringify({ t: "sub", sessionId: sid, projectId: project.id, bounded: true, epoch: EPOCH, seq: 0 }));
+    const snapshot = client.sent.map((m) => JSON.parse(m)).find((m) => m.t === "snapshot");
+    assert.equal(snapshot.historyRevision, session.historyRevision);
+    assert.equal(snapshot.reset, true);
+    assert.equal(session.isStarted, false);
+  } finally { unsub(); closeConn(conn); await sessions.drop(sid); }
+});
+
+test("each WS message rechecks token validity without relying on a logout callback", async () => {
+  const token = "synthetic-message-recheck";
+  db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const client = socket(), conn = openConn(client.ws, token);
+  let removed = 0;
+  conn.subs.set("synthetic", () => removed++);
+  db.prepare("DELETE FROM auth_tokens WHERE token = ?").run(token);
+  await handleMessage(conn, JSON.stringify({ t: "ping" }));
+  assert.equal(conn.closed, true);
+  assert.deepEqual(client.closed, [4401]);
+  assert.equal(removed, 1);
+  assert.equal(client.sent.length, 0);
+});
+
+test("logout while subscription initialization awaits cannot leak a new subscription", async () => {
+  const { addProject, sessions } = await import("./sessions.ts");
+  const project = await addProject(dir), sid = crypto.randomUUID();
+  const session = await sessions.getOrCreate(sid, dir);
+  const token = "synthetic-pending-sub";
+  db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+  const client = socket(), conn = openConn(client.ws, token);
+  const original = sessions.getOrCreate;
+  let release!: () => void, entered!: () => void;
+  const gate = new Promise<void>((resolve) => { release = resolve; });
+  const started = new Promise<void>((resolve) => { entered = resolve; });
+  sessions.getOrCreate = async () => { entered(); await gate; return session; };
+  try {
+    const pending = handleMessage(conn, JSON.stringify({ t: "sub", projectId: project.id, sessionId: sid }));
+    await started;
+    revokeConnections(token);
+    release();
+    await pending;
+    assert.equal(conn.closed, true);
+    assert.equal(conn.subs.size, 0);
+    assert.equal(client.sent.length, 0);
+  } finally {
+    release(); sessions.getOrCreate = original; closeConn(conn); await sessions.drop(sid);
+  }
+});
+
+test("password rotation actively closes every old socket and removes subscriptions", async () => {
+  const { config } = await import("./config.ts");
+  const { isTokenValid } = await import("./auth.ts");
+  const tokens = ["synthetic-rotation-a", "synthetic-rotation-b"];
+  const clients = tokens.map(() => socket());
+  const connections = tokens.map((token, index) => {
+    db.prepare("INSERT INTO auth_tokens VALUES (?, ?, ?)").run(token, Date.now(), Date.now());
+    return openConn(clients[index]!.ws, token);
+  });
+  let removed = 0;
+  for (const conn of connections) conn.subs.set("synthetic-view", () => removed++);
+  await fs.promises.writeFile(config.passwordFile, "synthetic-new-password\n");
+  assert.equal(await refreshAuth(), true);
+  assert.equal(removed, 2);
+  for (const [index, conn] of connections.entries()) {
+    assert.equal(conn.closed, true); assert.equal(conn.subs.size, 0);
+    assert.deepEqual(clients[index]!.closed, [4401]);
+    assert.equal(isTokenValid(tokens[index]!), false);
+    await handleMessage(conn, JSON.stringify({ t: "ping" }));
+    assert.equal(clients[index]!.sent.length, 0);
+  }
+  const pending = socket();
+  assert.equal(openConn(pending.ws, tokens[0]!).closed, true);
+  assert.deepEqual(pending.closed, [4401]);
+});

package/server/ws.ts

@@ -0,0 +1,197 @@
+import crypto from "node:crypto";
+import type { WSContext } from "hono/ws";
+import type { ClientMsg, ServerMsg } from "../shared/protocol.ts";
+import { projectPath, sessions } from "./sessions.ts";
+import { idecron } from "./idecron.ts";
+import { isTokenValid, onAuthRevoked, validateToken } from "./auth.ts";
+import { notify, setViewingCheck } from "./push.ts";
+import { deployedDistVersion, onDistVersion } from "./dist-version.ts";
+import { boundedReplay } from "../shared/message-window.ts";
+
+/** Changes on every server start so stale client cursors are detected. */
+export const EPOCH = crypto.randomBytes(6).toString("hex");
+
+type Conn = { ws: WSContext; subs: Map<string, () => void>; visible: boolean; token: string; closed: boolean; versionAware?: boolean; sentVersion?: string };
+
+const conns = new Set<Conn>();
+
+// Credential rotation revokes devices, never the sessions/CLI processes they
+// were viewing. closeConn only removes this socket and its subscriptions.
+onAuthRevoked(() => {
+  for (const conn of conns) {
+    closeConn(conn);
+    conn.ws.close(4401, "authentication changed");
+  }
+});
+
+function sendVersion(conn: Conn, version: string | undefined) {
+  if (!version || !conn.versionAware || conn.sentVersion === version) return;
+  send(conn, { t: "version", version });
+  conn.sentVersion = version;
+}
+onDistVersion((version) => {
+  for (const conn of conns) sendVersion(conn, version);
+});
+
+function send(conn: Conn, msg: ServerMsg) {
+  if (conn.closed) return;
+  try {
+    conn.ws.send(JSON.stringify(msg));
+  } catch {
+    // socket already closed
+  }
+}
+
+sessions.onActivity((a) => {
+  for (const c of conns) send(c, { t: "activity", ...a });
+  void notify({
+    kind: a.kind,
+    title: a.title,
+    body: a.kind === "done" ? "已完成" : a.kind === "attention" ? "等你处理" : "出错了",
+    url: `/p/${a.projectId}/s/${a.sessionId}`,
+    tag: `${a.sessionId}:${a.kind}`,
+    skipIfViewing: a.sessionId,
+  });
+});
+
+// A device with the session open over a live socket is "looking at it": no push needed.
+// "Viewing" = a visible page has the session open; a background tab still gets the push.
+setViewingCheck((sessionId) => [...conns].some((c) => c.visible && c.subs.has(sessionId)));
+
+sessions.onSessionsChanged((projectId) => {
+  for (const c of conns) send(c, { t: "sessions", projectId });
+});
+
+export function openConn(ws: WSContext, token: string): Conn {
+  const conn: Conn = { ws, subs: new Map(), visible: true, token, closed: false };
+  if (isTokenValid(token)) conns.add(conn);
+  else { conn.closed = true; ws.close(4401, "unauthorized"); }
+  return conn;
+}
+
+export function closeConn(conn: Conn) {
+  conn.closed = true;
+  for (const unsub of conn.subs.values()) unsub();
+  conn.subs.clear();
+  conns.delete(conn);
+}
+
+export function revokeConnections(token: string) {
+  for (const conn of conns) {
+    if (conn.token !== token) continue;
+    closeConn(conn);
+    conn.ws.close(4401, "logged out");
+  }
+}
+
+export async function handleMessage(conn: Conn, raw: string) {
+  if (conn.closed) return;
+  if (!await validateToken(conn.token)) {
+    closeConn(conn);
+    conn.ws.close(4401, "unauthorized");
+    return;
+  }
+  if (conn.closed) return;
+  let msg: ClientMsg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  try {
+    await dispatch(conn, msg);
+  } catch (err) {
+    send(conn, { t: "error", message: err instanceof Error ? err.message : String(err) });
+  }
+}
+
+async function dispatch(conn: Conn, msg: ClientMsg) {
+  switch (msg.t) {
+    case "clientVersion":
+      // Older clients do not understand the new message type; only send it after opt-in.
+      conn.versionAware = true;
+      sendVersion(conn, await deployedDistVersion());
+      return;
+    case "sub": {
+      conn.subs.get(msg.sessionId)?.();
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      const sameEpoch = msg.epoch === EPOCH && typeof msg.seq === "number";
+      const missed = sameEpoch ? s.eventsSince(msg.seq!) : undefined;
+      // Active block prefixes live outside the ring. Replay a fresh window when restoring
+      // them so their cumulative checkpoints replace the client's earlier fragments.
+      const checkpoints = msg.bounded ? s.streamingCheckpoints : [];
+      const replay = checkpoints.length ? s.events : missed ?? s.events;
+      const events = msg.bounded ? boundedReplay(replay, checkpoints) : replay;
+      const reset = !missed || checkpoints.length > 0 || events.length !== replay.length;
+      send(conn, {
+        t: "snapshot",
+        sessionId: msg.sessionId,
+        epoch: EPOCH,
+        seq: s.seq,
+        reset,
+        historyRevision: s.historyRevision,
+        live: s.snapshot(),
+        events,
+      });
+      const unsub = s.subscribe((seq, ev) => send(conn, { t: "ev", sessionId: msg.sessionId, seq, ev }));
+      conn.subs.set(msg.sessionId, unsub);
+      return;
+    }
+    case "unsub":
+      conn.subs.get(msg.sessionId)?.();
+      conn.subs.delete(msg.sessionId);
+      return;
+    case "send": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.send(msg.uuid, msg.text, msg.images);
+      return;
+    }
+    case "interrupt":
+      await sessions.get(msg.sessionId)?.interrupt();
+      return;
+    case "refreshCrons": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.refreshCrons();
+      return;
+    }
+    case "cancelIdecron":
+      idecron.cancel(msg.id, msg.sessionId);
+      return;
+    case "setModel": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.setModel(msg.model);
+      return;
+    }
+    case "setEffort": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.setEffort(msg.effort);
+      return;
+    }
+    case "setPlanMode": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.setPlanMode(msg.on);
+      return;
+    }
+    case "bash": {
+      const s = await sessions.getOrCreate(msg.sessionId, projectPath(msg.projectId));
+      if (conn.closed) return;
+      await s.runBash(msg.uuid, msg.command);
+      return;
+    }
+    case "ping":
+      send(conn, { t: "pong" });
+      return;
+    case "visibility":
+      conn.visible = msg.visible;
+      return;
+    case "answer":
+      sessions.get(msg.sessionId)?.resolvePending(msg.requestId, msg.answer);
+      return;
+  }
+}

package/shared/agent-model.ts

@@ -0,0 +1,15 @@
+import type { SdkMessageLike } from "./protocol.ts";
+
+/** Actual response metadata, never the parent's settings or a tool's model hint. */
+export function responseModel(message: SdkMessageLike): string | undefined {
+  let model: unknown;
+  if (message.type === "assistant" && !message.error && !message.aborted) {
+    model = (message.message as { model?: unknown } | undefined)?.model;
+  } else if (message.type === "stream_event") {
+    const event = message.event as { type?: string; message?: { model?: unknown } } | undefined;
+    if (event?.type === "message_start") model = event.message?.model;
+  }
+  if (typeof model !== "string") return undefined;
+  const value = model.trim();
+  return value && value !== "<synthetic>" ? value : undefined;
+}

package/shared/agent-tasks.ts

@@ -0,0 +1,12 @@
+import type { AgentTask } from "./protocol.ts";
+
+/** SDK run IDs are ordered lexically. Arrival order can change when an older
+ * run reports late progress or model metadata, so it cannot establish recency. */
+export function currentAgentTask(tasks: Iterable<AgentTask>, taskId: string): AgentTask | undefined {
+  let current: AgentTask | undefined;
+  for (const task of tasks) {
+    if (task.taskId !== taskId) continue;
+    if (!current?.runId || task.runId && task.runId >= current.runId) current = task;
+  }
+  return current;
+}