toyon 0.17.0 → 0.18.0

package/dist/daemon.js

@@ -1,8 +1,8 @@
 // @bun
 // ../daemon/src/index.ts
-import { rmSync as rmSync9, writeFileSync as writeFileSync13 } from "fs";
+import { rmSync as rmSync9, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir15 } from "os";
-import { dirname as dirname13, join as join32 } from "path";
+import { dirname as dirname14, join as join33 } from "path";
 import { fileURLToPath } from "url";
 
 // ../shared/src/protocol/events.ts
@@ -71,6 +71,7 @@ function applyLog(lines, proc, line, retract = 0) {
     return out;
   return [...out, { proc, line }];
 }
+var isBusy = (status) => status === "working" || status === "waiting";
 var KEEP_AWAKE_MODES = ["use", "always", "off"];
 
 // ../shared/src/worktree-caps.ts
@@ -6601,7 +6602,7 @@ ${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
 }
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 115;
+var PROTOCOL_VERSION = 119;
 var PAGE_ERROR_MAX_CHARS = 2000;
 var PAGE_TITLE_MAX_CHARS = 1000;
 var FILE_MAX_CHARS = 5000000;
@@ -7039,7 +7040,13 @@ var clientMsgSchema = discriminatedUnion("t", [
     attachments,
     boxId
   }),
-  object({ t: literal("agent-decide"), worktreeId: id, askId: string2().max(64), choiceId: string2().max(200) }),
+  object({
+    t: literal("agent-decide"),
+    worktreeId: id,
+    askId: string2().max(64),
+    choiceId: string2().max(200),
+    note: string2().max(1e4).optional()
+  }),
   object({
     t: literal("handoff-answer"),
     worktreeId: id,
@@ -8519,7 +8526,7 @@ async function turnRemoteOff(ts, daemonPort, file, was) {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.17.0",
+  version: "0.18.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -13765,7 +13772,8 @@ function sameLimits(a, b) {
   if (!a || !b)
     return a === b;
   const win = (x) => x ? `${x.used}@${x.resetsAt}` : "";
-  return a.status === b.status && a.binding === b.binding && win(a.windows.five_hour) === win(b.windows.five_hour) && win(a.windows.seven_day) === win(b.windows.seven_day);
+  const keys = ["five_hour", "seven_day", "seven_day_overage_included"];
+  return a.status === b.status && a.binding === b.binding && keys.every((k) => win(a.windows[k]) === win(b.windows[k]));
 }
 function same(a, b) {
   if (!a || !b)
@@ -15091,6 +15099,91 @@ function loadAgentRegistry(agentsFile, agentsDir, sandbox, managed = MANAGED_DEF
 // ../daemon/src/agent/acp/session.ts
 import { randomUUID } from "crypto";
 
+// ../daemon/src/agent/awsAuth.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+var AWS_EXPIRED_RE = /could not load aws credentials|aws sso login|aws authentication failed|expiredtoken|security token included in the request is (expired|invalid)|sso (session|token)[^.]*expired|token is expired|awsauthrefresh/i;
+var AWS_LOGIN_METHOD = "aws-login";
+var AWS_REFRESH_METHOD = "aws-refresh";
+function readAwsAuth(configDir, cwd, env = process.env) {
+  const files = [
+    join8(cwd, ".claude", "settings.local.json"),
+    join8(cwd, ".claude", "settings.json"),
+    join8(configDir, "settings.json")
+  ];
+  let profile;
+  let refresh;
+  for (const file of files) {
+    const s = readSettings(file);
+    if (!s)
+      continue;
+    const e = s.env;
+    profile ??= str2(e?.AWS_PROFILE);
+    refresh ??= str2(s.awsAuthRefresh);
+  }
+  profile ??= str2(env.AWS_PROFILE);
+  return { ...profile ? { profile } : {}, ...refresh ? { refresh } : {} };
+}
+function awsLoginCommand(profile) {
+  return profile ? `aws sso login --profile ${shellWord(profile)}` : "aws sso login";
+}
+function awsMethods(auth, settable) {
+  const login = {
+    id: AWS_LOGIN_METHOD,
+    name: "log in to AWS",
+    description: `runs ${awsLoginCommand(auth.profile)} in the terminal pane`,
+    kind: "terminal"
+  };
+  if (auth.refresh || !settable)
+    return [login];
+  return [
+    {
+      id: AWS_REFRESH_METHOD,
+      name: "refresh automatically",
+      description: "sets awsAuthRefresh in your Claude settings, so Claude runs the login itself when the session expires",
+      kind: "agent"
+    },
+    login
+  ];
+}
+function setAwsAuthRefresh(configDir, command) {
+  const file = join8(configDir, "settings.json");
+  let settings = {};
+  if (existsSync10(file)) {
+    try {
+      const v = JSON.parse(readFileSync9(file, "utf8"));
+      if (!v || typeof v !== "object" || Array.isArray(v))
+        throw new Error("not an object");
+      settings = v;
+    } catch (e) {
+      throw new UserError(`${file} is not valid JSON (${e instanceof Error ? e.message : String(e)}); fix it, then try again`);
+    }
+  }
+  const rest = Object.fromEntries(Object.entries(settings).filter(([k]) => k !== "awsAuthRefresh"));
+  const next = { awsAuthRefresh: command, ...rest };
+  mkdirSync7(dirname4(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync6(tmp, `${JSON.stringify(next, null, 2)}
+`);
+  renameSync2(tmp, file);
+  return file;
+}
+function readSettings(file) {
+  if (!existsSync10(file))
+    return null;
+  try {
+    const v = JSON.parse(readFileSync9(file, "utf8"));
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+  } catch (e) {
+    log.warn("aws-auth", `${file} is not valid JSON`, e);
+    return null;
+  }
+}
+var str2 = (v) => typeof v === "string" && v.trim() ? v.trim() : undefined;
+function shellWord(s) {
+  return /^[\w.@-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+}
+
 // ../daemon/src/agent/modes.ts
 var READ_ONLY_MODE_IDS = ["plan", "read-only"];
 function agentModeFor(spec, mode, available) {
@@ -15117,19 +15210,19 @@ function orderPlanOptions(options) {
 }
 
 // ../daemon/src/agent/origins.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename3, join as join8 } from "path";
+import { basename as basename3, join as join9 } from "path";
 function commandFolders(spec, cwd, home = homedir4()) {
   if (spec.id === "claude") {
     return [
-      { origin: "project", skills: join8(cwd, ".claude", "skills"), commands: join8(cwd, ".claude", "commands") },
-      { origin: "user", skills: join8(home, ".claude", "skills"), commands: join8(home, ".claude", "commands") },
-      ...pluginPaths(spec.meta).map((p) => ({ origin: "plugin", skills: join8(p, "skills"), commands: join8(p, "commands") }))
+      { origin: "project", skills: join9(cwd, ".claude", "skills"), commands: join9(cwd, ".claude", "commands") },
+      { origin: "user", skills: join9(home, ".claude", "skills"), commands: join9(home, ".claude", "commands") },
+      ...pluginPaths(spec.meta).map((p) => ({ origin: "plugin", skills: join9(p, "skills"), commands: join9(p, "commands") }))
     ];
   }
   if (spec.id === "codex")
-    return [{ origin: "user", commands: join8(home, ".codex", "prompts") }];
+    return [{ origin: "user", commands: join9(home, ".codex", "prompts") }];
   return [];
 }
 function readCommandOrigins(folders) {
@@ -15169,15 +15262,15 @@ function pluginPaths(meta) {
 }
 function skillNames(dir) {
   return entries2(dir).flatMap((e) => {
-    const file = join8(dir, e, "SKILL.md");
-    if (!existsSync10(file))
+    const file = join9(dir, e, "SKILL.md");
+    if (!existsSync11(file))
       return [];
     return [frontMatterName(file) ?? e];
   });
 }
 function commandNames(dir) {
   return entries2(dir).flatMap((e) => {
-    const path = join8(dir, e);
+    const path = join9(dir, e);
     if (e.endsWith(".md"))
       return [basename3(e, ".md")];
     return isDir(path) ? commandNames(path) : [];
@@ -15185,7 +15278,7 @@ function commandNames(dir) {
 }
 function frontMatterName(file) {
   try {
-    const text = readFileSync9(file, "utf8");
+    const text = readFileSync10(file, "utf8");
     if (!text.startsWith("---"))
       return null;
     const end = text.indexOf(`
@@ -15199,7 +15292,7 @@ function frontMatterName(file) {
   }
 }
 function entries2(dir) {
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     return [];
   try {
     return readdirSync4(dir).filter((e) => !e.startsWith("."));
@@ -15249,10 +15342,10 @@ function unformatOutput(output) {
 import { isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 
 // ../daemon/src/agent/acp/background.ts
-import { existsSync as existsSync11, statSync as statSync4 } from "fs";
+import { existsSync as existsSync12, statSync as statSync4 } from "fs";
 import { open as open2 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename4, dirname as dirname4, join as join9 } from "path";
+import { basename as basename4, dirname as dirname5, join as join10 } from "path";
 var STARTED = /Command running in background with ID: (\S+)\. Output is being written to: (\S+)\./;
 function backgroundStart(input, output) {
   const flag = input && typeof input === "object" ? input.run_in_background : undefined;
@@ -15265,15 +15358,15 @@ function spawnDetached(output) {
   return output.includes("Async agent launched successfully");
 }
 function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join9(homedir5(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join10(homedir5(), ".claude");
 }
 function sessionLogFor(file, configDir = claudeConfigDir()) {
-  const tasks = dirname4(file);
+  const tasks = dirname5(file);
   if (basename4(tasks) !== "tasks")
     return null;
-  const session = dirname4(tasks);
-  const path = join9(configDir, "projects", basename4(dirname4(session)), `${basename4(session)}.jsonl`);
-  return existsSync11(path) ? path : null;
+  const session = dirname5(tasks);
+  const path = join10(configDir, "projects", basename4(dirname5(session)), `${basename4(session)}.jsonl`);
+  return existsSync12(path) ? path : null;
 }
 function taskEnd(text, toolId) {
   const at = text.indexOf(`<tool-use-id>${toolId}</tool-use-id>`);
@@ -16187,11 +16280,11 @@ ${a.text}
 }
 
 // ../daemon/src/agent/transcript.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { appendFile } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function transcriptPathFor(transcriptsDir, worktreeId) {
-  return join10(transcriptsDir, `${worktreeId}.jsonl`);
+  return join11(transcriptsDir, `${worktreeId}.jsonl`);
 }
 function coalesce(entries) {
   const out = [];
@@ -16214,6 +16307,24 @@ function coalesce(entries) {
   }
   return out;
 }
+var NOT_THE_TURNS = new Set(["usage", "session-info", "user-message", "fix-asked"]);
+function sealOpenTurn(entries) {
+  let reason = null;
+  let ts = 0;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const e = entries[i].event;
+    if ("ts" in e && typeof e.ts === "number")
+      ts = Math.max(ts, e.ts);
+    if (e.type === "turn-end")
+      return null;
+    if (e.type === "turn-start")
+      return { type: "turn-end", stopReason: reason ?? "lost", ts };
+    if (NOT_THE_TURNS.has(e.type))
+      continue;
+    reason ??= e.type === "agent-auth-required" ? "auth" : e.type === "agent-error" ? "failed" : "lost";
+  }
+  return null;
+}
 function parseTranscript(text, tag) {
   const out = [];
   let torn = 0;
@@ -16245,7 +16356,7 @@ class Transcript {
     this.seq = (this.entries.at(-1)?.seq ?? -1) + 1;
   }
   read() {
-    return existsSync12(this.path) ? parseTranscript(readFileSync10(this.path, "utf8"), this.tag) : [];
+    return existsSync13(this.path) ? parseTranscript(readFileSync11(this.path, "utf8"), this.tag) : [];
   }
   append(event) {
     const entry = { seq: this.seq++, event };
@@ -16458,6 +16569,9 @@ function toContent(form, answers) {
 // ../daemon/src/agent/acp/ratelimit.ts
 var RATE_LIMIT_META = "_claude/rateLimit";
 var STATUSES = new Set(["allowed", "allowed_warning", "rejected"]);
+var WINDOW_KEYS = ["five_hour", "seven_day", "seven_day_overage_included"];
+var isWindowKey = (v) => WINDOW_KEYS.includes(v);
+var hasWindow = (windows) => WINDOW_KEYS.some((key) => windows[key]);
 var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
 function window(v) {
   const w = v;
@@ -16479,18 +16593,17 @@ function parseRateLimit(meta, now) {
   const binding = typeof info.rateLimitType === "string" ? info.rateLimitType : undefined;
   const unified = info.unifiedWindows ?? undefined;
   const windows = {};
-  const fiveHour = window(unified?.five_hour);
-  const sevenDay = window(unified?.seven_day);
-  if (fiveHour)
-    windows.five_hour = fiveHour;
-  if (sevenDay)
-    windows.seven_day = sevenDay;
-  if (!fiveHour && !sevenDay && (binding === "five_hour" || binding === "seven_day")) {
+  for (const key of WINDOW_KEYS) {
+    const w = window(unified?.[key]);
+    if (w)
+      windows[key] = w;
+  }
+  if (!hasWindow(windows) && isWindowKey(binding)) {
     const top = window({ utilization: info.utilization, resetsAt: info.resetsAt });
     if (top)
       windows[binding] = top;
   }
-  if (!windows.five_hour && !windows.seven_day)
+  if (!hasWindow(windows))
     return null;
   return { status, ...binding ? { binding } : {}, windows, at: now };
 }
@@ -16525,9 +16638,10 @@ class AcpSession {
   status = "idle";
   queue = [];
   steered = [];
+  steerMark;
+  streamingId;
   refused = null;
-  running = false;
-  interrupted = false;
+  turn = null;
   stopped = false;
   holds = 0;
   get held() {
@@ -16557,6 +16671,7 @@ class AcpSession {
       ...d.claudeConfigDir !== undefined ? { configDir: d.claudeConfigDir } : {}
     });
     this.seq = nextNumbers(this.log.entries.map(({ event }) => event.type === "user-message" ? event.attachments : undefined));
+    const seal = sealOpenTurn(this.log.entries);
     const open = new Set;
     for (const { event } of this.log.entries) {
       if (event.type === "agent-question" || event.type === "agent-permission")
@@ -16597,6 +16712,10 @@ class AcpSession {
         ts: Date.now()
       });
     }
+    if (seal) {
+      log.info(d.worktreeId, `sealed a turn left open: ${seal.stopReason}`);
+      this.emit(seal);
+    }
     if (this.openHandoffs.size > 0)
       this.syncStatus();
   }
@@ -16707,6 +16826,19 @@ class AcpSession {
     this.status = s;
     this.d.onStatus(s);
   }
+  get running() {
+    return this.turn !== null;
+  }
+  get stopping() {
+    return this.turn?.stopping ?? false;
+  }
+  setStopping(on) {
+    const turn = this.turn;
+    if (!turn || turn.stopping === on)
+      return;
+    turn.stopping = on;
+    this.d.onStopping?.();
+  }
   send(text, opts = {}) {
     if (this.stopped)
       return log.warn(this.d.worktreeId, "send after close dropped");
@@ -16716,6 +16848,11 @@ class AcpSession {
     this.post(text, opts);
   }
   post(text, opts = {}) {
+    const steer = this.deliver(text, opts);
+    if (steer)
+      fireAndForget(this.d.worktreeId, steer, "agent steer");
+  }
+  deliver(text, opts = {}) {
     const { context, attachments, asked } = opts;
     const item = {
       text,
@@ -16728,10 +16865,11 @@ class AcpSession {
       item.recorded = { attachments: [] };
     }
     this.d.attachments.uploads.hold(uploadIds(attachments));
-    if ((this.running || this.own) && !this.interrupted && !this.held && this.live?.conn.steering) {
-      return fireAndForget(this.d.worktreeId, this.steer(item), "agent steer");
+    if ((this.running || this.own) && !this.turn?.stopping && !this.held && this.live?.conn.steering) {
+      return this.steer(item);
     }
     this.enqueue(item);
+    return;
   }
   enqueue(item) {
     this.queue.push(item);
@@ -16754,9 +16892,10 @@ class AcpSession {
   async steer(item) {
     item.recorded ??= await this.record(item);
     const live = this.live;
-    if (!live || !(this.running || this.own) || this.interrupted)
+    if (!live || !(this.running || this.own) || this.turn?.stopping)
       return this.enqueue(item);
     this.steered.push(item);
+    this.steerMark = this.streamingId;
     let outcome;
     try {
       outcome = steerOutcome(await live.conn.ctx.request(STEER_METHOD, {
@@ -16787,6 +16926,13 @@ class AcpSession {
     if (this.live === live)
       preempted(live.tools);
   }
+  answered() {
+    this.steered = [];
+    if (!this.turn?.stopping || !this.queue.some((q) => q.handedBack))
+      return;
+    this.queue = this.queue.filter((q) => !q.handedBack);
+    this.queueChanged();
+  }
   unsteer(item) {
     const at = this.steered.indexOf(item);
     if (at >= 0)
@@ -16803,8 +16949,10 @@ class AcpSession {
       }
       return;
     }
-    this.interrupted = true;
+    this.setStopping(true);
     if (this.steered.length > 0) {
+      for (const item of this.steered)
+        item.handedBack = true;
       this.queue.unshift(...this.steered);
       this.steered = [];
       this.queueChanged();
@@ -16829,7 +16977,7 @@ class AcpSession {
   }
   async drain() {
     this.endOwn("end_turn");
-    this.running = true;
+    this.turn = { open: false, stopping: false };
     this.clearReaper();
     this.setStatus("working");
     let item = null;
@@ -16837,44 +16985,69 @@ class AcpSession {
       while (this.queue.length > 0 && !this.held) {
         item = this.queue.shift();
         this.queueChanged();
+        const turn = { open: false, stopping: false };
+        this.turn = turn;
         try {
           await this.runTurn(item);
         } catch (e) {
-          if (!this.interrupted)
+          if (!turn.stopping)
             throw e;
-          this.emit({ type: "turn-end", stopReason: "interrupted", ts: Date.now() });
+          if (turn.open)
+            this.endTurn("interrupted");
+          else
+            this.emit({ type: "agent-error", message: this.describe(e), ts: Date.now() });
         }
-        this.interrupted = false;
         this.steered = [];
+        for (const q of this.queue)
+          q.handedBack = false;
+        this.setStopping(false);
       }
       this.setStatus(this.openHandoffs.size > 0 ? "waiting" : "idle");
     } catch (e) {
-      if (this.conn && (isAuthRequired(e) || this.rejectedCredential(e))) {
+      const aws = this.conn && AWS_EXPIRED_RE.test(this.describe(e)) ? this.awsAuth() : null;
+      if (this.conn && (aws || isAuthRequired(e) || this.rejectedCredential(e))) {
         const rejected = !isAuthRequired(e);
-        if (rejected)
+        if (rejected && !aws)
           this.emit({ type: "agent-error", message: this.describe(e), ts: Date.now() });
         this.refused = item;
         this.emit({
           type: "agent-auth-required",
           agent: this.conn.spec.id,
           agentName: this.conn.spec.name,
-          ...this.offeredMethods(this.conn),
+          ...aws ? {
+            methods: awsMethods(aws, this.conn.spec.id === "claude"),
+            provider: "aws",
+            detail: this.describe(e),
+            ...aws.refresh ? { refresh: aws.refresh } : {}
+          } : this.offeredMethods(this.conn),
           ...rejected ? { rejected: true } : {},
           ts: Date.now()
         });
+        this.endTurn("auth");
         this.setStatus("error");
       } else {
         this.emit({ type: "agent-error", message: this.describe(e), ts: Date.now() });
+        this.endTurn("failed");
         this.setStatus("error");
         fireAndForget(this.d.worktreeId, this.dropConn("error"), "drop agent after error");
       }
     } finally {
-      this.interrupted = false;
       this.steered = [];
-      this.running = false;
+      for (const q of this.queue)
+        q.handedBack = false;
+      this.setStopping(false);
+      this.turn = null;
       this.maybeArmReaper();
     }
   }
+  endTurn(stopReason) {
+    const turn = this.turn;
+    if (!turn?.open)
+      return;
+    turn.open = false;
+    this.emit({ type: "turn-end", stopReason, ts: Date.now() });
+    this.setStopping(false);
+  }
   async ask(system, prompt, opts = {}) {
     if (this.stopped)
       return null;
@@ -16905,6 +17078,8 @@ class AcpSession {
   }
   async authenticate(methodId, apiKey) {
     const conn = await this.ensureConn("login");
+    if (methodId === AWS_LOGIN_METHOD || methodId === AWS_REFRESH_METHOD)
+      return this.authenticateAws(methodId);
     const method = conn.authMethods.find((m) => m.id === methodId);
     if (!method)
       throw new UserError(`${conn.spec.name} offers no login method "${methodId}"`);
@@ -16936,6 +17111,23 @@ class AcpSession {
     this.loggedIn();
     return { kind: "done" };
   }
+  async authenticateAws(methodId) {
+    const command = awsLoginCommand(this.awsAuth().profile);
+    if (methodId === AWS_LOGIN_METHOD) {
+      return { kind: "terminal", run: { command: process.env.SHELL || "sh", args: ["-lc", command], env: {} } };
+    }
+    const file = setAwsAuthRefresh(this.claudeConfigDir(), command);
+    log.info(this.d.worktreeId, `awsAuthRefresh set to "${command}" in ${file}`);
+    await this.dropConn("settings changed");
+    this.loggedIn();
+    return { kind: "done" };
+  }
+  awsAuth() {
+    return readAwsAuth(this.claudeConfigDir(), this.d.cwd);
+  }
+  claudeConfigDir() {
+    return this.d.claudeConfigDir ?? claudeConfigDir();
+  }
   loggedIn() {
     this.emit({ type: "agent-auth-ok", ts: Date.now() });
     this.retry();
@@ -17000,12 +17192,13 @@ class AcpSession {
       log.warn(this.d.worktreeId, "before-turn hook failed", e);
     }
     this.emit({ type: "turn-start", ts: Date.now() });
+    this.turn.open = true;
     const live = await this.ensureLive("a turn");
     await this.applyMode(live);
     await this.applyOption(live, "model");
     await this.applyOption(live, "thought_level");
-    if (this.interrupted) {
-      this.emit({ type: "turn-end", stopReason: "interrupted", ts: Date.now() });
+    if (this.turn?.stopping) {
+      this.endTurn("interrupted");
       return;
     }
     const carried = this.carried(live, item.recorded.attachments);
@@ -17015,7 +17208,7 @@ class AcpSession {
       sessionId: live.sessionId,
       prompt: buildPrompt(item.text, this.contextFor(item), prefix, carried)
     });
-    this.emit({ type: "turn-end", stopReason: mapStopReason(res.stopReason), ts: Date.now() });
+    this.endTurn(mapStopReason(res.stopReason));
   }
   contextFor(item) {
     return ambientBlock([
@@ -17285,8 +17478,15 @@ class AcpSession {
     if (!this.running)
       this.trackOwn(events);
     for (const ev of events) {
-      if (ev.type === "text-delta" || ev.type === "tool-start")
-        this.steered = [];
+      if (ev.type === "tool-start")
+        this.answered();
+      else if (ev.type === "text-delta") {
+        if (ev.messageId === undefined)
+          this.steered = [];
+        else if (ev.messageId !== this.steerMark)
+          this.answered();
+        this.streamingId = ev.messageId;
+      }
       this.emit(ev.type === "session-info" ? { ...ev, sessionId: live.sessionId } : ev);
     }
   }
@@ -17357,18 +17557,23 @@ class AcpSession {
       const choice = picked ? choices.find((c) => c.id === picked) : undefined;
       if (!choice)
         return { outcome: { outcome: "cancelled" } };
+      const res = { outcome: { outcome: "selected", optionId: choice.id } };
       if (plan && (choice.kind === "allow_once" || choice.kind === "allow_always")) {
         this.d.setMode?.(modeAfterPlan(choice.name));
         if (planPath)
-          fireAndForget(this.d.worktreeId, this.sayPlanEdited(detail, planPath), "edited plan");
+          return this.sayPlanEdited(detail, planPath).then(() => res);
       }
-      return { outcome: { outcome: "selected", optionId: choice.id } };
+      return res;
     });
   }
   async sayPlanEdited(proposed, path) {
-    if (!await this.d.planEdited?.(path, proposed))
-      return;
-    this.post(`I edited the plan before approving it. Build what is in ${path}, not the plan you proposed.`);
+    try {
+      if (!await this.d.planEdited?.(path, proposed))
+        return;
+      await this.deliver(`I edited the plan before approving it. Build what is in ${path}, not the plan you proposed.`);
+    } catch (e) {
+      log.warn(this.d.worktreeId, "the edited plan was not sent", e);
+    }
   }
   onElicit(params, signal) {
     const live = this.live;
@@ -17399,13 +17604,14 @@ class AcpSession {
   openAsk(card, respond, signal, headers) {
     const id = randomUUID();
     return new Promise((resolve) => {
-      const settle = (outcome, reply) => {
+      const settle = (outcome, reply, before) => {
         if (!this.asks.delete(id))
           return;
         signal?.removeEventListener("abort", onAbort);
         this.emit({ type: "agent-ask-end", id, outcome, ...recorded(reply), ts: Date.now() });
         this.syncStatus();
-        resolve(respond(outcome, reply));
+        const res = respond(outcome, reply);
+        resolve(before ? before().then(() => res) : res);
       };
       const onAbort = () => settle("cancelled");
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -17419,12 +17625,21 @@ class AcpSession {
     if (!ask)
       return log.debug(this.d.worktreeId, `answer for an ask that already closed (${askId})`);
     const skipped = reply.kind === "answers" && !reply.answers;
-    ask.settle(skipped ? "skipped" : "answered", reply);
-    if (skipped || !followUp?.attachments.length)
-      return;
+    const note = reply.kind === "choice" ? reply.note?.trim() : undefined;
+    const attachments = skipped ? [] : followUp?.attachments ?? [];
     const headers = ask.headers ?? [];
     const text = headers.length === 1 ? `with my answer to "${headers[0]}"` : "with my answers";
-    this.post(text, { attachments: followUp.attachments });
+    const before = note || attachments.length ? async () => {
+      try {
+        if (note)
+          await this.deliver(note);
+        if (attachments.length)
+          await this.deliver(text, { attachments });
+      } catch (e) {
+        log.warn(this.d.worktreeId, "what followed the answer did not go", e);
+      }
+    } : undefined;
+    ask.settle(skipped ? "skipped" : "answered", reply, before);
   }
   cancelAsks(outcome = "cancelled") {
     for (const ask of [...this.asks.values()])
@@ -18803,6 +19018,7 @@ function defaultAgent(wt, d, preview, onProcess) {
     setSessionId: (id) => d.state.setSession(wt.id, id),
     onEvent: (event, seq) => d.hub.emit("agent", wt.id, seq, event),
     onStatus: (status) => d.hub.emit("agentStatus", wt.id, status),
+    onStopping: () => d.hub.emit("agentStopping", wt.id),
     beforeTurn: async () => d.turnStarting?.(wt.id),
     onAuth: (agentId, o) => d.readiness?.observe(agentId, o),
     onLimits: (agentId, limits) => d.readiness?.observeLimits(agentId, limits),
@@ -19648,8 +19864,8 @@ class RuntimeRegistry {
 
 // ../daemon/src/worktrees/naming.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { existsSync as existsSync13 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join12 } from "path";
 function shortId() {
   return randomBytes3(5).toString("hex");
 }
@@ -19657,7 +19873,7 @@ function freeSlot(parent) {
   for (;; ) {
     const id = shortId();
     const dir = `wt-${id.slice(0, 4)}`;
-    if (!existsSync13(join11(parent, dir)))
+    if (!existsSync14(join12(parent, dir)))
       return { id, dir };
   }
 }
@@ -19685,6 +19901,7 @@ function variantLens(index) {
 }
 
 // ../daemon/src/agent/recap.ts
+var DAEMON_STOPS = new Set(["interrupted", "failed", "auth", "lost"]);
 var REPLY_KEEP = 2000;
 var CLIP = 160;
 function clip(text, max = CLIP) {
@@ -19807,7 +20024,7 @@ function openAskOf(entries) {
 }
 function factsOf(turns, end, ask) {
   const last = turns.at(-1);
-  const cut = last?.stop && last.stop !== "end_turn" && last.stop !== "interrupted" ? last.stop : undefined;
+  const cut = last?.stop && last.stop !== "end_turn" && !DAEMON_STOPS.has(last.stop) ? last.stop : undefined;
   return {
     turns: Math.max(1, turns.length),
     edits: turns.reduce((n, t) => n + t.edits, 0),
@@ -20114,8 +20331,8 @@ function makePlanner(agents) {
 }
 
 // ../daemon/src/agent/transcriptForward.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync12, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
+import { join as join13 } from "path";
 var FORWARD_STEP = "1";
 var MARK = '"page';
 function forwardLine(line) {
@@ -20157,22 +20374,22 @@ function forwardTranscripts(dirs, stamp) {
   let files = 0;
   let rows = 0;
   for (const path of dirs.flatMap(transcriptsUnder)) {
-    const { text, changed } = forwardText(readFileSync11(path, "utf8"));
+    const { text, changed } = forwardText(readFileSync12(path, "utf8"));
     if (!changed)
       continue;
     const tmp = `${path}.tmp`;
-    writeFileSync6(tmp, text);
-    renameSync2(tmp, path);
+    writeFileSync7(tmp, text);
+    renameSync3(tmp, path);
     files++;
     rows += changed;
   }
-  writeFileSync6(stamp, FORWARD_STEP);
+  writeFileSync7(stamp, FORWARD_STEP);
   if (files)
     log.info("transcripts", `moved ${rows} row(s) in ${files} transcript(s) past the preview-threw row`);
 }
 function readStamp(stamp) {
   try {
-    return readFileSync11(stamp, "utf8").trim();
+    return readFileSync12(stamp, "utf8").trim();
   } catch {
     return null;
   }
@@ -20181,10 +20398,10 @@ function transcriptsUnder(dir) {
   const found = [];
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
     if (entry.isFile() && entry.name.endsWith(".jsonl"))
-      found.push(join12(dir, entry.name));
+      found.push(join13(dir, entry.name));
     else if (entry.isDirectory()) {
-      const inner = join12(dir, entry.name, "transcript.jsonl");
-      if (existsSync14(inner))
+      const inner = join13(dir, entry.name, "transcript.jsonl");
+      if (existsSync15(inner))
         found.push(inner);
     }
   }
@@ -20192,23 +20409,23 @@ function transcriptsUnder(dir) {
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync15, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync5 } from "fs";
-import { join as join13, resolve as resolve5 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync5 } from "fs";
+import { join as join14, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
-  const packaged = existsSync15(join13(here, "shell", "index.html"));
+  const packaged = existsSync16(join14(here, "shell", "index.html"));
   return {
-    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join13(here, "shell") : join13(here, "../../shell/dist")),
-    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join13(here, "bridge.js") : join13(here, "../../bridge/dist/bridge.js")),
-    helperStub: packaged ? join13(here, "helper-stub") : join13(here, "../dist/helper-stub"),
-    cliEntry: packaged ? join13(here, "cli.js") : join13(here, "../../cli/src/cli.ts"),
+    shellDist: env.TOYON_SHELL_DIST ?? (packaged ? join14(here, "shell") : join14(here, "../../shell/dist")),
+    bridgeJs: env.TOYON_BRIDGE_JS ?? (packaged ? join14(here, "bridge.js") : join14(here, "../../bridge/dist/bridge.js")),
+    helperStub: packaged ? join14(here, "helper-stub") : join14(here, "../dist/helper-stub"),
+    cliEntry: packaged ? join14(here, "cli.js") : join14(here, "../../cli/src/cli.ts"),
     sourceRoot: packaged ? null : resolve5(here, "../../.."),
-    packageJson: packaged ? join13(here, "..", "package.json") : null,
-    changelog: packaged ? join13(here, "CHANGELOG.md") : resolve5(here, "../../../CHANGELOG.md")
+    packageJson: packaged ? join14(here, "..", "package.json") : null,
+    changelog: packaged ? join14(here, "CHANGELOG.md") : resolve5(here, "../../../CHANGELOG.md")
   };
 }
 var KEEP_MS = 3 * 24 * 60 * 60 * 1000;
 function pruneAssets(shellDist) {
-  const dir = join13(shellDist, "assets");
+  const dir = join14(shellDist, "assets");
   let names;
   try {
     names = readdirSync6(dir);
@@ -20217,7 +20434,7 @@ function pruneAssets(shellDist) {
   }
   const found = [];
   for (const name of names) {
-    const path = join13(dir, name);
+    const path = join14(dir, name);
     try {
       found.push({ path, mtime: statSync5(path).mtimeMs });
     } catch {}
@@ -20662,7 +20879,7 @@ class KeepAwake {
 }
 
 // ../daemon/src/core/dialog.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir6 } from "os";
 var PROMPTS = {
   location: { prompt: "Choose where the new project goes", pick: "folder" },
@@ -20681,7 +20898,7 @@ function folderDialog() {
   let cancelled = false;
   const ask = async (start, purpose) => {
     const typed = start === "~" || start.startsWith("~/") ? `${homedir6()}${start.slice(1)}` : start;
-    const from = typed.startsWith("/") && existsSync16(typed) ? typed : homedir6();
+    const from = typed.startsWith("/") && existsSync17(typed) ? typed : homedir6();
     cancelled = false;
     const { prompt, pick } = PROMPTS[purpose];
     const p = Bun.spawn(["osascript", ...script(pick).flatMap((line) => ["-e", line]), prompt, from], {
@@ -20759,9 +20976,9 @@ class GrantCodes {
 
 // ../daemon/src/core/helper.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { chmod, copyFile as copyFile3, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename5, dirname as dirname5, join as join14 } from "path";
+import { basename as basename5, dirname as dirname6, join as join15 } from "path";
 var EXECUTABLE = "Toyon";
 function helperWanted(where) {
   return where.platform === "darwin" && !where.cloud && where.port === DAEMON_DEFAULT_PORT && where.home === undefined;
@@ -20828,7 +21045,7 @@ class Helper {
   run;
   constructor(spec, run2) {
     this.spec = spec;
-    this.run = run2 ?? (async (cmd) => (await run(cmd[0], cmd.slice(1), dirname5(spec.dir))).ok);
+    this.run = run2 ?? (async (cmd) => (await run(cmd[0], cmd.slice(1), dirname6(spec.dir))).ok);
   }
   startLink() {
     return this.ready ? START_LINK : null;
@@ -20840,23 +21057,23 @@ class Helper {
   }
   async write() {
     const { spec } = this;
-    if (!existsSync17(spec.stub))
+    if (!existsSync18(spec.stub))
       return "skipped";
     const stubHash = createHash3("sha256").update(await readFile2(spec.stub)).digest("hex").slice(0, 16);
     const { plist, script } = helperFiles(spec, stubHash);
-    const contents = join14(spec.dir, "Contents");
-    const resources = join14(contents, "Resources");
-    const stub = join14(contents, "MacOS", EXECUTABLE);
-    const scriptFile = join14(resources, "launch.sh");
-    if (existsSync17(stub) && existsSync17(scriptFile) && await readFile2(scriptFile, "utf8") === script)
+    const contents = join15(spec.dir, "Contents");
+    const resources = join15(contents, "Resources");
+    const stub = join15(contents, "MacOS", EXECUTABLE);
+    const scriptFile = join15(resources, "launch.sh");
+    if (existsSync18(stub) && existsSync18(scriptFile) && await readFile2(scriptFile, "utf8") === script)
       return "kept";
-    await mkdir2(join14(contents, "MacOS"), { recursive: true });
+    await mkdir2(join15(contents, "MacOS"), { recursive: true });
     await mkdir2(resources, { recursive: true });
-    await writeFile2(join14(contents, "Info.plist"), plist);
+    await writeFile2(join15(contents, "Info.plist"), plist);
     await writeFile2(scriptFile, script, { mode: 493 });
     await copyFile3(spec.stub, stub);
     await chmod(stub, 493);
-    if (!existsSync17(join14(resources, "AppIcon.icns")))
+    if (!existsSync18(join15(resources, "AppIcon.icns")))
       await this.drawIcon(resources);
     await this.run(["xattr", "-cr", spec.dir]);
     if (!await this.run(["codesign", "--force", "--deep", "-s", "-", spec.dir])) {
@@ -20867,16 +21084,16 @@ class Helper {
   }
   async drawIcon(resources) {
     const svg = this.spec.icon;
-    const tmp = join14(resources, "iconset.tmp");
-    const set = join14(tmp, "AppIcon.iconset");
+    const tmp = join15(resources, "iconset.tmp");
+    const set = join15(tmp, "AppIcon.iconset");
     await mkdir2(set, { recursive: true });
     await this.run(["qlmanage", "-t", "-s", "1024", "-o", tmp, svg]);
-    const big = join14(tmp, `${basename5(svg)}.png`);
-    if (existsSync17(big)) {
+    const big = join15(tmp, `${basename5(svg)}.png`);
+    if (existsSync18(big)) {
       for (const size of [16, 32, 64, 128, 256, 512, 1024]) {
-        await this.run(["sips", "-z", String(size), String(size), big, "--out", join14(set, `icon_${size}x${size}.png`)]);
+        await this.run(["sips", "-z", String(size), String(size), big, "--out", join15(set, `icon_${size}x${size}.png`)]);
       }
-      await this.run(["iconutil", "-c", "icns", set, "-o", join14(resources, "AppIcon.icns")]);
+      await this.run(["iconutil", "-c", "icns", set, "-o", join15(resources, "AppIcon.icns")]);
     }
     await rm(tmp, { recursive: true, force: true });
   }
@@ -21100,7 +21317,7 @@ class Origins {
 }
 
 // ../daemon/src/core/remoteSwitch.ts
-import { writeFileSync as writeFileSync7 } from "fs";
+import { writeFileSync as writeFileSync8 } from "fs";
 class RemoteSwitch {
   d;
   constructor(d) {
@@ -21133,7 +21350,7 @@ class RemoteSwitch {
     const accepted = acceptRemote(view, this.d.policy);
     if (typeof accepted === "string")
       throw new UserError(accepted);
-    writeFileSync7(this.d.file, `${JSON.stringify(accepted, null, 2)}
+    writeFileSync8(this.d.file, `${JSON.stringify(accepted, null, 2)}
 `);
     return this.live(accepted);
   }
@@ -21156,12 +21373,12 @@ import { spawn as spawn4 } from "child_process";
 import { homedir as homedir7 } from "os";
 
 // ../shared/src/logfile.ts
-import { chmodSync, existsSync as existsSync18, openSync, renameSync as renameSync3, statSync as statSync6 } from "fs";
+import { chmodSync, existsSync as existsSync19, openSync, renameSync as renameSync4, statSync as statSync6 } from "fs";
 var LOG_ROTATE_BYTES = 10 * 1024 * 1024;
 var previousLog = (path) => `${path}.1`;
 function openLog(path, maxBytes = LOG_ROTATE_BYTES) {
-  if (existsSync18(path) && statSync6(path).size > maxBytes)
-    renameSync3(path, previousLog(path));
+  if (existsSync19(path) && statSync6(path).size > maxBytes)
+    renameSync4(path, previousLog(path));
   const fd = openSync(path, "a", 384);
   chmodSync(path, 384);
   return fd;
@@ -21328,7 +21545,7 @@ class SelfWatch {
 
 // ../daemon/src/core/state.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync12, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync13, renameSync as renameSync5, writeFileSync as writeFileSync9 } from "fs";
 var TRUSTED_MAX = 16;
 var DAEMON_GROUPS = "daemon";
 var GROUPS_SAVE_MS = 250;
@@ -21337,11 +21554,11 @@ var empty = { repos: [], worktrees: [], sessions: {} };
 function loadState(paths) {
   ensureDirs(paths);
   const STATE_FILE = paths.stateFile;
-  if (!existsSync19(STATE_FILE))
+  if (!existsSync20(STATE_FILE))
     return structuredClone(empty);
   let raw;
   try {
-    raw = readFileSync12(STATE_FILE, "utf8");
+    raw = readFileSync13(STATE_FILE, "utf8");
   } catch (e) {
     log.error("state", `cannot read ${STATE_FILE}; starting empty`, e);
     return structuredClone(empty);
@@ -21352,7 +21569,7 @@ function loadState(paths) {
   } catch (e) {
     const backup = `${STATE_FILE}.corrupt-${Date.now()}`;
     try {
-      writeFileSync8(backup, raw);
+      writeFileSync9(backup, raw);
     } catch (be) {
       log.warn("state", "could not write the corrupt-state backup", be);
     }
@@ -21383,16 +21600,16 @@ function loadState(paths) {
 }
 function saveState(paths, state) {
   const tmp = `${paths.stateFile}.tmp`;
-  writeFileSync8(tmp, JSON.stringify(state, null, 2));
-  renameSync4(tmp, paths.stateFile);
+  writeFileSync9(tmp, JSON.stringify(state, null, 2));
+  renameSync5(tmp, paths.stateFile);
 }
 function loadOrCreateToken(paths) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
-  if (existsSync19(TOKEN_FILE))
-    return readFileSync12(TOKEN_FILE, "utf8").trim();
+  if (existsSync20(TOKEN_FILE))
+    return readFileSync13(TOKEN_FILE, "utf8").trim();
   const token = randomBytes6(32).toString("hex");
-  writeFileSync8(TOKEN_FILE, token, { mode: 384 });
+  writeFileSync9(TOKEN_FILE, token, { mode: 384 });
   return token;
 }
 
@@ -21855,7 +22072,7 @@ class Tailnet {
 }
 
 // ../daemon/src/design/service.ts
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // ../daemon/src/design/scan.ts
 var COLOR = /^(#|rgba?\(|hsla?\(|oklch\(|oklab\(|lab\(|lch\(|color\(|color-mix\(|light-dark\()/i;
@@ -22305,7 +22522,7 @@ class DesignService {
 async function readAll(root, paths) {
   const out = [];
   for (const path of paths) {
-    const file = Bun.file(join15(root, path));
+    const file = Bun.file(join16(root, path));
     if (file.size === 0 || file.size > MAX_FILE_BYTES)
       continue;
     try {
@@ -22420,14 +22637,14 @@ function typicalUse(classes) {
 var normal = (s) => s.replace(/[-_]/g, "").toLowerCase();
 async function loadProjectTypescript(root) {
   try {
-    return await import(join15(root, "node_modules", "typescript", "lib", "typescript.js"));
+    return await import(join16(root, "node_modules", "typescript", "lib", "typescript.js"));
   } catch {
     return null;
   }
 }
 
 // ../daemon/src/drafts/store.ts
-import { existsSync as existsSync20, readFileSync as readFileSync13, renameSync as renameSync5, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync14, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "fs";
 var SAVE_DELAY_MS = 1000;
 
 class DraftStore {
@@ -22564,10 +22781,10 @@ class DraftStore {
   }
 }
 function readRecord(file) {
-  if (!existsSync20(file))
+  if (!existsSync21(file))
     return [];
   try {
-    const raw = JSON.parse(readFileSync13(file, "utf8"));
+    const raw = JSON.parse(readFileSync14(file, "utf8"));
     return raw && typeof raw === "object" ? Object.entries(raw) : [];
   } catch (e) {
     log.warn("drafts", `skipped an unreadable ${file}`, e);
@@ -22577,8 +22794,8 @@ function readRecord(file) {
 function writeAtomic(file, value) {
   const tmp = `${file}.tmp`;
   try {
-    writeFileSync9(tmp, JSON.stringify(value));
-    renameSync5(tmp, file);
+    writeFileSync10(tmp, JSON.stringify(value));
+    renameSync6(tmp, file);
   } catch (e) {
     log.error("drafts", `could not write ${file}`, e);
   }
@@ -22824,13 +23041,13 @@ import { stat as stat3 } from "fs/promises";
 import { basename as basename6, resolve as resolve7 } from "path";
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync21, statSync as statSync7 } from "fs";
+import { existsSync as existsSync22, statSync as statSync7 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname6, join as join16 } from "path";
+import { dirname as dirname7, join as join17 } from "path";
 var MAX_ENTRIES = 40;
 function expandTilde(raw) {
-  return raw === "~" || raw.startsWith("~/") ? join16(homedir8(), raw.slice(1)) : raw;
+  return raw === "~" || raw.startsWith("~/") ? join17(homedir8(), raw.slice(1)) : raw;
 }
 function collapseTilde(abs) {
   const home = homedir8();
@@ -22841,7 +23058,7 @@ function holdsNothing(names) {
 }
 async function describeFolder(abs) {
   const path = collapseTilde(abs);
-  if (existsSync21(join16(abs, ".git")))
+  if (existsSync22(join17(abs, ".git")))
     return { path, kind: "project" };
   try {
     return { path, kind: holdsNothing(await readdir(abs)) ? "empty" : "folder" };
@@ -22859,11 +23076,11 @@ function describe2(typed, parent) {
     isFile = st.isFile();
   } catch {}
   return {
-    exists: existsSync21(typed),
+    exists: existsSync22(typed),
     isDir,
-    isRepo: isDir && existsSync21(join16(typed, ".git")),
+    isRepo: isDir && existsSync22(join17(typed, ".git")),
     isFile,
-    parentExists: existsSync21(parent)
+    parentExists: existsSync22(parent)
   };
 }
 async function browsePath(raw) {
@@ -22871,7 +23088,7 @@ async function browsePath(raw) {
   if (!typed.startsWith("/"))
     return { entries: [], target: NOWHERE };
   const listing = typed.endsWith("/");
-  const dir = listing ? typed : dirname6(typed);
+  const dir = listing ? typed : dirname7(typed);
   const prefix = listing ? "" : typed.slice(dir.length).replace(/^\//, "").toLowerCase();
   const target = describe2(listing ? typed.replace(/\/+$/, "") : typed, dir);
   let found;
@@ -22879,7 +23096,7 @@ async function browsePath(raw) {
     const listed = await readdir(dir, { withFileTypes: true });
     found = listed.map((e) => ({
       name: e.name,
-      isFile: e.isSymbolicLink() ? isFileAt(join16(dir, e.name)) : e.isFile() ? true : e.isDirectory() ? false : null
+      isFile: e.isSymbolicLink() ? isFileAt(join17(dir, e.name)) : e.isFile() ? true : e.isDirectory() ? false : null
     })).filter((e) => e.isFile !== null);
   } catch {
     return { entries: [], target };
@@ -22890,8 +23107,8 @@ async function browsePath(raw) {
       continue;
     if (!name.toLowerCase().startsWith(prefix))
       continue;
-    const abs = join16(dir, name);
-    entries.push({ path: collapseTilde(abs), name, isRepo: !isFile && existsSync21(join16(abs, ".git")), isFile });
+    const abs = join17(dir, name);
+    entries.push({ path: collapseTilde(abs), name, isRepo: !isFile && existsSync22(join17(abs, ".git")), isFile });
   }
   const rank = (e) => e.isRepo ? 0 : e.isFile ? 2 : 1;
   entries.sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name));
@@ -23014,7 +23231,7 @@ function withFetchLock(repoPath, fn) {
 var fileLockKey = (absPath) => `file:${absPath}`;
 
 // ../daemon/src/git/status.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 async function treeFingerprint(worktreePath) {
   const [head, diff, untracked] = await Promise.all([
     git(worktreePath, "rev-parse", "HEAD"),
@@ -23024,7 +23241,7 @@ async function treeFingerprint(worktreePath) {
   const others = await Promise.all(untracked.out.split(`
 `).filter(Boolean).map(async (p) => {
     try {
-      const f = Bun.file(join17(worktreePath, p));
+      const f = Bun.file(join18(worktreePath, p));
       const body = f.size > 2000000 ? String(f.size) : Bun.hash(await f.arrayBuffer()).toString(36);
       return `${p}:${body}`;
     } catch {
@@ -23109,7 +23326,7 @@ async function numstat(worktreePath, ...range) {
 }
 async function untrackedLines(worktreePath, file, budget) {
   try {
-    const f = Bun.file(join17(worktreePath, file));
+    const f = Bun.file(join18(worktreePath, file));
     if (f.size > 2000000 || f.size > budget.left)
       return {};
     budget.left -= f.size;
@@ -23822,7 +24039,7 @@ class OpenService {
   async grant(path, size, mtimeMs) {
     const name = basename6(path);
     if (this.d.refused.some((r) => within2(path, canonical(resolve7(r))))) {
-      throw new UserError(`${name} is inside Toyon's own folder, which is not for editing`);
+      throw new UserError(`${name} is Toyon's own state, which the daemon keeps itself`);
     }
     const id = shortId();
     if (size > FILE_MAX_CHARS) {
@@ -24215,9 +24432,9 @@ class AfterLand {
 }
 
 // ../daemon/src/repos/registry.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync7, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename8, dirname as dirname8, join as join21 } from "path";
+import { basename as basename8, dirname as dirname9, join as join22 } from "path";
 
 // ../daemon/src/git/base.ts
 async function resolveBase(repoPath, defaultBranch, route) {
@@ -24228,8 +24445,8 @@ async function resolveBase(repoPath, defaultBranch, route) {
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync22, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync14, readSync, statSync as statSync8 } from "fs";
-import { join as join18 } from "path";
+import { closeSync, existsSync as existsSync23, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync15, readSync, statSync as statSync8 } from "fs";
+import { join as join19 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -25593,7 +25810,7 @@ function applyEdits(text, edits) {
 
 // ../daemon/src/repos/config.ts
 var PLACES = [CONFIG_FILES.folder, CONFIG_FILES.root];
-var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync22(join18(repoPath, rel)));
+var present = (repoPath, place) => [place.shared, place.local].filter((rel) => existsSync23(join19(repoPath, rel)));
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function parseSettings(text) {
   const errors = [];
@@ -25618,7 +25835,7 @@ function readConfigFile(repoPath) {
   for (const rel of files) {
     let raw;
     try {
-      raw = parseSettings(readFileSync14(join18(repoPath, rel), "utf8"));
+      raw = parseSettings(readFileSync15(join19(repoPath, rel), "utf8"));
     } catch (e) {
       return { ok: false, reason: `${rel} is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -25677,12 +25894,12 @@ function configTarget(repoPath, made) {
 }
 function configBody(repoPath, rel, config) {
   const place = PLACES.find((p) => p.local === rel);
-  const abs = place && join18(repoPath, place.shared);
-  if (!abs || !existsSync22(abs))
+  const abs = place && join19(repoPath, place.shared);
+  if (!abs || !existsSync23(abs))
     return config;
   let shared;
   try {
-    shared = parseSettings(readFileSync14(abs, "utf8"));
+    shared = parseSettings(readFileSync15(abs, "utf8"));
   } catch {
     return config;
   }
@@ -25695,7 +25912,7 @@ function configText(repoPath, rel, config) {
   let text;
   let was;
   try {
-    text = readFileSync14(join18(repoPath, rel), "utf8");
+    text = readFileSync15(join19(repoPath, rel), "utf8");
     was = parseSettings(text);
   } catch {
     return fresh;
@@ -25725,9 +25942,9 @@ function detectConfig(repoPath) {
     return { config: explicit.config, needsSetup: false };
   if (explicit)
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
-  const pkgPath = join18(repoPath, "package.json");
-  if (existsSync22(pkgPath)) {
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+  const pkgPath = join19(repoPath, "package.json");
+  if (existsSync23(pkgPath)) {
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
     const pages = detectPages(repoPath, scripts, runner);
@@ -25748,7 +25965,7 @@ function detectConfig(repoPath) {
       };
     }
   }
-  if (existsSync22(join18(repoPath, "start.sh"))) {
+  if (existsSync23(join19(repoPath, "start.sh"))) {
     return { config: { run: { app: "./start.sh" } }, needsSetup: true, from: "start.sh" };
   }
   const assumed = assumeNothingToRun(repoPath);
@@ -25791,7 +26008,7 @@ function assumeNothingToRun(repoPath) {
   return marker && !servesPage(repoPath) ? marker : undefined;
 }
 function markerIn(repoPath) {
-  const named = NO_PAGE_MARKERS.find((f) => existsSync22(join18(repoPath, f)));
+  const named = NO_PAGE_MARKERS.find((f) => existsSync23(join19(repoPath, f)));
   if (named)
     return named;
   let entries;
@@ -25803,12 +26020,12 @@ function markerIn(repoPath) {
   return entries.find((f) => NO_PAGE_EXTENSIONS.some((ext) => f.endsWith(ext)));
 }
 function servesPage(repoPath) {
-  if (WEB_FILES.some((f) => existsSync22(join18(repoPath, f))))
+  if (WEB_FILES.some((f) => existsSync23(join19(repoPath, f))))
     return true;
-  if (/^web:/m.test(head(join18(repoPath, "Procfile"))))
+  if (/^web:/m.test(head(join19(repoPath, "Procfile"))))
     return true;
   for (const [files, names] of WEB_DEPENDENCIES) {
-    const text = files.map((f) => head(join18(repoPath, f))).join(`
+    const text = files.map((f) => head(join19(repoPath, f))).join(`
 `);
     if (text.trim() && names.some((n) => mentions(text, n)))
       return true;
@@ -25825,7 +26042,7 @@ function frontEndBeside(repoPath) {
   return dirs.some((d) => {
     if (!d.isDirectory() || d.name.startsWith(".") || NOT_A_PACKAGE.has(d.name))
       return false;
-    const pkg = head(join18(repoPath, d.name, "package.json"));
+    const pkg = head(join19(repoPath, d.name, "package.json"));
     if (!pkg)
       return false;
     try {
@@ -25840,7 +26057,7 @@ function mentions(text, name) {
   return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i").test(text);
 }
 function head(path) {
-  if (!existsSync22(path))
+  if (!existsSync23(path))
     return "";
   try {
     const fd = openSync2(path, "r");
@@ -25881,11 +26098,11 @@ function isLocalDatabase(url) {
 }
 function detectServices(repoPath) {
   const out = {};
-  const compose = COMPOSE_FILES.find((f) => existsSync22(join18(repoPath, f)));
+  const compose = COMPOSE_FILES.find((f) => existsSync23(join19(repoPath, f)));
   if (compose)
     out.compose = compose;
   for (const file of ENV_FILES) {
-    const text = head(join18(repoPath, file));
+    const text = head(join19(repoPath, file));
     if (!text)
       continue;
     for (const name of DB_URL_NAMES) {
@@ -25909,7 +26126,7 @@ function inferPaths(cmd, repoPath, depth = 1) {
       return;
     let dir = false;
     try {
-      dir = statSync8(join18(repoPath, clean)).isDirectory();
+      dir = statSync8(join19(repoPath, clean)).isDirectory();
     } catch {
       return;
     }
@@ -25920,25 +26137,25 @@ function inferPaths(cmd, repoPath, depth = 1) {
     const t = tokens[i];
     if (t === "cd") {
       const dir = tokens[i + 1];
-      if (dir && !dir.startsWith("-") && existsSync22(join18(repoPath, dir)))
+      if (dir && !dir.startsWith("-") && existsSync23(join19(repoPath, dir)))
         add(dir);
       continue;
     }
     if (t.startsWith("-") || t.startsWith("$"))
       continue;
     const mod = /^([A-Za-z_]\w*)(?:\.\w+)*:\w+$/.exec(t);
-    if (mod?.[1] && existsSync22(join18(repoPath, mod[1]))) {
+    if (mod?.[1] && existsSync23(join19(repoPath, mod[1]))) {
       add(mod[1]);
       continue;
     }
     const rel = t.replace(/^\.\//, "");
     if (rel.startsWith("/") || rel.startsWith("..") || rel.includes("="))
       continue;
-    if (!existsSync22(join18(repoPath, rel)))
+    if (!existsSync23(join19(repoPath, rel)))
       continue;
     add(rel);
     if (depth > 0 && rel.endsWith(".sh")) {
-      for (const p of inferPaths(head(join18(repoPath, rel)), repoPath, depth - 1))
+      for (const p of inferPaths(head(join19(repoPath, rel)), repoPath, depth - 1))
         out.add(p);
     }
   }
@@ -25961,31 +26178,31 @@ function procCommand(runner, script, body) {
   return `${base}${runner === "npm" ? " --" : ""} ${flag}`;
 }
 function detectPages(repoPath, scripts, runner) {
-  if (!scripts.build || !existsSync22(join18(repoPath, "functions")))
+  if (!scripts.build || !existsSync23(join19(repoPath, "functions")))
     return null;
-  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join18(repoPath, f)).find((f) => existsSync22(f));
+  const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join19(repoPath, f)).find((f) => existsSync23(f));
   if (!cfg)
     return null;
-  const out = readFileSync14(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
+  const out = readFileSync15(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
   if (!out)
     return null;
   return { web: `${runner} run build && npx wrangler pages dev ${out} --ip 127.0.0.1 --port $PORT` };
 }
 function detectRunner(repoPath, packageManager) {
-  if (existsSync22(join18(repoPath, "bun.lock")) || existsSync22(join18(repoPath, "bun.lockb")))
+  if (existsSync23(join19(repoPath, "bun.lock")) || existsSync23(join19(repoPath, "bun.lockb")))
     return "bun";
-  if (existsSync22(join18(repoPath, "pnpm-lock.yaml")))
+  if (existsSync23(join19(repoPath, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync22(join18(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
+  if (existsSync23(join19(repoPath, "yarn.lock")) || typeof packageManager === "string" && packageManager.startsWith("yarn"))
     return "yarn";
   return "npm";
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync23, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
+import { existsSync as existsSync24, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir3, rm as rm2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname7, join as join19, resolve as resolve8 } from "path";
+import { dirname as dirname8, join as join20, resolve as resolve8 } from "path";
 function isInside(dir, parent) {
   const p = parent.replace(/\/+$/, "");
   return dir === p || dir.startsWith(`${p}/`);
@@ -25996,35 +26213,35 @@ function planProject(opts, home = homedir9()) {
     throw new UserError(nameError);
   const first = firstProjectsFolder(opts.parent, home);
   const parent = first ?? resolveParent(opts.parent);
-  const dir = join19(parent, opts.name.trim());
-  if (existsSync23(dir))
+  const dir = join20(parent, opts.name.trim());
+  if (existsSync24(dir))
     throw new UserError(`${dir} already exists`);
   return { parent, dir, makeParent: first !== null };
 }
 function firstProjectsFolder(raw, home) {
   const typed = expandTilde(raw.trim()).replace(/\/+$/, "");
-  if (typed !== join19(home, PROJECTS_FOLDER) || existsSync23(typed) || !existsSync23(home))
+  if (typed !== join20(home, PROJECTS_FOLDER) || existsSync24(typed) || !existsSync24(home))
     return null;
-  return join19(realpathSync2(home), PROJECTS_FOLDER);
+  return join20(realpathSync2(home), PROJECTS_FOLDER);
 }
 function planInPlace(opts) {
   const name = opts.name.trim();
   if (!name || name === "." || name === ".." || name.includes("/")) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
-  const typed = join19(resolveParent(opts.parent), name);
-  if (!existsSync23(typed) || !statSync9(typed).isDirectory())
+  const typed = join20(resolveParent(opts.parent), name);
+  if (!existsSync24(typed) || !statSync9(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
-  if (existsSync23(join19(dir, ".git")))
+  if (existsSync24(join20(dir, ".git")))
     throw new UserError(`${dir} is already a project; open it instead`);
-  return { parent: dirname7(dir), dir, makeParent: false };
+  return { parent: dirname8(dir), dir, makeParent: false };
 }
 function resolveParent(raw) {
   const typed = expandTilde(raw.trim());
   if (!typed.startsWith("/"))
     throw new UserError(`${raw} is not a folder path`);
-  if (!existsSync23(typed))
+  if (!existsSync24(typed))
     throw new UserError(`${raw} does not exist; make it first`);
   if (!statSync9(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
@@ -26065,7 +26282,7 @@ async function initWithFirstCommit(dir) {
   if (!exclude.ok)
     throw new UserError(`git rev-parse failed: ${exclude.err}`);
   const excludePath = resolve8(dir, exclude.out);
-  await mkdir3(dirname7(excludePath), { recursive: true });
+  await mkdir3(dirname8(excludePath), { recursive: true });
   await appendFile2(excludePath, `
 ${LOCAL_EXCLUDES.join(`
 `)}
@@ -26105,13 +26322,13 @@ async function undoCreate(dir) {
 }
 async function undoInit(dir) {
   try {
-    await rm2(join19(dir, ".git"), { recursive: true, force: true });
+    await rm2(join20(dir, ".git"), { recursive: true, force: true });
   } catch (e) {
     log.warn(dir, "could not take back a half-made .git", e);
   }
 }
 async function unmakeProject(dir, made) {
-  const target = made === "folder" ? dir : join19(dir, ".git");
+  const target = made === "folder" ? dir : join20(dir, ".git");
   try {
     await rm2(target, { recursive: true, force: true });
   } catch (e) {
@@ -26141,8 +26358,8 @@ async function ok(p, what) {
 }
 
 // ../daemon/src/repos/watcher.ts
-import { existsSync as existsSync24, watch } from "fs";
-import { basename as basename7, join as join20 } from "path";
+import { existsSync as existsSync25, watch } from "fs";
+import { basename as basename7, join as join21 } from "path";
 function watchDefaultBranch(repoPath, branch, onMove) {
   const last = { local: null, upstream: null };
   const read = async () => {
@@ -26195,29 +26412,29 @@ function watchDefaultBranch(repoPath, branch, onMove) {
     ]);
     if (stopped)
       return;
-    const gitDir = common.ok && common.out ? common.out : join20(repoPath, ".git");
+    const gitDir = common.ok && common.out ? common.out : join21(repoPath, ".git");
     tryWatch(gitDir);
-    tryWatch(join20(gitDir, "refs", "heads"));
+    tryWatch(join21(gitDir, "refs", "heads"));
     if (!remote.ok || !remote.out)
       return;
-    const remotes = join20(gitDir, "refs", "remotes");
-    const mine = join20(remotes, remote.out);
+    const remotes = join21(gitDir, "refs", "remotes");
+    const mine = join21(remotes, remote.out);
     let inner = null;
     let mid = null;
     const armInner = () => {
       inner?.close();
-      inner = existsSync24(mine) ? tryWatch(mine) : null;
+      inner = existsSync25(mine) ? tryWatch(mine) : null;
     };
     const armMid = () => {
       mid?.close();
-      mid = existsSync24(remotes) ? tryWatch(remotes, (_event, filename) => {
+      mid = existsSync25(remotes) ? tryWatch(remotes, (_event, filename) => {
         if (!filename || filename === remote.out)
           armInner();
         schedule();
       }) : null;
       armInner();
     };
-    tryWatch(join20(gitDir, "refs"), (_event, filename) => {
+    tryWatch(join21(gitDir, "refs"), (_event, filename) => {
       if (!filename || filename === "remotes")
         armMid();
       schedule();
@@ -26246,7 +26463,7 @@ function watchWorktreeDir(repoPath, onChange) {
     }, 300);
   };
   const arm = (commonDir) => {
-    const dir = join20(commonDir, "worktrees");
+    const dir = join21(commonDir, "worktrees");
     const armInner = () => {
       inner?.close();
       inner = null;
@@ -26289,7 +26506,7 @@ function watchWorktreeDir(repoPath, onChange) {
 function watchConfigFile(repoPath, onChange) {
   const atRoot = new Set([CONFIG_FILES.root.shared, CONFIG_FILES.root.local, CONFIG_DIR]);
   const inDir = new Set([CONFIG_FILES.folder.shared, CONFIG_FILES.folder.local].map((rel) => basename7(rel)));
-  const dir = join20(repoPath, CONFIG_DIR);
+  const dir = join21(repoPath, CONFIG_DIR);
   let timer = null;
   let outer = null;
   let inner = null;
@@ -26304,7 +26521,7 @@ function watchConfigFile(repoPath, onChange) {
   const armInner = () => {
     inner?.close();
     inner = null;
-    if (!existsSync24(dir))
+    if (!existsSync25(dir))
       return;
     try {
       inner = watch(dir, (_event, filename) => {
@@ -26358,7 +26575,7 @@ class RepoRegistry {
   }
   async boot() {
     const { state } = this.d;
-    const gone = state.worktrees.filter((wt) => !existsSync25(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
+    const gone = state.worktrees.filter((wt) => !existsSync26(wt.path) || !state.repos.some((r) => r.id === wt.repoId));
     for (const wt of gone)
       await this.d.worktrees.forgetGone(wt);
     for (const repo of state.repos) {
@@ -26426,7 +26643,7 @@ class RepoRegistry {
       return `${repo.name} is set up now`;
     if (main.promptedAt || main.lastTurn)
       return `${repo.name} has a chat now`;
-    if (existsSync25(join21(repo.path, ".claude")))
+    if (existsSync26(join22(repo.path, ".claude")))
       return `an agent has already run in ${repo.name}`;
     if ((await statusFiles(repo.path)).length > 0 || !await treeEmpty(repo.path)) {
       return `${repo.name} has files in it now`;
@@ -26507,7 +26724,7 @@ class RepoRegistry {
   }
   async register(rawPath, made) {
     const path = expandTilde(rawPath);
-    if (!existsSync25(path))
+    if (!existsSync26(path))
       throw new UserError(`${path} does not exist`);
     if (!await isGitRepo(path))
       throw new UserError(`${path} is not a git repository`);
@@ -26581,10 +26798,10 @@ class RepoRegistry {
       throw new UserError(current.reason);
     const was = configTarget(repo.path, !!repo.made);
     const rel = configSibling(was, kind);
-    const moved = rel !== was && existsSync25(join21(repo.path, was));
+    const moved = rel !== was && existsSync26(join22(repo.path, was));
     if (moved && !(kind === "local" && await isTracked(repo.path, was))) {
       try {
-        rmSync4(join21(repo.path, was));
+        rmSync4(join22(repo.path, was));
       } catch (e) {
         log.warn(repoId, `could not remove ${was}`, e);
       }
@@ -26593,10 +26810,10 @@ class RepoRegistry {
     }
     if (isLocalConfigFile(rel))
       await excludeFromGit(repo.path, rel);
-    const file = join21(repo.path, rel);
+    const file = join22(repo.path, rel);
     try {
-      mkdirSync7(dirname8(file), { recursive: true });
-      writeFileSync10(file, configText(repo.path, rel, config));
+      mkdirSync8(dirname9(file), { recursive: true });
+      writeFileSync11(file, configText(repo.path, rel, config));
     } catch (e) {
       log.warn(repoId, `could not write ${rel}`, e);
     }
@@ -26697,7 +26914,7 @@ class RepoRegistry {
   }
   placeConfig(repo) {
     const rel = configTarget(repo.path, !!repo.made);
-    if (isLocalConfigFile(rel) && existsSync25(join21(repo.path, rel))) {
+    if (isLocalConfigFile(rel) && existsSync26(join22(repo.path, rel))) {
       fireAndForget(repo.id, excludeFromGit(repo.path, rel), "exclude local settings");
     }
     if (repo.configFile === rel)
@@ -26789,7 +27006,7 @@ class RepoRegistry {
 }
 
 // ../daemon/src/routes/service.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // ../daemon/src/routes/fileRouters.ts
 var SKIP = /(^|\/)(node_modules|dist|build|out|coverage|\.next|\.nuxt|\.output|\.svelte-kit|\.vercel|\.netlify)\//;
@@ -28002,7 +28219,7 @@ class RouteService {
     return mergeRoutes(fileRoutes(paths, roots), code);
   }
   async cachedRead(root, path, had, kept, decode) {
-    const abs = join22(root, path);
+    const abs = join23(root, path);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -28027,7 +28244,7 @@ class RouteService {
     }
   }
   async hash(root, file) {
-    const abs = join22(root, file);
+    const abs = join23(root, file);
     const stat = await this.fs.stat(abs);
     if (!stat)
       return null;
@@ -28289,7 +28506,7 @@ function isAlive(pid) {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync26, readFileSync as readFileSync15, statSync as statSync10 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync16, statSync as statSync10 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -28319,7 +28536,7 @@ class BridgeScript {
     this.cache = null;
   }
   get() {
-    if (!existsSync26(this.path))
+    if (!existsSync27(this.path))
       return "// toyon bridge not built";
     const s = statSync10(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
@@ -28328,7 +28545,7 @@ class BridgeScript {
     this.stamp = stamp;
     const origins = [...this.origins, ...this.learned];
     this.cache = `window.__toyonShellOrigins=${JSON.stringify(origins)};
-${readFileSync15(this.path, "utf8")}`;
+${readFileSync16(this.path, "utf8")}`;
     return this.cache;
   }
 }
@@ -28397,50 +28614,50 @@ import { homedir as homedir12, hostname as hostname2 } from "os";
 import { randomBytes as randomBytes7 } from "crypto";
 
 // ../daemon/src/agent/config.ts
-import { existsSync as existsSync27, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir11()) {
   const file = (id, label, path) => ({
     id,
     label,
     path,
-    exists: existsSync27(path)
+    exists: existsSync28(path)
   });
   if (spec.id === "claude") {
     return [
-      file("user-config", "user config (MCP servers, projects)", join23(home, ".claude.json")),
-      file("user-settings", "user settings (permissions, hooks)", join23(home, ".claude", "settings.json")),
-      ...repoPath ? [file("project-mcp", "project MCP servers", join23(repoPath, ".mcp.json"))] : [],
-      ...repoPath ? [file("project-settings", "project settings", join23(repoPath, ".claude", "settings.json"))] : []
+      file("user-config", "user config (MCP servers, projects)", join24(home, ".claude.json")),
+      file("user-settings", "user settings (permissions, hooks)", join24(home, ".claude", "settings.json")),
+      ...repoPath ? [file("project-mcp", "project MCP servers", join24(repoPath, ".mcp.json"))] : [],
+      ...repoPath ? [file("project-settings", "project settings", join24(repoPath, ".claude", "settings.json"))] : []
     ];
   }
   if (spec.id === "codex")
-    return [file("user-config", "config", join23(home, ".codex", "config.toml"))];
+    return [file("user-config", "config", join24(home, ".codex", "config.toml"))];
   return [];
 }
 function describeAgentConfig(spec, repoPath, home = homedir11()) {
   const files = agentConfigFiles(spec, repoPath, home);
   const servers = [];
   if (spec.id === "claude") {
-    const user = readJson(join23(home, ".claude.json"));
+    const user = readJson(join24(home, ".claude.json"));
     servers.push(...serversOf(user?.mcpServers, "user"));
     if (repoPath) {
       const projects = user?.projects;
       const mine = projects?.[repoPath];
       servers.push(...serversOf(mine?.mcpServers, "local"));
-      servers.push(...serversOf(readJson(join23(repoPath, ".mcp.json"))?.mcpServers, "project"));
+      servers.push(...serversOf(readJson(join24(repoPath, ".mcp.json"))?.mcpServers, "project"));
     }
   } else if (spec.id === "codex") {
-    servers.push(...codexServers(join23(home, ".codex", "config.toml")));
+    servers.push(...codexServers(join24(home, ".codex", "config.toml")));
   }
   return { agent: spec.id, files, servers };
 }
 function readJson(path) {
-  if (!existsSync27(path))
+  if (!existsSync28(path))
     return null;
   try {
-    const v = JSON.parse(readFileSync16(path, "utf8"));
+    const v = JSON.parse(readFileSync17(path, "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : null;
   } catch (e) {
     log.warn("agent-config", `${path} is not valid JSON`, e);
@@ -28458,11 +28675,11 @@ function serversOf(raw, scope) {
   });
 }
 function codexServers(path) {
-  if (!existsSync27(path))
+  if (!existsSync28(path))
     return [];
   const out = [];
   let current = null;
-  for (const raw of readFileSync16(path, "utf8").split(`
+  for (const raw of readFileSync17(path, "utf8").split(`
 `)) {
     const line = raw.trim();
     const header = /^\[mcp_servers\.("?)([^\]"]+)\1\]$/.exec(line);
@@ -29381,6 +29598,7 @@ var handlers = {
   },
   continue(msg, _ctx, s) {
     s.fix.goOn(msg.worktreeId);
+    s.worktrees.markPrompted(msg.worktreeId);
   },
   async "write-file"(msg, ctx, s) {
     const head = { t: "file-written", worktreeId: msg.worktreeId, path: msg.path, seq: msg.seq };
@@ -29497,7 +29715,7 @@ var handlers = {
   },
   "agent-decide"(msg, _ctx, s) {
     requireRun(s, msg.worktreeId);
-    s.runtime.agentFor(msg.worktreeId)?.answer(msg.askId, { kind: "choice", choiceId: msg.choiceId });
+    s.runtime.agentFor(msg.worktreeId)?.answer(msg.askId, { kind: "choice", choiceId: msg.choiceId, ...msg.note ? { note: msg.note } : {} });
     s.worktrees.markPrompted(msg.worktreeId);
   },
   async "handoff-answer"(msg, _ctx, s) {
@@ -29650,9 +29868,9 @@ async function dispatch(msg, ctx, s) {
 }
 
 // ../daemon/src/server/http.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { hostname } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // ../daemon/src/server/cors.ts
 var ALLOW_HEADERS = "authorization, content-type";
@@ -29955,7 +30173,7 @@ function createFetch(opts) {
         return new Response("unauthorized", { status: 401 });
       const id = url.pathname.slice("/uploads/".length);
       const path = opts.attachments.uploads.path(id);
-      if (!path || !existsSync28(path))
+      if (!path || !existsSync29(path))
         return new Response("not found", { status: 404 });
       return new Response(Bun.file(path), {
         headers: { "cache-control": IMMUTABLE, ...attachedHeaders(opts.attachments.uploads.imageType(id)) }
@@ -29968,7 +30186,7 @@ function createFetch(opts) {
       const places = worktreeId && file && !extra ? [opts.attachments.fileFor(worktreeId, file), opts.archivedAttachment(worktreeId, file)] : [];
       if (worktreeId && file)
         await opts.attachments.whenWritten(worktreeId, file);
-      const path = places.find((p) => !!p && existsSync28(p));
+      const path = places.find((p) => !!p && existsSync29(p));
       if (!path)
         return new Response("not found", { status: 404 });
       if (url.searchParams.has("where")) {
@@ -30006,12 +30224,12 @@ function createFetch(opts) {
       });
     }
     const rel = url.pathname === "/" ? "/index.html" : url.pathname;
-    const file = join24(opts.shellDist, rel.replaceAll("..", ""));
+    const file = join25(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
-    if (existsSync28(file) && Bun.file(file).size > 0) {
+    if (existsSync29(file) && Bun.file(file).size > 0) {
       if (rel === "/manifest.json") {
-        const { bar, ground } = opts.manifestColors();
-        const manifest = { ...await Bun.file(file).json(), theme_color: bar, background_color: ground };
+        const ground = opts.manifestGround();
+        const manifest = { ...await Bun.file(file).json(), theme_color: ground, background_color: ground };
         return Response.json(manifest, {
           headers: { "content-type": "application/manifest+json", "cache-control": NO_STORE2 }
         });
@@ -30027,8 +30245,8 @@ function createFetch(opts) {
     }
     if (hashed)
       return new Response("not found", { status: 404 });
-    const index = join24(opts.shellDist, "index.html");
-    if (existsSync28(index))
+    const index = join25(opts.shellDist, "index.html");
+    if (existsSync29(index))
       return new Response(Bun.file(index), { headers: { "cache-control": NO_STORE2 } });
     return new Response("Toyon daemon running; shell not built (run: bun run build)", { status: 200 });
   }
@@ -30203,6 +30421,7 @@ function startServer(opts) {
   };
   s.hub.on("worktreesChanged", worktreesChanged);
   s.hub.on("agentStatus", worktreesChanged);
+  s.hub.on("agentStopping", worktreesChanged);
   s.hub.on("reposChanged", () => broadcast({ t: "repos", repos: s.state.repos }));
   s.hub.on("pendingChanged", () => broadcast({ t: "pending-repos", pending: s.repos.pending }));
   s.hub.on("proc", (worktreeId, proc) => broadcast({ t: "proc", worktreeId, proc }));
@@ -30349,10 +30568,7 @@ function startServer(opts) {
       managed: { source: opts.managed.source, hash: opts.managed.hash },
       preview: (id) => s.runtime.get(id)?.proxy?.handler ?? null,
       bootstrap: helloFrame,
-      manifestColors: () => {
-        const { surface0, surface1 } = s.themes.current().colors;
-        return { bar: surface0, ground: surface1 };
-      },
+      manifestGround: () => s.themes.current().colors.surface1,
       open: (path) => s.opens.open(path),
       restart: (now) => s.restarter.request({ now }),
       restartWait: () => ({ waiting: s.restarter.waitingOn(), asking: s.restarter.asking() }),
@@ -30477,16 +30693,16 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync29, readdirSync as readdirSync8, readFileSync as readFileSync17, statSync as statSync11, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync30, readdirSync as readdirSync8, readFileSync as readFileSync18, statSync as statSync11, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename9, dirname as dirname9, join as join25, resolve as resolve9 } from "path";
+import { basename as basename9, dirname as dirname10, join as join26, resolve as resolve9 } from "path";
 var home = homedir13();
 var defaultExtensionDirs = [
-  join25(home, ".vscode", "extensions"),
-  join25(home, ".vscode-insiders", "extensions"),
-  join25(home, ".vscode-oss", "extensions"),
-  join25(home, ".cursor", "extensions"),
-  join25(home, ".windsurf", "extensions"),
+  join26(home, ".vscode", "extensions"),
+  join26(home, ".vscode-insiders", "extensions"),
+  join26(home, ".vscode-oss", "extensions"),
+  join26(home, ".cursor", "extensions"),
+  join26(home, ".windsurf", "extensions"),
   "/Applications/Visual Studio Code.app/Contents/Resources/app/extensions",
   "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions",
   "/Applications/Cursor.app/Contents/Resources/app/extensions",
@@ -30570,14 +30786,14 @@ class ThemeStore {
       name: json?.name ?? base,
       source: "file"
     });
-    writeFileSync11(join25(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
+    writeFileSync12(join26(this.themesDir, `${base}.json`), `${JSON.stringify(theme, null, 2)}
 `);
     this.load();
     return theme;
   }
 }
 function readJsonc(file) {
-  return parse6(readFileSync17(file, "utf8"), [], { allowTrailingComma: true });
+  return parse6(readFileSync18(file, "utf8"), [], { allowTrailingComma: true });
 }
 function readVscodeTheme(file, depth = 0) {
   const json = readJsonc(file);
@@ -30585,7 +30801,7 @@ function readVscodeTheme(file, depth = 0) {
     throw new ThemeImportError(`${file}: not a JSON object`);
   const t = json;
   if (typeof t.include === "string" && depth < 5) {
-    const parent = readVscodeTheme(resolve9(dirname9(file), t.include), depth + 1);
+    const parent = readVscodeTheme(resolve9(dirname10(file), t.include), depth + 1);
     return {
       ...parent,
       ...t,
@@ -30599,13 +30815,13 @@ function readVscodeTheme(file, depth = 0) {
   return t;
 }
 function loadDir(dir) {
-  if (!existsSync29(dir))
+  if (!existsSync30(dir))
     return [];
   const out = [];
   for (const f of readdirSync8(dir)) {
     if (!/\.jsonc?$/i.test(f))
       continue;
-    const file = join25(dir, f);
+    const file = join26(dir, f);
     const id = `file:${slug(f.replace(/\.(json|jsonc)$/i, ""))}`;
     try {
       const json = readJsonc(file);
@@ -30621,7 +30837,7 @@ function loadDir(dir) {
   return out;
 }
 function discover(dir) {
-  if (!existsSync29(dir))
+  if (!existsSync30(dir))
     return [];
   const out = [];
   let entries;
@@ -30631,21 +30847,21 @@ function discover(dir) {
     return out;
   }
   for (const name of entries) {
-    const extDir = join25(dir, name);
-    const pkgFile = join25(extDir, "package.json");
+    const extDir = join26(dir, name);
+    const pkgFile = join26(extDir, "package.json");
     try {
-      if (!statSync11(extDir).isDirectory() || !existsSync29(pkgFile))
+      if (!statSync11(extDir).isDirectory() || !existsSync30(pkgFile))
         continue;
-      const pkg = JSON.parse(readFileSync17(pkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync18(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
       if (!Array.isArray(themes))
         continue;
       const ext = `${pkg.publisher ?? "local"}.${pkg.name ?? name}`;
       let nls = {};
-      const nlsFile = join25(extDir, "package.nls.json");
-      if (existsSync29(nlsFile)) {
+      const nlsFile = join26(extDir, "package.nls.json");
+      if (existsSync30(nlsFile)) {
         try {
-          nls = JSON.parse(readFileSync17(nlsFile, "utf8"));
+          nls = JSON.parse(readFileSync18(nlsFile, "utf8"));
         } catch {}
       }
       for (const c of themes) {
@@ -31057,16 +31273,16 @@ class BackendShare {
 
 // ../daemon/src/worktrees/cache.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync30, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync19 } from "fs";
 import { mkdir as mkdir5, readdir as readdir2, rename, rm as rm4, stat as stat4, utimes, writeFile as writeFile3 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 
 // ../daemon/src/core/clone.ts
 import { mkdir as mkdir4, rm as rm3 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname11 } from "path";
 async function cloneTree(src, dst) {
   const started = Date.now();
-  await mkdir4(dirname10(dst), { recursive: true });
+  await mkdir4(dirname11(dst), { recursive: true });
   const attempts = [
     ["clonefile", ["-Rc", src, dst]],
     ["reflink", ["-R", "--reflink=auto", src, dst]],
@@ -31074,7 +31290,7 @@ async function cloneTree(src, dst) {
   ];
   let error = "";
   for (const [how, args] of attempts) {
-    const r = await run("cp", args, dirname10(dst));
+    const r = await run("cp", args, dirname11(dst));
     if (r.ok)
       return { ok: true, how, ms: Date.now() - started };
     error = r.err.split(`
@@ -31090,7 +31306,7 @@ var STALE_MS = 30 * 24 * 3600000;
 var TMP = ".tmp-";
 var MANIFEST = "manifest.json";
 function defaultTools(dir) {
-  const has = (...files) => files.some((f) => existsSync30(join26(dir, f)));
+  const has = (...files) => files.some((f) => existsSync31(join27(dir, f)));
   const out = [];
   if (has("bun.lock", "bun.lockb"))
     out.push("bun --version");
@@ -31103,7 +31319,7 @@ function defaultTools(dir) {
   return out;
 }
 function withSidecars(root, rel) {
-  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync30(join26(root, n)));
+  return [rel, ...SIDECARS.map((s) => rel + s)].filter((n) => existsSync31(join27(root, n)));
 }
 var entryName = (base, at) => `${base.slice(0, 12)}-${at.toString(36)}`;
 async function listEntries(familyDir) {
@@ -31118,8 +31334,8 @@ async function listEntries(familyDir) {
     const m = /^([0-9a-f]{12})-([0-9a-z]+)$/.exec(name);
     if (!m?.[1] || !m[2])
       continue;
-    const dir = join26(familyDir, name);
-    if (!existsSync30(join26(dir, MANIFEST)))
+    const dir = join27(familyDir, name);
+    if (!existsSync31(join27(dir, MANIFEST)))
       continue;
     out.push({ dir, base: m[1], at: Number.parseInt(m[2], 36) });
   }
@@ -31149,7 +31365,7 @@ class ArtifactCache {
     try {
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const entries = await listEntries(join26(this.d.paths.cacheDir, repo.id, family.key));
+      const entries = await listEntries(join27(this.d.paths.cacheDir, repo.id, family.key));
       const entry = entries.find((e) => e.base === base.slice(0, 12)) ?? entries[0];
       if (!entry) {
         say(`cache: nothing kept for these lockfiles and tools on ${family.platform}`);
@@ -31157,14 +31373,14 @@ class ArtifactCache {
       }
       const restored = [];
       for (const rel of policy.paths) {
-        if (existsSync30(join26(wt.path, rel)))
+        if (existsSync31(join27(wt.path, rel)))
           continue;
         const names = withSidecars(entry.dir, rel);
         if (names.length === 0)
           continue;
         let whole = true;
         for (const name of names) {
-          const r = await (this.d.clone ?? cloneTree)(join26(entry.dir, name), join26(wt.path, name));
+          const r = await (this.d.clone ?? cloneTree)(join27(entry.dir, name), join27(wt.path, name));
           if (r.ok)
             continue;
           say(`cache: could not restore ${name}: ${r.error}`);
@@ -31198,12 +31414,12 @@ class ArtifactCache {
     let tmp;
     let slot;
     try {
-      const present = policy.paths.filter((rel) => existsSync30(join26(wt.path, rel)));
+      const present = policy.paths.filter((rel) => existsSync31(join27(wt.path, rel)));
       if (present.length === 0)
         return;
       const family = await this.family(wt, repo, policy);
       const base = await this.baseCommit(wt, repo);
-      const familyDir = join26(this.d.paths.cacheDir, repo.id, family.key);
+      const familyDir = join27(this.d.paths.cacheDir, repo.id, family.key);
       const key = `${familyDir}/${base.slice(0, 12)}`;
       const kept = (await listEntries(familyDir)).find((e) => e.base === base.slice(0, 12));
       if (kept || this.making.has(key)) {
@@ -31214,21 +31430,21 @@ class ArtifactCache {
       this.making.add(key);
       const at = Date.now();
       const name = entryName(base, at);
-      tmp = join26(familyDir, `${TMP}${name}`);
+      tmp = join27(familyDir, `${TMP}${name}`);
       await mkdir5(tmp, { recursive: true });
       let how = "clonefile";
       for (const rel of present) {
         for (const n of withSidecars(wt.path, rel)) {
-          const r = await (this.d.clone ?? cloneTree)(join26(wt.path, n), join26(tmp, n));
+          const r = await (this.d.clone ?? cloneTree)(join27(wt.path, n), join27(tmp, n));
           if (!r.ok)
             throw new Error(`could not keep ${n}: ${r.error}`);
           how = r.how;
         }
       }
       const manifest = { at, base, platform: family.platform, tools: family.tools, paths: present };
-      await writeFile3(join26(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
+      await writeFile3(join27(tmp, MANIFEST), `${JSON.stringify(manifest, null, 2)}
 `);
-      await rename(tmp, join26(familyDir, name));
+      await rename(tmp, join27(familyDir, name));
       tmp = undefined;
       log.info(worktreeId, `cache: kept ${list(present)} for ${base.slice(0, 7)} via ${how} in ${Date.now() - started}ms`);
       await this.prune(familyDir);
@@ -31256,7 +31472,7 @@ class ArtifactCache {
       return;
     }
     for (const repoId of repoIds) {
-      const repoDir = join26(root, repoId);
+      const repoDir = join27(root, repoId);
       if (!this.d.state.repo(repoId)) {
         await rm4(repoDir, { recursive: true, force: true });
         continue;
@@ -31268,7 +31484,7 @@ class ArtifactCache {
         continue;
       }
       for (const family of families) {
-        const familyDir = join26(repoDir, family);
+        const familyDir = join27(repoDir, family);
         let names;
         try {
           names = await readdir2(familyDir);
@@ -31277,7 +31493,7 @@ class ArtifactCache {
         }
         for (const n of names)
           if (n.startsWith(TMP))
-            await rm4(join26(familyDir, n), { recursive: true, force: true });
+            await rm4(join27(familyDir, n), { recursive: true, force: true });
         const entries = await listEntries(familyDir);
         let newest = 0;
         for (const e of entries) {
@@ -31297,7 +31513,7 @@ class ArtifactCache {
     for (const f of policy.key) {
       h.update(`\x00${f}\x00`);
       try {
-        h.update(readFileSync18(join26(wt.path, f)));
+        h.update(readFileSync19(join27(wt.path, f)));
       } catch {
         h.update("(absent)");
       }
@@ -31502,6 +31718,8 @@ function lastStop(entries) {
     const e = entries[i].event;
     if (e.type === "usage" || e.type === "session-info")
       continue;
+    if (e.type === "turn-end" && (e.stopReason === "failed" || e.stopReason === "auth" || e.stopReason === "lost"))
+      continue;
     if (e.type === "turn-end" && e.stopReason === "interrupted")
       return { kind: "stopped" };
     if (e.type === "agent-error")
@@ -31854,7 +32072,7 @@ class LandingService {
     this.judging.delete(worktreeId);
   }
   note(worktreeId, status) {
-    if (status === "working" || status === "waiting")
+    if (isBusy(status))
       this.busy.add(worktreeId);
     else
       this.busy.delete(worktreeId);
@@ -32537,9 +32755,9 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync35, readFileSync as readFileSync20, rmSync as rmSync8 } from "fs";
+import { cpSync, existsSync as existsSync36, readFileSync as readFileSync21, rmSync as rmSync8 } from "fs";
 import { rm as rm5 } from "fs/promises";
-import { dirname as dirname12, join as join31 } from "path";
+import { dirname as dirname13, join as join32 } from "path";
 
 // ../daemon/src/git/archive.ts
 import { rmSync as rmSync5 } from "fs";
@@ -32663,7 +32881,7 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 var STEP_TIMEOUT_MS = RUN_CEILING_MS;
 function rowOf(r) {
   return r.shown && r.toolId && r.command ? { toolId: r.toolId, command: r.command, text: r.text } : undefined;
@@ -32797,7 +33015,7 @@ async function midway(worktreePath) {
   if (!r.ok)
     return null;
   const at = r.out.split(`
-`).findIndex((file) => file && existsSync31(file));
+`).findIndex((file) => file && existsSync32(file));
   return MIDWAY[at]?.[1] ?? null;
 }
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
@@ -33147,8 +33365,8 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/git/turn.ts
-import { copyFileSync, existsSync as existsSync32, rmSync as rmSync6 } from "fs";
-import { join as join27 } from "path";
+import { copyFileSync, existsSync as existsSync33, rmSync as rmSync6 } from "fs";
+import { join as join28 } from "path";
 var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
 var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
 var queue = new Map;
@@ -33166,14 +33384,14 @@ async function treeNow(wtPath, head, dirty) {
     const dir = await git(wtPath, "rev-parse", "--absolute-git-dir");
     if (!dir.ok || !dir.out)
       return null;
-    index = join27(dir.out, "toyon-turn-index");
+    index = join28(dir.out, "toyon-turn-index");
   }
   const env = { GIT_INDEX_FILE: index };
   const writeTree = async () => {
     const tree = await run(GIT, ["write-tree"], wtPath, env);
     return tree.ok && tree.out ? tree.out : null;
   };
-  if (!existsSync32(index))
+  if (!existsSync33(index))
     was = undefined;
   const paths = dirty && !dirty.some((f) => /[RC]/.test(f.xy)) ? dirty.map((f) => f.path) : null;
   if (was && paths && was.head === head) {
@@ -33188,9 +33406,9 @@ async function treeNow(wtPath, head, dirty) {
     }
   }
   synced.delete(wtPath);
-  if (!existsSync32(index)) {
-    const own = join27(index, "..", "index");
-    if (existsSync32(own))
+  if (!existsSync33(index)) {
+    const own = join28(index, "..", "index");
+    if (existsSync33(own))
       copyFileSync(own, index);
     else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
       return null;
@@ -33271,20 +33489,20 @@ async function dropTurnRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync19, renameSync as renameSync6, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename11, dirname as dirname11, join as join28 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync9, readdirSync as readdirSync9, readFileSync as readFileSync20, renameSync as renameSync7, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename11, dirname as dirname12, join as join29 } from "path";
 class WorktreeArchive {
   dir;
   records = new Map;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync8(dir, { recursive: true });
+    mkdirSync9(dir, { recursive: true });
     for (const id of readdirSync9(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync33(file))
+      if (!existsSync34(file))
         continue;
       try {
-        this.records.set(id, JSON.parse(readFileSync19(file, "utf8")));
+        this.records.set(id, JSON.parse(readFileSync20(file, "utf8")));
       } catch (e) {
         log.warn("archive", `skipped an unreadable record: ${file}`, e);
       }
@@ -33295,11 +33513,11 @@ class WorktreeArchive {
   }
   put(rec, from) {
     const at = this.filesOf(rec.worktree.id);
-    mkdirSync8(at.dir, { recursive: true });
+    mkdirSync9(at.dir, { recursive: true });
     move(from.transcript, at.transcript);
     move(from.attachments, at.attachments);
     move(from.plans, at.plans);
-    writeFileSync12(at.record, JSON.stringify(rec, null, 2));
+    writeFileSync13(at.record, JSON.stringify(rec, null, 2));
     this.records.set(rec.worktree.id, rec);
     return { transcript: at.transcript, attachments: at.attachments, plans: at.plans };
   }
@@ -33328,7 +33546,7 @@ class WorktreeArchive {
     const rec = this.records.get(id);
     if (!rec)
       return;
-    writeFileSync12(this.filesOf(id).record, JSON.stringify(rec, null, 2));
+    writeFileSync13(this.filesOf(id).record, JSON.stringify(rec, null, 2));
   }
   chatFiles(id) {
     if (!this.records.has(id))
@@ -33339,24 +33557,24 @@ class WorktreeArchive {
   planFile(id, rel) {
     if (!this.records.has(id) || !isPlanPath(rel))
       return null;
-    const file = join28(this.filesOf(id).plans, basename11(rel));
-    if (!existsSync33(file))
+    const file = join29(this.filesOf(id).plans, basename11(rel));
+    if (!existsSync34(file))
       return null;
     try {
-      return readFileSync19(file, "utf8");
+      return readFileSync20(file, "utf8");
     } catch (e) {
       log.warn(id, `could not read its archived plan ${rel}`, e);
       return null;
     }
   }
   filesOf(id) {
-    const dir = join28(this.dir, id);
+    const dir = join29(this.dir, id);
     return {
       dir,
-      record: join28(dir, "record.json"),
-      transcript: join28(dir, "transcript.jsonl"),
-      attachments: join28(dir, "attachments"),
-      plans: join28(dir, "plans")
+      record: join29(dir, "record.json"),
+      transcript: join29(dir, "transcript.jsonl"),
+      attachments: join29(dir, "attachments"),
+      plans: join29(dir, "plans")
     };
   }
 }
@@ -33381,9 +33599,9 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync33(transcript))
+  if (!existsSync34(transcript))
     return null;
-  const lines = readFileSync19(transcript, "utf8").split(`
+  const lines = readFileSync20(transcript, "utf8").split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
     if (!lines[i]?.includes('"usage"'))
@@ -33397,9 +33615,9 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync33(transcript))
+  if (!existsSync34(transcript))
     return;
-  for (const line of readFileSync19(transcript, "utf8").split(`
+  for (const line of readFileSync20(transcript, "utf8").split(`
 `)) {
     if (!line.includes('"user-message"'))
       continue;
@@ -33412,11 +33630,11 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync33(from))
+  if (!existsSync34(from))
     return;
-  mkdirSync8(dirname11(to), { recursive: true });
+  mkdirSync9(dirname12(to), { recursive: true });
   rmSync7(to, { recursive: true, force: true });
-  renameSync6(from, to);
+  renameSync7(from, to);
 }
 
 // ../daemon/src/worktrees/archivedGit.ts
@@ -33494,8 +33712,8 @@ async function fillLandMarks(jobs, read, width = 8) {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { existsSync as existsSync34 } from "fs";
-import { basename as basename12, join as join29 } from "path";
+import { existsSync as existsSync35 } from "fs";
+import { basename as basename12, join as join30 } from "path";
 class SparePool {
   d;
   inflight = new Map;
@@ -33518,7 +33736,7 @@ class SparePool {
     if (!text.trim())
       return;
     const wt = this.d.state.worktree(boxId);
-    if (wt?.kind !== "spare" || !existsSync34(wt.path))
+    if (wt?.kind !== "spare" || !existsSync35(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -33563,11 +33781,11 @@ class SparePool {
     return this.record(repoId, repo).then((wt) => this.warmUp(wt, repo, {}));
   }
   async record(repoId, repo) {
-    const { id, dir } = freeSlot(join29(this.d.paths.worktreesDir, repo.name));
+    const { id, dir } = freeSlot(join30(this.d.paths.worktreesDir, repo.name));
     const wt = {
       id,
       repoId,
-      path: join29(this.d.paths.worktreesDir, repo.name, dir),
+      path: join30(this.d.paths.worktreesDir, repo.name, dir),
       branch: repo.defaultBranch,
       kind: "spare",
       phase: "reserved",
@@ -33582,7 +33800,7 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync34(wt.path))
+      if (existsSync35(wt.path))
         return;
       const run = this.d.runs.begin(wt.id, "setup", {
         timeoutMs: timeoutFor(repo.config, "setup"),
@@ -33643,7 +33861,7 @@ class SparePool {
     }
     log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
     this.d.carryDraft?.(wt.id, wt.repoId);
-    if (existsSync34(wt.path)) {
+    if (existsSync35(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -33715,7 +33933,7 @@ class SparePool {
       try {
         await running?.added;
         running?.cut();
-        if (!existsSync34(wt.path))
+        if (!existsSync35(wt.path))
           throw new Error("the worktree's directory is gone");
         await this.refreshing.get(repoId);
         await prepare(wt);
@@ -33743,7 +33961,7 @@ class SparePool {
     for (const k of Object.keys(stamps))
       delete wt[k];
     delete wt.promptedAt;
-    if (!existsSync34(wt.path)) {
+    if (!existsSync35(wt.path)) {
       await this.rollBack(wt, e);
       return;
     }
@@ -33757,7 +33975,7 @@ class SparePool {
 // ../daemon/src/worktrees/treeState.ts
 import { watch as watch2 } from "fs";
 import { stat as stat5 } from "fs/promises";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var EDIT_DELAY_MS = 150;
 var SHELL_QUIET_MS2 = 1500;
 var WATCH_DELAY_MS = 300;
@@ -34140,7 +34358,7 @@ class TreeState {
       xy: f.xy,
       ...entries.folded.has(f.path) ? { add: f.add, del: f.del } : {}
     }));
-    const stats = await Promise.all(files.slice(0, SIGNATURE_STATS).map((f) => stat5(join30(r.path, f.path)).then((s) => `${s.mtimeMs}:${s.size}`, () => "-")));
+    const stats = await Promise.all(files.slice(0, SIGNATURE_STATS).map((f) => stat5(join31(r.path, f.path)).then((s) => `${s.mtimeMs}:${s.size}`, () => "-")));
     const t0 = performance.now();
     const counts = { ...ab, ...unpushed === null ? {} : { unpushed } };
     const signature = String(Bun.hash([
@@ -34449,7 +34667,7 @@ class TurnService {
   }
 }
 function stopOf(prev, next) {
-  const busy = prev === "working" || prev === "waiting";
+  const busy = isBusy(prev);
   if (next === "waiting" && prev !== "waiting")
     return "asking";
   if (next === "idle" && busy)
@@ -34666,8 +34884,8 @@ class WorktreeService {
     if (!await isGitRepo(repo.path)) {
       throw new UserError(`git no longer reads ${repo.name} as a checkout, so there is nothing to start a worktree from. If \`git config core.bare\` says true there, \`git config --unset core.bare\` puts it back.`);
     }
-    const { id, dir } = freeSlot(join31(this.d.paths.worktreesDir, repo.name));
-    const wtPath = join31(this.d.paths.worktreesDir, repo.name, dir);
+    const { id, dir } = freeSlot(join32(this.d.paths.worktreesDir, repo.name));
+    const wtPath = join32(this.d.paths.worktreesDir, repo.name, dir);
     const branch = `toyon/${dir}`;
     await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--no-track", "-b", branch, wtPath, baseOf(repo)));
     const wt = {
@@ -34741,7 +34959,7 @@ class WorktreeService {
       };
       const carried = await git(repo.path, "ls-tree", "-r", "--name-only", `${sha}^3`);
       const restored = (carried.ok ? carried.out.split(`
-`).filter(Boolean) : []).filter((p) => !existsSync35(join31(wt.path, p)));
+`).filter(Boolean) : []).filter((p) => !existsSync36(join32(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -34778,9 +34996,9 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync35(join31(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync36(join32(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
-    const wtPath = join31(this.d.paths.worktreesDir, repo.name, slug);
+    const wtPath = join32(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
       const out = (await listWorktrees(repo.path)).find((w) => w.branch === branch);
       if (out)
@@ -35047,7 +35265,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync35(wt.path))
+    if (cmds.length === 0 || !existsSync36(wt.path))
       return;
     for (const cmd of cmds) {
       const code = await runSetup(cmd, wt.path, (line) => this.d.hub.emit("log", wt.id, "setup", line), worktreeEnv(wt, repo), { timeoutMs: timeoutFor(repo.config, "setup") });
@@ -35056,7 +35274,7 @@ class WorktreeService {
     }
   }
   async keep(repo, wt) {
-    const index = join31(this.d.paths.archiveDir, `${wt.id}.index`);
+    const index = join32(this.d.paths.archiveDir, `${wt.id}.index`);
     const kept = await keepState(repo.path, wt.path, archiveRef(wt.id), index) ?? await this.keepUnlinked(repo, wt);
     if (!kept)
       log.warn(wt.id, "could not keep its git state");
@@ -35088,16 +35306,16 @@ class WorktreeService {
       throw new Error(`git worktree remove --force ${wt.path} failed (${r.exit}): ${r.err}`);
     if (await deleteTree(wt.path))
       return;
-    await run("chmod", ["-R", "u+w", wt.path], dirname12(wt.path));
+    await run("chmod", ["-R", "u+w", wt.path], dirname13(wt.path));
     if (!await deleteTree(wt.path))
       log.warn(wt.id, `its directory could not be deleted and stays at ${wt.path}`);
   }
   plansScratch(worktreeId) {
-    return join31(this.d.paths.archiveDir, `${worktreeId}.plans`);
+    return join32(this.d.paths.archiveDir, `${worktreeId}.plans`);
   }
   keepPlans(wt) {
-    const from = join31(wt.path, PLANS_DIR);
-    if (!existsSync35(from))
+    const from = join32(wt.path, PLANS_DIR);
+    if (!existsSync36(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -35233,11 +35451,15 @@ class WorktreeService {
   }
   archivedTranscript(archiveId) {
     const files = this.archive.chatFiles(archiveId);
-    return files ? new Transcript(files.transcript, archiveId).entries : null;
+    if (!files)
+      return null;
+    const { entries } = new Transcript(files.transcript, archiveId);
+    const seal = sealOpenTurn(entries);
+    return seal ? [...entries, { seq: (entries.at(-1)?.seq ?? -1) + 1, event: seal }] : entries;
   }
   archivedAttachment(archiveId, file) {
     const files = this.archive.chatFiles(archiveId);
-    return files && isAttachmentFile(file) ? join31(files.attachments, file) : null;
+    return files && isAttachmentFile(file) ? join32(files.attachments, file) : null;
   }
   archivedGit(archiveId) {
     const rec = this.archive.get(archiveId);
@@ -35293,7 +35515,7 @@ class WorktreeService {
       throw new UserError(`${old.title} was archived without its commits, so there is nothing to restore`);
     if (rec.auto)
       log.info(old.id, `restoring a worktree that archived itself (${rec.auto})`);
-    const path = existsSync35(old.path) ? join31(dirname12(old.path), freeSlot(dirname12(old.path)).dir) : old.path;
+    const path = existsSync36(old.path) ? join32(dirname13(old.path), freeSlot(dirname13(old.path)).dir) : old.path;
     const { variant: _variant, ...rest } = old;
     const wt = {
       ...rest,
@@ -35332,7 +35554,7 @@ class WorktreeService {
     run.finish(0);
     this.arriving.delete(wt.id);
     wt.branch = branch;
-    move(chat.plans, join31(path, PLANS_DIR));
+    move(chat.plans, join32(path, PLANS_DIR));
     const dropped = await git(repo.path, "update-ref", "-d", archiveRef(old.id));
     if (!dropped.ok)
       log.warn(old.id, `could not drop its archive ref: ${dropped.err}`);
@@ -35408,12 +35630,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync35(repoPath)) {
+    if (rec.kept && existsSync36(repoPath)) {
       const r = await git(repoPath, "update-ref", "-d", archiveRef(archiveId));
       if (!r.ok)
         log.warn(archiveId, `could not drop its archive ref: ${r.err}`);
     }
-    if (rec.worktree.lands?.length && existsSync35(repoPath))
+    if (rec.worktree.lands?.length && existsSync36(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -35474,8 +35696,7 @@ class WorktreeService {
         throw new UserError(`${w.title} cannot be grafted`);
       if (w.repoId !== target.repoId)
         throw new UserError("worktrees must belong to one repo");
-      const status = this.d.runtime.agentFor(w.id)?.status;
-      if (status === "working" || status === "waiting")
+      if (isBusy(this.d.runtime.agentFor(w.id)?.status))
         throw new UserError(`${w.title}'s agent is mid-turn; stop it first`);
     }
     for (const w of all) {
@@ -35521,10 +35742,10 @@ class WorktreeService {
     }
   }
   async mirrorBaseIgnore(repo) {
-    const src = join31(repo.path, ".gitignore");
-    const tracked = existsSync35(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
-    const mirror = existsSync35(src) && !tracked;
-    const lines = mirror ? readFileSync20(src, "utf8").split(`
+    const src = join32(repo.path, ".gitignore");
+    const tracked = existsSync36(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync36(src) && !tracked;
+    const lines = mirror ? readFileSync21(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
   }
@@ -35536,9 +35757,9 @@ class WorktreeService {
       await this.d.cache.restore(wt, repo, (line) => this.d.hub.emit("log", wt.id, "setup", line));
       run.finish(0);
     }
-    const srcNm = join31(depsSource, "node_modules");
-    const dstNm = join31(wt.path, "node_modules");
-    if (existsSync35(srcNm) && !existsSync35(dstNm)) {
+    const srcNm = join32(depsSource, "node_modules");
+    const dstNm = join32(wt.path, "node_modules");
+    if (existsSync36(srcNm) && !existsSync36(dstNm)) {
       const run = this.runs.begin(wt.id, "setup", { timeoutMs: ceiling, stage: "copying dependencies" });
       const r = await cloneTree(srcNm, dstNm);
       run.finish(0);
@@ -35548,10 +35769,10 @@ class WorktreeService {
         log.warn(wt.id, "could not copy node_modules from the base checkout", r.error);
     }
     for (const f of LOCAL_CONFIG_FILES) {
-      const src = join31(depsSource, f);
-      if (!existsSync35(src) || existsSync35(join31(wt.path, f)))
+      const src = join32(depsSource, f);
+      if (!existsSync36(src) || existsSync36(join32(wt.path, f)))
         continue;
-      const r = await run("cp", [src, join31(wt.path, f)], wt.path);
+      const r = await run("cp", [src, join32(wt.path, f)], wt.path);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `copied ${f}`);
       else
@@ -35771,8 +35992,7 @@ ${wt.landing.body}` : s;
     });
   }
   async movedMidTurn(wt) {
-    const status = this.d.runtime.agentFor(wt.id)?.status;
-    if (status !== "working" && status !== "waiting")
+    if (!isBusy(this.d.runtime.agentFor(wt.id)?.status))
       return null;
     const l = wt.landing;
     if (!l || l.fingerprint === await this.fingerprint(wt.path))
@@ -35821,8 +36041,7 @@ ${wt.landing.body}` : s;
       this.ops.delete(id);
       release?.();
       this.d.hub.emit("worktreesChanged");
-      const status = this.d.runtime.agentFor(id)?.status;
-      if (status !== "working" && status !== "waiting")
+      if (!isBusy(this.d.runtime.agentFor(id)?.status))
         this.syncAfterTurn(id);
     }
   }
@@ -36112,8 +36331,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
     const repo = this.d.state.requireRepo(r.repoId);
     const own = r.wt ? hasOwnBranch(r.wt) : false;
     const carry = !!r.wt;
-    const status = this.d.runtime.agentFor(worktreeId)?.status;
-    if (carry && (status === "working" || status === "waiting") && (await statusFiles(r.path)).length > 0) {
+    const busy = isBusy(this.d.runtime.agentFor(worktreeId)?.status);
+    if (carry && busy && (await statusFiles(r.path)).length > 0) {
       this.syncQueued.add(worktreeId);
       this.d.hub.emit("worktreesChanged");
       return { result: { ok: true, message: `${r.name} syncs from ${r.base} once the turn ends` }, base: r.base };
@@ -36501,6 +36720,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined);
         procs: rt?.procs?.states() ?? [],
         borrowed: rt?.borrowed.size ? [...rt.borrowed] : undefined,
         agent: rt?.agent.status ?? "idle",
+        stopping: rt?.agent.stopping || undefined,
         login: !!rt?.login,
         ahead,
         behind,
@@ -36625,7 +36845,7 @@ class ArchiveSweep {
 process.on("unhandledRejection", (e) => log.error("daemon", "unhandled rejection", e));
 process.on("uncaughtException", (e) => log.error("daemon", "uncaught exception", e));
 log.info("daemon", `toyon ${package_default.version} on bun ${Bun.version}, pid ${process.pid}, ${process.argv[1]}`);
-var here = dirname13(fileURLToPath(import.meta.url));
+var here = dirname14(fileURLToPath(import.meta.url));
 var {
   shellDist: SHELL_DIST,
   bridgeJs: BRIDGE_JS,
@@ -36641,17 +36861,17 @@ if (pruned > 0)
 var managed = await loadManaged();
 var paths = makePaths();
 ensureDirs(paths);
-forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join32(paths.home, "transcripts-forwarded"));
+forwardTranscripts([paths.transcriptsDir, paths.archiveDir], join33(paths.home, "transcripts-forwarded"));
 var token = loadOrCreateToken(paths);
 var port = Number(process.env.TOYON_PORT ?? DAEMON_DEFAULT_PORT);
-var helperApp = join32(paths.home, DAEMON_FILES.helper);
+var helperApp = join33(paths.home, DAEMON_FILES.helper);
 var helper = helperWanted({ platform: process.platform, cloud: cloud.enabled, port, home: process.env.TOYON_HOME }) ? new Helper({
   dir: helperApp,
   stub: HELPER_STUB,
   bun: process.execPath,
   cli: CLI_ENTRY,
-  log: join32(paths.home, DAEMON_FILES.launcherLog),
-  icon: join32(SHELL_DIST, "icon.svg"),
+  log: join33(paths.home, DAEMON_FILES.launcherLog),
+  icon: join33(SHELL_DIST, "icon.svg"),
   version: package_default.version
 }) : null;
 if (helper) {
@@ -36799,7 +37019,15 @@ var opens = new OpenService({
   hub,
   register: (path) => repos.register(path),
   found: () => worktrees.discovered(),
-  refused: [paths.home]
+  refused: [
+    paths.stateFile,
+    paths.draftsFile,
+    paths.draftAttachmentsFile,
+    paths.remoteFile,
+    paths.pidFile,
+    paths.tokenFile,
+    paths.gitCredentialsFile
+  ]
 });
 var idle = new IdlePolicy({
   runtime,
@@ -36945,7 +37173,7 @@ hub.on("remoteChanged", () => {
   fireAndForget("remote", tailnet.refresh(), "ask Tailscale");
 });
 fireAndForget("remote", tailnet.start(), "ask Tailscale");
-writeFileSync13(paths.pidFile, `${process.pid}
+writeFileSync14(paths.pidFile, `${process.pid}
 `);
 var stopLagSampler = startLagSampler();
 fireAndForget("daemon", run("sh", ["-c", "ulimit -n"], homedir15()).then((r) => {