toyon 0.9.0 → 0.10.0

package/dist/daemon.js

@@ -58,6 +58,7 @@ function applyLog(lines, proc, line, retract = 0) {
     return out;
   return [...out, { proc, line }];
 }
+var KEEP_AWAKE_MODES = ["use", "always", "off"];
 
 // ../shared/src/worktree-caps.ts
 function isMain(wt) {
@@ -119,7 +120,7 @@ function archiveReason(wt, f) {
     return null;
   if (unitsAhead(wt, f.rows) < ARCHIVE_KEEP_RECENT)
     return null;
-  const what = lost ? "a sibling landed" : wt.landed ? "landed" : "no changes";
+  const what = lost ? "sibling landed" : wt.landed ? "landed" : "no changes";
   return `${what}, ${UNOPENED}${duration(f.afterMs)}`;
 }
 var UNOPENED = "not opened in ";
@@ -6473,12 +6474,25 @@ function describeManaged(p) {
   return out;
 }
 
+// ../shared/src/output.ts
+var CONTEXT_CHARS = 6000;
+var HEAD_CHARS = 1500;
+function clipOutput(text) {
+  if (text.length <= CONTEXT_CHARS)
+    return text;
+  const cut = text.length - CONTEXT_CHARS;
+  return `${text.slice(0, HEAD_CHARS)}
+[${cut} characters cut here]
+${text.slice(text.length - (CONTEXT_CHARS - HEAD_CHARS))}`;
+}
+
 // ../shared/src/pair.ts
 var PAIR_TTL_MS = 120000;
 var pairLink = (host, code) => `https://${host}/#pair=${code}`;
+var isTailnetName = (host) => host.endsWith(".ts.net");
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 85;
+var PROTOCOL_VERSION = 89;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -6784,7 +6798,9 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({
     t: literal("adopt-worktree"),
     clientId: string2().max(64).optional(),
-    worktreeId: id
+    worktreeId: id,
+    message: object({ text: prose, attachments }).optional(),
+    boxId
   }),
   object({ t: literal("git-status"), worktreeId: id }),
   object({
@@ -6830,6 +6846,8 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("design-scan"), worktreeId: id }),
   object({ t: literal("discard-files"), worktreeId: id, paths: array(relPath).min(1).max(500) }),
   object({ t: literal("judge"), worktreeId: id, note: string2().max(500).optional() }),
+  object({ t: literal("fix-preview"), worktreeId: id, clientId: string2().max(64).optional() }),
+  object({ t: literal("fix"), worktreeId: id, toolId: string2().min(1).max(200) }),
   object({ t: literal("reveal"), worktreeId: id, path: relPath.optional() }),
   object({ t: literal("stop-agent"), worktreeId: id }),
   object({ t: literal("seen"), worktreeId: id }),
@@ -6888,6 +6906,7 @@ var clientMsgSchema = discriminatedUnion("t", [
   object({ t: literal("set-theme"), prefs: themePrefsSchema }),
   object({ t: literal("zone"), tz: string2().max(100) }),
   object({ t: literal("set-default-agent"), agent: id }),
+  object({ t: literal("set-keep-awake"), mode: _enum(KEEP_AWAKE_MODES) }),
   object({ t: literal("install-agent"), agent: id }),
   object({
     t: literal("agent-auth"),
@@ -8201,7 +8220,7 @@ function safeUser() {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.9.0",
+  version: "0.10.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -13214,8 +13233,9 @@ async function runLive(cmd, args, cwd, opts = {}) {
   }
 }
 function watchHooks(stream, onHook) {
+  let failed;
   if (!stream)
-    return;
+    return () => failed;
   const dec = new TextDecoder;
   let buf = "";
   const open = new Map;
@@ -13236,11 +13256,15 @@ function watchHooks(stream, onHook) {
       if (ev.event === "child_start" && ev.child_class === "hook" && ev.hook_name) {
         open.set(ev.child_id, ev.hook_name);
         onHook(ev.hook_name);
-      } else if (ev.event === "child_exit" && open.delete(ev.child_id)) {
+      } else if (ev.event === "child_exit" && open.has(ev.child_id)) {
+        if (ev.code)
+          failed = open.get(ev.child_id);
+        open.delete(ev.child_id);
         onHook(open.size > 0 ? [...open.values()].pop() : undefined);
       }
     }
   });
+  return () => failed;
 }
 function runWatched(cmd, args, cwd, opts = {}) {
   const started = Date.now();
@@ -13285,8 +13309,7 @@ function runWatched(cmd, args, cwd, opts = {}) {
     };
     if (child.pid)
       opts.onSpawn?.(child.pid, kill);
-    if (opts.onHook)
-      watchHooks(child.stdio[3], opts.onHook);
+    const failedHook = opts.onHook ? watchHooks(child.stdio[3], opts.onHook) : undefined;
     if (opts.timeoutMs) {
       timer = setTimeout(() => {
         timedOut = true;
@@ -13322,7 +13345,8 @@ function runWatched(cmd, args, cwd, opts = {}) {
         err: err.join("").trim(),
         exit,
         text,
-        ...timedOut && opts.timeoutMs ? { ceilingMs: opts.timeoutMs } : {}
+        ...timedOut && opts.timeoutMs ? { ceilingMs: opts.timeoutMs } : {},
+        ...failedHook?.() ? { hook: failedHook() } : {}
       });
     });
   });
@@ -14051,6 +14075,12 @@ ${body}
   return parts.join(`
 `);
 }
+function unformatOutput(output) {
+  if (!output.startsWith("```\n"))
+    return "";
+  const close = output.lastIndexOf("\n```");
+  return close < 4 ? "" : output.slice(4, close);
+}
 
 // ../daemon/src/agent/policy.ts
 import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
@@ -14159,6 +14189,7 @@ var SYSTEM_APPEND = [
   "Never run `git commit` unless the user explicitly asks you to, and never offer to, through the question tool or otherwise; leave changes uncommitted for the user to review and commit themselves.",
   "Keep the scope tight: do the asked task well, then stop. A follow-up the user might want later is a sentence in your reply, not a question.",
   "When the work is done and the only thing left is whether to do something you recommend, do not end your turn on a prose offer waiting for a yes. Ask it with your question tool when you have one: one question, two options with the recommended one first, each saying what it changes, and typed text allowed so the answer can carry instructions. The card is the first thing the user reads, before any prose of yours, so the question itself states what you propose and why in a sentence or two; a question that is only the yes-or-no leaves them guessing what it is. Ask this way only where you would otherwise have stopped and waited; never to confirm work already asked for.",
+  "An answer to a question of yours can carry typed text beside the option picked, and the text outranks the pick. Text that doubts the pick, asks you something or says the user cannot decide is not a yes: answer it in prose and change nothing until they have decided. Text that only adds detail to the pick is an instruction for carrying it out.",
   "When referencing a file in chat, use a Markdown link whose target is its absolute path, with an optional `:line`; Toyon opens it in the built-in editor, whether it is in this worktree or anywhere else on this machine. A folder, a URL route or a command is not a file: name it in backticks, never as a link.",
   "`@some/path` in a message means read that file or directory first; `@changes` means this worktree's uncommitted files, which `git status` lists.",
   'Toyon previews the project in a browser panel by running the commands in its settings file, .toyon/settings.json (or toyon.json at the repo root, in a repo that keeps it there), shaped like {"setup": ["bun install"], "run": {"web": "bun run dev --port $PORT"}, "check": "bun run check", "land": {"route": "merge"}}: setup runs once in every new worktree, teardown (optional) runs once when a worktree is removed, every command in run keeps running and must listen on $PORT, which toyon sets differently for each worktree, check (optional) runs after each of your turns and must pass before the work can land, and land (optional) says how the user lands work on main: route "merge" (onto main here), "push" (onto main here, then pushed) or "pr" (a pull request); method "merge", "squash" or "rebase" for how the commits arrive on main; automerge true when GitHub should merge the pull request itself; timeouts (optional) gives setup, check and commit each a ceiling as a duration like "30m" (ten minutes each when unset), for a suite that runs longer. A settings.local.json beside it (toyon.local.json at the root) holds one person\'s overrides and is never committed. Both files may carry comments and trailing commas; leave any you find.',
@@ -14166,6 +14197,113 @@ var SYSTEM_APPEND = [
   "When you scaffold a project, write its .gitignore (dependencies, build output, local env files) before installing anything, so an install never leaves thousands of untracked files for the user to wade through or commit.",
   "When you scaffold a project or change how it installs or starts, finish by updating the settings file Toyon already reads, or writing .toyon/settings.json when there is none, so the preview can run it."
 ].join(" ");
+function failedRun(f) {
+  switch (f.kind) {
+    case "hook":
+    case "check":
+    case "command":
+      return f;
+    case "conflict":
+      return f.step;
+    case "preview":
+      return;
+  }
+}
+function fixPrompt(f) {
+  switch (f.kind) {
+    case "hook":
+      return hookFixPrompt(f.hook);
+    case "conflict":
+      return conflictFixPrompt(f.base, f.how, !!f.step);
+    case "check":
+      return checkFixPrompt(f.command);
+    case "command":
+      return commandFixPrompt(f.command);
+    case "preview":
+      return procFixPrompt(f.procs, f.log);
+  }
+}
+var WHY_COMMAND_CHARS = 60;
+function fixWhy(f) {
+  switch (f.kind) {
+    case "hook":
+      return `the ${f.hook} hook refused the ${f.hook.includes("push") ? "push" : "commit"}`;
+    case "conflict":
+      return f.how === "rebase" ? `the branch needs a rebase onto ${f.base}` : `the branch needs ${f.base} merged in`;
+    case "check":
+      return "the check failed";
+    case "command": {
+      const line = f.command.split(`
+`)[0] ?? "";
+      return `\`${line.length > WHY_COMMAND_CHARS ? `${line.slice(0, WHY_COMMAND_CHARS)}...` : line}\` failed`;
+    }
+    case "preview":
+      return "the dev server is not reachable";
+  }
+}
+function failureContext(f) {
+  const run = failedRun(f);
+  if (!run)
+    return;
+  const shown = clipOutput(run.text.replace(/\n+$/, ""));
+  const what = f.kind === "command" ? "The command that failed" : "What Toyon ran";
+  return `${what}, and what it printed:
+$ ${run.command}${shown ? `
+${shown}` : `
+(it printed nothing)`}`;
+}
+function hookFixPrompt(hook) {
+  return [
+    `The ${hook} hook refused that, and what it printed is attached below.`,
+    "Fix what it complains about, inside this worktree.",
+    "Do not skip the hook, do not edit it or its configuration to get past it, and do not commit: Toyon runs the check when your turn ends, and the user lands from there."
+  ].join(" ");
+}
+function conflictFixPrompt(base, how, shown) {
+  const ask = how === "rebase" ? `Rebase this branch onto ${base} and resolve the conflicts, keeping any uncommitted changes, then verify the app still works.` : `Merge ${base} into this branch, resolve the conflicts and commit the merge, then verify the app still works.`;
+  return shown ? `${ask} What git printed when Toyon tried is attached below.` : ask;
+}
+function checkFixPrompt(command) {
+  return [
+    `The repo's check, \`${command}\`, failed, and what it printed is attached below.`,
+    "Fix what it reports, inside this worktree.",
+    "Do not weaken the check or its configuration to get past it. Toyon runs it again when your turn ends."
+  ].join(" ");
+}
+function commandFixPrompt(command) {
+  return [
+    `The user ran \`${command}\` and it failed; what it printed is attached below.`,
+    "Find the cause and fix it, inside this worktree.",
+    "If the cause is not in this worktree, say what it is instead of changing anything."
+  ].join(" ");
+}
+var PROC_TAIL = 40;
+function procFixPrompt(procs, log) {
+  const bad = procs.filter((p) => p.status === "crashed" || p.status === "unreachable");
+  const lines = bad.map((p) => `- \`${p.name}\`: \`${p.command}\`, started with PORT=${p.port}. ${procDiagnosis(p)}`);
+  const tail = log.slice(-PROC_TAIL).map((l) => `[${l.proc}] ${l.line}`).join(`
+`);
+  return [
+    "The dev server in this worktree is not reachable, so the preview is empty.",
+    "",
+    ...lines,
+    "",
+    tail ? `Last output:
+\`\`\`
+${tail}
+\`\`\`` : "It produced no output.",
+    "",
+    "Find the cause and fix it. The command must run in the foreground and listen on the port in the PORT environment variable, which Toyon sets differently for each worktree. If the tool takes its port from a flag instead (Vite does), make the app read PORT, for Vite `server.port: Number(process.env.PORT)` with `strictPort: true`, or add the flag to the start command in toyon's settings file. When your turn ends toyon restarts the process and checks again."
+  ].join(`
+`);
+}
+function procDiagnosis(p) {
+  if (p.detail)
+    return p.detail;
+  if (p.status === "crashed")
+    return p.exitCode != null ? `It exited with code ${p.exitCode}.` : "It crashed.";
+  return "It never answered on that port.";
+}
 function ambientBlock(paragraphs) {
   const said = paragraphs.filter((p) => !!p);
   if (said.length === 0)
@@ -14185,7 +14323,7 @@ function previewContext(p) {
       line = "Toyon is setting this worktree up and starts the preview when that is done; the next message will say where it answers.";
       break;
     case "parked":
-      line = "The preview is off: this worktree came back from the archive, and Toyon starts its dev servers when you first write a file or when the user asks for them. Nothing answers until then.";
+      line = "The preview is off: Toyon has not started this worktree's dev servers, and starts them when you first write a file or when the user asks for them. Nothing answers until then.";
       break;
     case "starting":
       line = `Toyon is starting the preview; it answers${at} once it is up.`;
@@ -14822,12 +14960,18 @@ function release(toolId, memo) {
     memo.writing = false;
   return memo.ended ? null : { type: "tool-update", toolId, ...held };
 }
+function preempted(memos) {
+  for (const memo of memos.values()) {
+    if (!memo.ended && memo.writing && !memo.parent)
+      memo.cut = true;
+  }
+}
 function abandoned(memos, parent, opening = false) {
   const out = [];
   for (const [toolId, memo] of memos) {
     if (memo.ended || !memo.writing || memo.parent !== parent)
       continue;
-    if (opening && memo.held) {
+    if (opening && memo.held && !memo.cut) {
       const sent = release(toolId, memo);
       if (sent)
         out.push(sent);
@@ -15107,6 +15251,7 @@ class AcpSession {
   held = false;
   conn = null;
   connecting = null;
+  opening = null;
   live = null;
   reaper = null;
   own = null;
@@ -15243,13 +15388,18 @@ class AcpSession {
   send(text, opts = {}) {
     if (this.stopped)
       return log.warn(this.d.worktreeId, "send after close dropped");
-    for (const ask of [...this.asks.values()])
-      ask.settle("skipped");
+    if (!opts.asked)
+      for (const ask of [...this.asks.values()])
+        ask.settle("skipped");
     this.post(text, opts);
   }
   post(text, opts = {}) {
-    const { context, attachments } = opts;
+    const { context, attachments, asked } = opts;
     const item = { text, context, ...attachments?.length ? { attachments } : {} };
+    if (asked) {
+      this.emit({ type: "fix-asked", text, ts: Date.now(), ...asked });
+      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");
@@ -15305,7 +15455,10 @@ class AcpSession {
       }
       this.clearReaper();
       log.warn(this.d.worktreeId, "steered message started a turn of the agent's own");
+      return;
     }
+    if (this.live === live)
+      preempted(live.tools);
   }
   unsteer(item) {
     const at = this.steered.indexOf(item);
@@ -15609,8 +15762,18 @@ class AcpSession {
   }
   async ensureLive(why) {
     const conn = await this.ensureConn(why);
+    if (this.opening?.conn === conn)
+      return this.opening.live;
     if (this.live?.conn === conn)
       return this.live;
+    const live = this.openLive(conn).finally(() => {
+      if (this.opening?.live === live)
+        this.opening = null;
+    });
+    this.opening = { conn, live };
+    return live;
+  }
+  async openLive(conn) {
     const additionalDirectories = conn.bounds.gitDir ? [conn.bounds.gitDir] : [];
     let sessionId = this.d.getSessionId();
     let modes;
@@ -15651,7 +15814,7 @@ class AcpSession {
     this.emit({ type: "session-info", sessionId, ...currentValues(options) });
     this.learn(options);
     const modeOption = modes ? null : readModeOption(configOptions);
-    this.live = {
+    const live = {
       conn,
       sessionId,
       prefixPending: !resumed && conn.spec.systemPrompt === "prompt-prefix",
@@ -15661,13 +15824,14 @@ class AcpSession {
       modeConfigId: modeOption?.id ?? null,
       options
     };
-    await this.applyMode(this.live);
-    await this.applyOption(this.live, "model");
-    await this.applyOption(this.live, "thought_level");
+    this.live = live;
+    await this.applyMode(live);
+    await this.applyOption(live, "model");
+    await this.applyOption(live, "thought_level");
     const pushed = conn.commands.get(sessionId);
     if (pushed)
       this.setCommands(pushed);
-    return this.live;
+    return live;
   }
   mode() {
     return this.d.mode?.() ?? DEFAULT_PERMISSION_MODE;
@@ -15767,7 +15931,7 @@ class AcpSession {
     if (!memo || !held)
       return;
     const t = setTimeout(() => {
-      if (this.live !== live || memo.held !== held || !(this.running || this.own))
+      if (this.live !== live || memo.held !== held || memo.cut || !(this.running || this.own))
         return;
       const sent = release(toolId, memo);
       if (sent)
@@ -17517,6 +17681,18 @@ class RuntimeRegistry {
         return true;
     return false;
   }
+  demand() {
+    if (this.holds.size > 0)
+      return "working";
+    let waiting = false;
+    for (const rt of this.runtimes.values()) {
+      if (rt.agent.status === "working")
+        return "working";
+      if (rt.agent.status === "waiting")
+        waiting = true;
+    }
+    return waiting ? "waiting" : null;
+  }
   markSetup(id, on) {
     if (on)
       this.settingUp.add(id);
@@ -18193,18 +18369,20 @@ function clip(text, max = CLIP) {
   const line = text.replace(/\s+/g, " ").trim();
   return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
 }
-function slice(asks, ts) {
-  return { asks, reply: "", edits: 0, toolErrors: 0, newestTs: ts };
+function slice(asks, fixes, ts) {
+  return { asks, fixes, reply: "", edits: 0, toolErrors: 0, newestTs: ts };
 }
 function turnsSince(entries, seenAt) {
   const turns = [];
   let pending = [];
+  let pendingFixes = [];
   let open = null;
   const writes = new Set;
   const refusals = new Map;
   const start = (ts) => {
-    const t = slice(pending, ts);
+    const t = slice(pending, pendingFixes, ts);
     pending = [];
+    pendingFixes = [];
     turns.push(t);
     return t;
   };
@@ -18212,12 +18390,16 @@ function turnsSince(entries, seenAt) {
     if (open && "ts" in e)
       open.newestTs = Math.max(open.newestTs, e.ts);
     switch (e.type) {
-      case "user-message":
-        if (open && open.stop === undefined && open.error === undefined && !open.auth)
-          open.asks.push(e.text);
-        else
-          pending.push(e.text);
+      case "user-message": {
+        const into = open && open.stop === undefined && open.error === undefined && !open.auth ? open : null;
+        (into?.asks ?? pending).push(e.text);
         break;
+      }
+      case "fix-asked": {
+        const into = open && open.stop === undefined && open.error === undefined && !open.auth ? open : null;
+        (into?.fixes ?? pendingFixes).push(e.why);
+        break;
+      }
       case "turn-start":
         open = start(e.ts);
         break;
@@ -18378,6 +18560,8 @@ function turnBlock(t) {
   const lines = [];
   if (t.asks.length)
     lines.push(`User asked: ${clip(t.asks.join(" / "), 400)}`);
+  if (t.fixes.length)
+    lines.push(`Toyon, not the user, asked for a fix: ${clip(t.fixes.join(" / "), 400)}`);
   if (t.reply.trim())
     lines.push(`Agent ended with: ${clip(t.reply, 1000)}`);
   return lines.join(`
@@ -18617,93 +18801,8 @@ function pruneAssets(shellDist) {
   return gone;
 }
 
-// ../daemon/src/core/dialog.ts
-import { existsSync as existsSync13 } from "fs";
-import { homedir as homedir5 } from "os";
-var PROMPTS = {
-  location: "Choose where the new project goes",
-  open: "Choose a project folder to open"
-};
-var SCRIPT = [
-  "on run argv",
-  "activate",
-  "POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
-  "end run"
-];
-function folderDialog() {
-  let open = null;
-  let child = null;
-  let cancelled = false;
-  const ask = async (start, purpose) => {
-    const typed = start === "~" || start.startsWith("~/") ? `${homedir5()}${start.slice(1)}` : start;
-    const from = typed.startsWith("/") && existsSync13(typed) ? typed : homedir5();
-    cancelled = false;
-    const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
-      stdout: "pipe",
-      stderr: "pipe",
-      stdin: "ignore"
-    });
-    child = p;
-    const [out, err, code] = await Promise.all([
-      new Response(p.stdout).text(),
-      new Response(p.stderr).text(),
-      p.exited
-    ]);
-    child = null;
-    if (code === 0)
-      return out.trim().replace(/\/+$/, "") || "/";
-    if (cancelled || err.includes("(-128)"))
-      return null;
-    throw new UserError(`the Finder dialog did not open: ${err.trim()}`);
-  };
-  return {
-    choose(start, purpose) {
-      if (process.platform !== "darwin") {
-        return Promise.reject(new UserError("choosing a folder in Finder is only available on macOS"));
-      }
-      if (!open) {
-        open = ask(start, purpose).finally(() => {
-          open = null;
-        });
-      }
-      return open;
-    },
-    cancel() {
-      if (!child)
-        return;
-      cancelled = true;
-      child.kill();
-    }
-  };
-}
-
-// ../daemon/src/core/hub.ts
-class Hub {
-  listeners = new Map;
-  on(event, fn) {
-    let set = this.listeners.get(event);
-    if (!set) {
-      set = new Set;
-      this.listeners.set(event, set);
-    }
-    set.add(fn);
-    return () => set?.delete(fn);
-  }
-  emit(event, ...args) {
-    const set = this.listeners.get(event);
-    if (!set)
-      return;
-    for (const fn of set) {
-      try {
-        const r = fn(...args);
-        if (r instanceof Promise)
-          r.catch((e) => log.error("hub", `async listener for ${String(event)} rejected`, e));
-      } catch (e) {
-        log.error("hub", `listener for ${String(event)} threw`, e);
-      }
-    }
-  }
-}
+// ../daemon/src/core/awake.ts
+import { spawn as spawn3 } from "child_process";
 
 // ../daemon/src/runtime/idle.ts
 var LOCAL_SLEEP_MS = 2 * 60 * 60000;
@@ -19011,6 +19110,208 @@ function humanMs(ms) {
   return `${Math.round(ms / 1000)} s`;
 }
 
+// ../daemon/src/core/awake.ts
+var WAIT_MS = 30 * 60000;
+function idleSleepAssertion(raw, platform = process.platform) {
+  if (raw === "off" || platform !== "darwin")
+    return null;
+  return () => {
+    const child = spawn3("/usr/bin/caffeinate", ["-i", "-w", String(process.pid)], { stdio: "ignore" });
+    child.on("error", (e) => log.warn("awake", "caffeinate did not start, so the Mac may sleep mid-turn", e));
+    child.unref();
+    return () => {
+      child.kill();
+    };
+  };
+}
+
+class KeepAwake {
+  d;
+  release = null;
+  waitingAt = null;
+  remote = 0;
+  remoteLeftAt = null;
+  timer = null;
+  gone = false;
+  waitMs;
+  now;
+  constructor(d) {
+    this.d = d;
+    this.waitMs = d.waitMs ?? WAIT_MS;
+    this.now = d.now ?? Date.now;
+    d.hub.on("agentStatus", (_id, status) => {
+      if (status === "waiting")
+        this.waitingAt = this.now();
+      this.reconsider();
+    });
+    d.hub.on("holdsChanged", () => this.reconsider());
+    d.hub.on("keepAwakeChanged", () => this.reconsider());
+    this.reconsider();
+  }
+  setting() {
+    return this.d.assert ? this.d.mode() : null;
+  }
+  remoteShells(n) {
+    if (n === this.remote)
+      return;
+    if (n === 0)
+      this.remoteLeftAt = this.now();
+    this.remote = n;
+    this.reconsider();
+  }
+  stop() {
+    this.gone = true;
+    this.disarm();
+    this.hold(false);
+  }
+  reconsider() {
+    if (this.gone || !this.d.assert)
+      return;
+    this.disarm();
+    const mode = this.d.mode();
+    const demand = this.d.demand();
+    if (demand !== "waiting" || !this.d.answerable)
+      this.waitingAt = null;
+    else
+      this.waitingAt ??= this.now();
+    if (mode === "off") {
+      this.hold(false);
+      return;
+    }
+    if (mode === "always" || demand === "working" || this.remote > 0) {
+      this.hold(true);
+      return;
+    }
+    const since = Math.max(this.waitingAt ?? Number.NEGATIVE_INFINITY, this.remoteLeftAt ?? Number.NEGATIVE_INFINITY);
+    const left = since + this.waitMs - this.now();
+    if (left > 0) {
+      this.hold(true);
+      this.arm(left);
+      return;
+    }
+    if (this.release && Number.isFinite(since)) {
+      log.info("awake", `nobody has answered or connected for ${humanMs(this.waitMs)}; the machine may sleep again`);
+    }
+    this.hold(false);
+  }
+  hold(on) {
+    if (on === (this.release !== null))
+      return;
+    if (on) {
+      this.release = this.d.assert?.() ?? null;
+    } else {
+      this.release?.();
+      this.release = null;
+    }
+    log.debug("awake", on ? "holding off idle sleep" : "idle sleep allowed again");
+  }
+  arm(ms) {
+    const set = this.d.setTimer ?? ((fn, delay) => {
+      const t = setTimeout(fn, delay);
+      t.unref?.();
+      return t;
+    });
+    this.timer = set(() => {
+      this.timer = null;
+      this.reconsider();
+    }, ms);
+  }
+  disarm() {
+    if (!this.timer)
+      return;
+    (this.d.clearTimer ?? ((t) => clearTimeout(t)))(this.timer);
+    this.timer = null;
+  }
+}
+
+// ../daemon/src/core/dialog.ts
+import { existsSync as existsSync13 } from "fs";
+import { homedir as homedir5 } from "os";
+var PROMPTS = {
+  location: "Choose where the new project goes",
+  open: "Choose a project folder to open"
+};
+var SCRIPT = [
+  "on run argv",
+  "activate",
+  "POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
+  "end run"
+];
+function folderDialog() {
+  let open = null;
+  let child = null;
+  let cancelled = false;
+  const ask = async (start, purpose) => {
+    const typed = start === "~" || start.startsWith("~/") ? `${homedir5()}${start.slice(1)}` : start;
+    const from = typed.startsWith("/") && existsSync13(typed) ? typed : homedir5();
+    cancelled = false;
+    const p = Bun.spawn(["osascript", ...SCRIPT.flatMap((line) => ["-e", line]), PROMPTS[purpose], from], {
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore"
+    });
+    child = p;
+    const [out, err, code] = await Promise.all([
+      new Response(p.stdout).text(),
+      new Response(p.stderr).text(),
+      p.exited
+    ]);
+    child = null;
+    if (code === 0)
+      return out.trim().replace(/\/+$/, "") || "/";
+    if (cancelled || err.includes("(-128)"))
+      return null;
+    throw new UserError(`the Finder dialog did not open: ${err.trim()}`);
+  };
+  return {
+    choose(start, purpose) {
+      if (process.platform !== "darwin") {
+        return Promise.reject(new UserError("choosing a folder in Finder is only available on macOS"));
+      }
+      if (!open) {
+        open = ask(start, purpose).finally(() => {
+          open = null;
+        });
+      }
+      return open;
+    },
+    cancel() {
+      if (!child)
+        return;
+      cancelled = true;
+      child.kill();
+    }
+  };
+}
+
+// ../daemon/src/core/hub.ts
+class Hub {
+  listeners = new Map;
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return () => set?.delete(fn);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        const r = fn(...args);
+        if (r instanceof Promise)
+          r.catch((e) => log.error("hub", `async listener for ${String(event)} rejected`, e));
+      } catch (e) {
+        log.error("hub", `listener for ${String(event)} threw`, e);
+      }
+    }
+  }
+}
+
 // ../daemon/src/core/idleExit.ts
 var STOP_AFTER_MS = 30 * 60000;
 function stopAfterFrom(raw, opts) {
@@ -19100,7 +19401,7 @@ class IdleExit {
 }
 
 // ../daemon/src/core/restart.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { openSync } from "fs";
 import { homedir as homedir6 } from "os";
 function restartable(env = process.env) {
@@ -19121,7 +19422,7 @@ async function replacementRuns() {
 }
 function respawn(logFile) {
   const logFd = openSync(logFile, "a");
-  const child = spawn3(process.execPath, process.argv.slice(1), {
+  const child = spawn4(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env }
@@ -19506,6 +19807,16 @@ class StateStore {
     delete this.state.defaultAgent;
     this.save();
   }
+  get keepAwake() {
+    return this.state.keepAwake ?? "use";
+  }
+  setKeepAwake(mode) {
+    if (mode === "use")
+      delete this.state.keepAwake;
+    else
+      this.state.keepAwake = mode;
+    this.save();
+  }
   get theme() {
     return this.state.theme;
   }
@@ -20315,12 +20626,13 @@ class ExecService {
       if (opts.quiet)
         agent.note(start);
       agent.note({ type: "tool-end", toolId, output: `could not run: ${reason}`, isError: true });
-      return Promise.resolve({ exit: reason, text: "" });
+      return Promise.resolve({ exit: reason, text: "", toolId });
     }
     const pid = proc.pid;
     let killing;
     const running = {
       stop: () => {
+        running.stopping = true;
         killing ??= killGroup(pid, groupGone(pid)).then((signal) => {
           if (signal)
             running.signal = signal;
@@ -20337,7 +20649,8 @@ class ExecService {
     this.deps.runtime.hold(worktreeId, `exec:${toolId}`);
     this.deps.runtime.noteGroup(worktreeId, `exec:${toolId}`, pid);
     opts.onSpawn?.(pid, () => fireAndForget(worktreeId, running.stop(), `exec ${toolId} stopped`));
-    return this.collect(worktreeId, toolId, proc, running, agent, ceiling, opts.quiet ? start : undefined);
+    const kind = name === CHECK_TOOL ? "check" : "command";
+    return this.collect(worktreeId, toolId, proc, running, agent, ceiling, kind, opts.quiet ? start : undefined);
   }
   async watch(worktreeId, command, run) {
     const agent = this.agentFor(worktreeId);
@@ -20375,16 +20688,17 @@ class ExecService {
       this.untrack(worktreeId, toolId);
     }
     if (!up && r.exit === 0)
-      return { ...r, shown: false };
+      return { ...r, shown: false, toolId };
     if (!up)
       agent.note(start);
     agent.note({
       type: "tool-end",
       toolId,
       output: formatOutput(text, r.exit, truncated, r.ceilingMs),
-      isError: r.exit !== 0
+      isError: r.exit !== 0,
+      ...r.hook && typeof r.exit === "number" && r.exit !== 0 ? { fixable: { kind: "hook", hook: r.hook } } : {}
     });
-    return { ...r, shown: true };
+    return { ...r, shown: true, toolId };
   }
   async stop(worktreeId, toolId) {
     const byTool = this.running.get(worktreeId);
@@ -20417,7 +20731,7 @@ class ExecService {
     this.deps.runtime.release(worktreeId, `exec:${toolId}`);
     this.deps.runtime.forgetGroup(worktreeId, pgid);
   }
-  async collect(worktreeId, toolId, proc, running, agent, ceiling, heldStart) {
+  async collect(worktreeId, toolId, proc, running, agent, ceiling, kind, heldStart) {
     let text = "";
     let truncated = false;
     const live = !heldStart;
@@ -20455,7 +20769,13 @@ class ExecService {
       log.warn(worktreeId, "exec: reading output failed", e);
     }
     const pgid = proc.pid;
-    const end = (how) => agent.note({ type: "tool-end", toolId, output: formatOutput(text, how, truncated, ceiling), isError: how !== 0 });
+    const end = (how) => agent.note({
+      type: "tool-end",
+      toolId,
+      output: formatOutput(text, how, truncated, ceiling),
+      isError: how !== 0,
+      ...typeof how === "number" && how !== 0 && !running.stopping && !running.timedOut ? { fixable: { kind } } : {}
+    });
     const lingers = running.signal === undefined && groupAlive(pgid);
     if (!lingers)
       this.settle(worktreeId, toolId, pgid);
@@ -20466,18 +20786,18 @@ class ExecService {
       }
       if (lingers)
         fireAndForget(worktreeId, this.linger(running, pgid).then(() => this.settle(worktreeId, toolId, pgid)), `exec ${toolId} left running`);
-      return { exit: running.timedOut ? "timeout" : exit, text };
+      return { exit: running.timedOut ? "timeout" : exit, text, toolId };
     }
     if (!lingers) {
       end(running.timedOut ? "timeout" : exit);
-      return { exit: running.timedOut ? "timeout" : exit, text };
+      return { exit: running.timedOut ? "timeout" : exit, text, toolId };
     }
     agent.note({ type: "tool-update", toolId, background: true });
     fireAndForget(worktreeId, this.linger(running, pgid).then(() => {
       this.settle(worktreeId, toolId, pgid);
       end(running.timedOut ? "timeout" : running.signal ?? exit);
     }), `exec ${toolId} in the background`);
-    return { exit, text };
+    return { exit, text, toolId };
   }
   async linger(running, pgid) {
     while (running.signal === undefined && groupAlive(pgid))
@@ -20586,7 +20906,7 @@ function looksBinary(text) {
 }
 
 // ../daemon/src/files/service.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { stat as stat2, unlink } from "fs/promises";
 
 // ../daemon/src/git/blame.ts
@@ -21285,7 +21605,7 @@ class FileService {
   revealPath(target) {
     if (process.platform !== "darwin")
       throw new UserError("reveal is only available on macOS");
-    const child = spawn4("open", ["-R", target], { stdio: "ignore" });
+    const child = spawn5("open", ["-R", target], { stdio: "ignore" });
     child.on("error", () => {});
     child.unref();
   }
@@ -25750,6 +26070,49 @@ class PairCodes {
   }
 }
 
+// ../daemon/src/core/tailnet.ts
+var PHONE_OS = new Set(["android", "ios"]);
+function tailnetPhones(json) {
+  let st;
+  try {
+    st = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (st === null || typeof st !== "object")
+    return null;
+  const phones = [];
+  for (const p of Object.values(st.Peer ?? {})) {
+    if (!p || !PHONE_OS.has((p.OS ?? "").toLowerCase()))
+      continue;
+    const name = p.HostName || (p.DNSName ?? "").split(".")[0] || "a phone";
+    phones.push({ name, ip: p.TailscaleIPs?.[0] ?? null });
+  }
+  return phones;
+}
+var PING_TIMEOUT = "2s";
+function cli(bin) {
+  return async (args) => {
+    try {
+      const p = Bun.spawn([bin, ...args], { stdin: "ignore", stdout: "pipe", stderr: "ignore", timeout: 5000 });
+      const out = await new Response(p.stdout).text();
+      return { ok: await p.exited === 0, out };
+    } catch {
+      return { ok: false, out: "" };
+    }
+  };
+}
+var ping = (ip) => ["ping", "--until-direct=false", "--c", "1", "--timeout", PING_TIMEOUT, ip];
+async function readTailnetPhones(run = ((bin) => bin ? cli(bin) : null)(Bun.which("tailscale"))) {
+  if (run === null)
+    return null;
+  const st = await run(["status", "--json"]);
+  const listed = st.ok ? tailnetPhones(st.out) : null;
+  if (listed === null)
+    return null;
+  return Promise.all(listed.map(async ({ name, ip }) => ({ name, online: ip !== null && (await run(ping(ip))).ok })));
+}
+
 // ../daemon/src/server/handlers.ts
 import { randomBytes as randomBytes5 } from "crypto";
 
@@ -26540,8 +26903,10 @@ var handlers = {
   async "delete-archived"(msg, _ctx, s) {
     await s.worktrees.deleteArchived(msg.archiveId);
   },
-  async "adopt-worktree"(msg, _ctx, s) {
-    await s.worktrees.adopt(msg.worktreeId, msg.clientId);
+  async "adopt-worktree"(msg, ctx, s) {
+    await sending(s, ctx, msg, msg.message?.attachments, async () => {
+      await s.worktrees.adopt(msg.worktreeId, msg.clientId, msg.message);
+    });
   },
   async "git-status"(msg, ctx, s) {
     await gitStatus(s, ctx, msg.worktreeId);
@@ -26587,21 +26952,17 @@ var handlers = {
   },
   async land(msg, ctx, s) {
     const { result } = await s.worktrees.land(msg.worktreeId, msg.message);
-    const suggestion = !result.ok && result.conflict ? "Bring main into this branch and resolve the conflicts, then verify the app still works." : undefined;
     if (result.ok && (result.pr || s.state.worktree(msg.worktreeId)?.pr)) {
       fireAndForget(msg.worktreeId, s.prs.refresh(msg.worktreeId), "pr refresh");
     }
     await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, {
       url: result.url,
-      ...suggestion ? { suggestion } : {}
+      ...result.asked ? { asked: true } : {}
     }));
   },
   async "sync-main"(msg, ctx, s) {
-    const { result, base } = await s.worktrees.sync(msg.worktreeId);
-    const prompt = !result.ok && result.conflict && s.state.worktree(msg.worktreeId);
-    await notify(s, ctx, msg.worktreeId, prompt ? shipped(msg.worktreeId, false, `sync conflicts with ${base}: prompt prefilled in chat`, {
-      suggestion: `Merge ${base} into this branch and resolve the conflicts, then verify the app still works.`
-    }) : shipped(msg.worktreeId, result.ok, result.message));
+    const { result } = await s.worktrees.sync(msg.worktreeId);
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, result.asked ? { asked: true } : {}));
   },
   async "pull-main"(msg, ctx, s) {
     const result = await s.worktrees.pull(msg.worktreeId);
@@ -26630,7 +26991,7 @@ var handlers = {
   },
   async commit(msg, ctx, s) {
     const result = await s.worktrees.commit(msg.worktreeId, msg.message);
-    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message));
+    await notify(s, ctx, msg.worktreeId, shipped(msg.worktreeId, result.ok, result.message, result.asked ? { asked: true } : {}));
   },
   async graft(msg, ctx, s) {
     const { target } = await s.worktrees.graft(msg.targetId, msg.sourceIds);
@@ -26705,6 +27066,12 @@ var handlers = {
   async judge(msg, _ctx, s) {
     await s.landing.judge(msg.worktreeId, msg.note);
   },
+  async "fix-preview"(msg, _ctx, s) {
+    await s.worktrees.fixPreview(msg.worktreeId, msg.clientId);
+  },
+  fix(msg, _ctx, s) {
+    s.fix.press(msg.worktreeId, msg.toolId);
+  },
   async "write-file"(msg, ctx, s) {
     const head = { t: "file-written", worktreeId: msg.worktreeId, path: msg.path, seq: msg.seq };
     try {
@@ -26835,6 +27202,10 @@ var handlers = {
     s.state.setDefaultAgent(msg.agent);
     s.hub.emit("agentsChanged");
   },
+  "set-keep-awake"(msg, _ctx, s) {
+    s.state.setKeepAwake(msg.mode);
+    s.hub.emit("keepAwakeChanged");
+  },
   "rescan-themes"(_msg, _ctx, s) {
     s.themes.load();
     s.hub.emit("themesChanged");
@@ -27010,7 +27381,8 @@ function createFetch(opts) {
         dropped: new Set,
         sent: 0,
         bytes: 0,
-        view: null
+        view: null,
+        ...remoteShell ? { remote: true } : {}
       };
       const headers = authed && remote && remoteShell ? { "set-cookie": grantCookie(grant, remote.host) } : undefined;
       if (srv.upgrade(req, { data, headers }))
@@ -27046,6 +27418,13 @@ function createFetch(opts) {
       const body = { code, url: pairLink(remote.host, code), ms };
       return Response.json(body, { headers: { "cache-control": NO_STORE } });
     }
+    if (url.pathname === "/pair/phones" && req.method === "GET") {
+      if (!sameSecret(req.headers.get("authorization"), `Bearer ${opts.token}`)) {
+        return new Response("unauthorized", { status: 401 });
+      }
+      const phones = remote && isTailnetName(remote.host) ? await opts.phones() : null;
+      return Response.json(phones, { headers: { "cache-control": NO_STORE } });
+    }
     if (url.pathname === "/pair/redeem" && req.method === "POST") {
       if (!remote || !remoteShell)
         return new Response("not found", { status: 404 });
@@ -27166,6 +27545,13 @@ function createFetch(opts) {
     const file = join21(opts.shellDist, rel.replaceAll("..", ""));
     const hashed = rel.startsWith("/assets/");
     if (existsSync23(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 };
+        return Response.json(manifest, {
+          headers: { "content-type": "application/manifest+json", "cache-control": NO_STORE }
+        });
+      }
       return new Response(Bun.file(file), { headers: { "cache-control": hashed ? IMMUTABLE : NO_STORE } });
     }
     if (hashed)
@@ -27202,13 +27588,17 @@ function startServer(opts) {
   const { services: s, token, version } = opts;
   const sockets = new Set;
   const linked = new Set;
+  const counted = () => {
+    s.idleExit.clients(linked.size);
+    s.keepAwake.remoteShells([...linked].filter((ws) => ws.data.remote || ws.data.preview).length);
+  };
   const link = (ws) => {
     linked.add(ws);
-    s.idleExit.clients(linked.size);
+    counted();
   };
   const unlink = (ws) => {
     if (linked.delete(ws))
-      s.idleExit.clients(linked.size);
+      counted();
   };
   const raw = (ws, json) => {
     try {
@@ -27417,6 +27807,7 @@ function startServer(opts) {
     agentChosen: s.state.defaultAgent !== undefined
   });
   s.hub.on("agentsChanged", () => broadcast(agentsMsg()));
+  s.hub.on("keepAwakeChanged", () => broadcast({ t: "keep-awake", mode: s.keepAwake.setting() }));
   s.hub.on("selfChanged", () => broadcast({ t: "self", self: s.self.get() }));
   s.hub.on("failed", (worktreeId, message) => broadcast({ t: "error", message, worktreeId }));
   s.hub.on("updateChanged", () => broadcast({ t: "update", update: s.update.get() }));
@@ -27442,6 +27833,7 @@ function startServer(opts) {
       agentChosen: s.state.defaultAgent !== undefined,
       home: homedir11(),
       folderDialog: process.platform === "darwin" && !cloud.enabled,
+      keepAwake: s.keepAwake.setting(),
       remote: opts.remote && { host: opts.remote.host, previews: opts.remote.previews },
       paired: s.state.paired,
       gitIdentity: await s.repos.gitIdentity(),
@@ -27474,6 +27866,10 @@ 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: surface1, ground: surface0 };
+      },
       open: (path) => s.opens.open(path),
       restart: (now) => s.restarter.request({ now }),
       restartWait: () => ({ waiting: s.restarter.waitingOn(), asking: s.restarter.asking() }),
@@ -27481,7 +27877,8 @@ function startServer(opts) {
       onPaired: () => {
         s.state.notePaired();
         broadcast({ t: "paired" });
-      }
+      },
+      phones: () => readTailnetPhones()
     }),
     websocket: {
       async open(ws) {
@@ -28577,6 +28974,92 @@ class ChatSearch {
   }
 }
 
+// ../daemon/src/worktrees/fix.ts
+var RESPONSE = {
+  hook: { does: "ask" },
+  conflict: { does: "ask" },
+  check: { does: "ask", once: true },
+  command: { does: "offer" },
+  preview: { does: "offer" }
+};
+function lastAsked(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const e = entries[i].event;
+    if (e.type === "fix-asked")
+      return e.kind;
+    if (e.type === "user-message")
+      return;
+  }
+  return;
+}
+function askedFor(entries, toolId) {
+  return entries.some(({ event }) => event.type === "fix-asked" && event.toolId === toolId);
+}
+function failureOf(entries, toolId) {
+  let command;
+  for (const { event } of entries) {
+    if (event.type === "tool-start" && event.toolId === toolId) {
+      const input = event.input;
+      command = typeof input?.command === "string" ? input.command : undefined;
+    } else if (event.type === "tool-end" && event.toolId === toolId) {
+      if (!event.fixable || command === undefined)
+        return null;
+      const run = { toolId, command, text: unformatOutput(event.output ?? "") };
+      if (event.fixable.kind === "hook")
+        return { kind: "hook", hook: event.fixable.hook ?? "git", ...run };
+      return { kind: event.fixable.kind, ...run };
+    }
+  }
+  return null;
+}
+
+class FixService {
+  d;
+  constructor(d) {
+    this.d = d;
+    d.hub.on("checkFailed", (id, run) => {
+      this.report(id, { kind: "check", ...run });
+    });
+  }
+  report(worktreeId, failure, opts = {}) {
+    const response = RESPONSE[failure.kind];
+    if (response.does === "offer" && !opts.pressed)
+      return false;
+    const wt = this.d.state.worktree(worktreeId);
+    if (!wt || isMain(wt))
+      return false;
+    const agent = this.d.runtime.agentFor(worktreeId);
+    if (!agent)
+      return false;
+    const entries = agent.transcript();
+    if (response.once && !opts.pressed && lastAsked(entries) === failure.kind)
+      return false;
+    const toolId = failedRun(failure)?.toolId;
+    if (toolId && askedFor(entries, toolId))
+      return false;
+    const context = failureContext(failure);
+    agent.send(fixPrompt(failure), {
+      asked: { kind: failure.kind, why: fixWhy(failure), ...toolId ? { toolId } : {} },
+      ...context ? { context: [context] } : {}
+    });
+    return true;
+  }
+  press(worktreeId, toolId) {
+    this.d.state.requireWorktree(worktreeId);
+    const agent = this.d.runtime.agentFor(worktreeId);
+    if (!agent)
+      throw new UserError("worktree still starting; try again in a moment");
+    const entries = agent.transcript();
+    const failure = failureOf(entries, toolId);
+    if (!failure)
+      throw new UserError("nothing to fix on that row");
+    if (askedFor(entries, toolId))
+      return;
+    if (!this.report(worktreeId, failure, { pressed: true }))
+      throw new UserError("nothing runs on main");
+  }
+}
+
 // ../daemon/src/worktrees/landing.ts
 var TAIL_CHARS = 400;
 var DIFF_CHARS = 2000;
@@ -28590,6 +29073,7 @@ class LandingService {
   constructor(d) {
     this.d = d;
     d.hub.on("turnSettled", (id, turn) => fireAndForget(id, this.settle(id, turn), "landing verdict"));
+    d.hub.on("messageRefused", (id, said) => fireAndForget(id, this.judge(id, `The commit-msg hook refused the last message, saying: ${said}`), "landing message after a refusal"));
     d.hub.on("agentStatus", (id, status) => {
       this.note(id, status);
       if (status === "working")
@@ -28760,6 +29244,7 @@ class LandingService {
     let check = "none";
     let checkTail;
     let waited = 0;
+    let ran;
     const command = repo.config.check?.trim();
     if (command) {
       const ceiling = timeoutFor(repo.config, "check");
@@ -28783,6 +29268,7 @@ class LandingService {
       run.finish(r.exit);
       if (!live())
         return;
+      ran = r;
       check = r.exit === 0 ? "pass" : "fail";
       if (r.exit === "timeout") {
         checkTail = [`gave up after ${describeDuration(ceiling)}`, tail(r.text)].filter(Boolean).join(`
@@ -28838,6 +29324,8 @@ class LandingService {
       record.recap = { at: Date.now(), text: verdict.recap };
     log.info(worktreeId, `landing: check ${check}${landing.why ? ", doubted" : ""}${opts.ask ? "" : ", check only"}, ${Date.now() - started}ms${waited > 100 ? ` (waited ${waited}ms for a check slot)` : ""}`);
     this.d.worktrees.setLanding(worktreeId, landing);
+    if (command && check === "fail" && ran && typeof ran.exit === "number" && !opts.quiet)
+      this.d.hub.emit("checkFailed", worktreeId, { toolId: ran.toolId, command, text: ran.text });
   }
   async sharedMigration(wt, repo) {
     if (!repo.services || keepsCopiesApart(repo.config))
@@ -29242,7 +29730,7 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync29, readFileSync as readFileSync18, rmSync as rmSync7 } from "fs";
+import { cpSync, existsSync as existsSync30, readFileSync as readFileSync18, rmSync as rmSync7 } from "fs";
 import { rm as rm4 } from "fs/promises";
 import { dirname as dirname11, join as join27 } from "path";
 
@@ -29368,7 +29856,11 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
+import { existsSync as existsSync26 } from "fs";
 var STEP_TIMEOUT_MS = 10 * 60000;
+function rowOf(r) {
+  return r.shown && r.toolId && r.command ? { toolId: r.toolId, command: r.command, text: r.text } : undefined;
+}
 var stepRun = (cwd, args, onText, signal, opts = {}) => runWatched(GIT, args, cwd, { env: NO_PROMPT, onText, signal, ...opts, timeoutMs: opts.timeoutMs ?? STEP_TIMEOUT_MS });
 var UNWATCHED = {
   step() {},
@@ -29381,6 +29873,14 @@ function refused(what, r, n = 200) {
   }
   return `${what}: ${r.shown ? "what git and its hooks printed is on the chat" : r.err.slice(0, n)}`;
 }
+function stepRefused(what, r, n = 200) {
+  const row = typeof r.exit === "number" && r.hook ? rowOf(r) : undefined;
+  return {
+    ok: false,
+    message: refused(what, r, n),
+    ...row && r.hook ? { hook: { ...row, name: r.hook } } : {}
+  };
+}
 async function commitWorktree(worktreePath, message, w = UNWATCHED) {
   if ((await statusFiles(worktreePath)).length === 0)
     return { ok: false, message: "nothing to commit" };
@@ -29388,7 +29888,7 @@ async function commitWorktree(worktreePath, message, w = UNWATCHED) {
   w.step("committing");
   const c = await w.git(worktreePath, ["commit", "-m", message]);
   if (!c.ok)
-    return { ok: false, message: refused("commit refused", c) };
+    return stepRefused("commit refused", c);
   return { ok: true, message: `committed: ${message}` };
 }
 async function requireClean(worktreePath) {
@@ -29474,7 +29974,27 @@ async function putBack(worktreePath, defaultBr, aside, taken) {
     message: `the uncommitted changes here conflict with ${defaultBr}${named}: commit them first, then sync`
   };
 }
+var MIDWAY = [
+  ["MERGE_HEAD", "merge"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"]
+];
+async function midway(worktreePath) {
+  const args = MIDWAY.flatMap(([file]) => ["--git-path", file]);
+  const r = await git(worktreePath, "rev-parse", "--path-format=absolute", ...args);
+  if (!r.ok)
+    return null;
+  const at = r.out.split(`
+`).findIndex((file) => file && existsSync26(file));
+  return MIDWAY[at]?.[1] ?? null;
+}
 async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
+  const unfinished = await midway(worktreePath);
+  if (unfinished) {
+    return { ok: false, message: `a ${unfinished} is unfinished here: finish or abort it first` };
+  }
   if (!carry) {
     const cErr = await requireClean(worktreePath);
     if (cErr)
@@ -29489,8 +30009,19 @@ async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = f
   const taken = await bringIn(worktreePath, defaultBr, own, behind, w);
   return aside ? putBack(worktreePath, defaultBr, aside, taken) : taken;
 }
+async function requireLinear(worktreePath, base) {
+  const merges = await git(worktreePath, "rev-list", "--merges", "--count", `${base}..HEAD`);
+  if (!merges.ok || merges.out === "0")
+    return null;
+  return {
+    ok: false,
+    conflict: "rebase",
+    message: `the branch holds a merge commit, which landing by rebase would put on ${base}: ask the agent to rebase onto ${base} first`
+  };
+}
 async function bringIn(worktreePath, defaultBr, own, behind, w) {
-  if (own) {
+  const merges = own ? await git(worktreePath, "rev-list", "--merges", "--count", `${defaultBr}..HEAD`) : null;
+  if (own && merges?.out === "0") {
     w.step(`rebasing onto ${defaultBr}`);
     const r = await w.git(worktreePath, ["rebase", defaultBr]);
     if (!r.ok) {
@@ -29498,10 +30029,12 @@ async function bringIn(worktreePath, defaultBr, own, behind, w) {
       const files = overwritten(r.text);
       if (files.length)
         return { ok: false, message: untrackedInTheWay(defaultBr, files) };
-      const ask = `rebase onto ${defaultBr} conflicts: ask the agent to bring ${defaultBr} in and resolve them`;
+      const ask = `rebase onto ${defaultBr} conflicts: ask the agent to rebase onto ${defaultBr} and resolve them`;
+      const step = rowOf(r);
       return {
         ok: false,
-        conflict: true,
+        conflict: "rebase",
+        ...step ? { step } : {},
         message: r.shown ? `${ask}; the conflicts are on the chat` : `${ask} (${r.text.slice(0, 200)})`
       };
     }
@@ -29548,7 +30081,7 @@ async function landLocally(worktreePath, branch, repoPath, defaultBr, method, me
     const c = await w.git(repoPath, ["commit", "-m", message]);
     if (!c.ok) {
       await git(repoPath, "reset", "--hard", "HEAD");
-      return { ok: false, message: refused("squash commit refused", c) };
+      return stepRefused("squash commit refused", c);
     }
     return { ok: true, message: `squashed ${branch} onto ${defaultBr}` };
   }
@@ -29607,7 +30140,7 @@ async function landingCommit(worktreePath, branch, base, method, message, own, w
     const c = await w.git(worktreePath, ["commit", "-m", message]);
     if (!c.ok) {
       await git(worktreePath, "reset", "--soft", head.out);
-      return { ok: false, message: refused("squash commit refused", c) };
+      return stepRefused("squash commit refused", c);
     }
     const sha = await git(worktreePath, "rev-parse", "HEAD");
     return { ok: true, sha: sha.out, message: `squashed ${branch} onto ${base}` };
@@ -29620,15 +30153,15 @@ async function landingCommit(worktreePath, branch, base, method, message, own, w
       w.step(`squashing onto ${base}`);
       const s = await w.git(worktreePath, ["merge", "--squash", branch]);
       if (!s.ok)
-        return { ok: false, message: refused("squash refused", s) };
+        return stepRefused("squash refused", s);
       const c = await w.git(worktreePath, ["commit", "-m", message]);
       if (!c.ok)
-        return { ok: false, message: refused("squash commit refused", c) };
+        return stepRefused("squash commit refused", c);
     } else {
       w.step(`merging into ${base}`);
       const m = await w.git(worktreePath, ["merge", "--no-ff", "-m", `Merge branch '${branch}'`, branch]);
       if (!m.ok)
-        return { ok: false, message: refused("merge refused", m) };
+        return stepRefused("merge refused", m);
     }
     const sha = await git(worktreePath, "rev-parse", "HEAD");
     return { ok: true, sha: sha.out, message: `${method === "squash" ? "squashed" : "merged"} ${branch} onto ${base}` };
@@ -29655,15 +30188,17 @@ async function pushLanding(worktreePath, sha, defaultBr, w = UNWATCHED) {
   if (p.ok)
     return { ok: true, message: `pushed ${defaultBr} to ${tracked.remote}` };
   const moved = /\[rejected\]|fetch first|non-fast-forward|cannot lock ref/.test(p.err);
-  return moved ? { ok: false, moved: true, message: `${defaultBr} on ${tracked.remote} moved while landing` } : { ok: false, message: refused("push failed", p, 300) };
+  return moved ? { ok: false, moved: true, message: `${defaultBr} on ${tracked.remote} moved while landing` } : stepRefused("push failed", p, 300);
 }
 async function mergeFailure(cwd, m, conflictMessage) {
   const conflict = /CONFLICT|Automatic merge failed/.test(m.text);
   if (conflict) {
     await git(cwd, "merge", "--abort");
+    const step = rowOf(m);
     return {
       ok: false,
-      conflict: true,
+      conflict: "merge",
+      ...step ? { step } : {},
       message: m.shown ? `${conflictMessage}; the conflicts are on the chat` : `${conflictMessage} (${m.text.slice(0, 200)})`
     };
   }
@@ -29694,7 +30229,7 @@ async function pushBranch(worktreePath, branch, w = UNWATCHED) {
     push = await w.git(worktreePath, args);
   }
   if (!push.ok)
-    return { ok: false, message: refused("push failed", push, 300) };
+    return stepRefused("push failed", push, 300);
   return { ok: true, message: `pushed ${branch}` };
 }
 async function goneFromOrigin(worktreePath, branch) {
@@ -29766,7 +30301,7 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/git/turn.ts
-import { copyFileSync, existsSync as existsSync26, rmSync as rmSync5 } from "fs";
+import { copyFileSync, existsSync as existsSync27, rmSync as rmSync5 } from "fs";
 import { join as join24 } from "path";
 var turnRef = (worktreeId, which) => `refs/toyon/turns/${worktreeId}/${which}`;
 var SNAPSHOT_SUBJECT2 = "toyon: tree at a send";
@@ -29792,7 +30327,7 @@ async function treeNow(wtPath, head, dirty) {
     const tree = await run(GIT, ["write-tree"], wtPath, env);
     return tree.ok && tree.out ? tree.out : null;
   };
-  if (!existsSync26(index))
+  if (!existsSync27(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) {
@@ -29807,9 +30342,9 @@ async function treeNow(wtPath, head, dirty) {
     }
   }
   synced.delete(wtPath);
-  if (!existsSync26(index)) {
+  if (!existsSync27(index)) {
     const own = join24(index, "..", "index");
-    if (existsSync26(own))
+    if (existsSync27(own))
       copyFileSync(own, index);
     else if (!(await run(GIT, ["read-tree", "HEAD"], wtPath, env)).ok)
       return null;
@@ -29890,7 +30425,7 @@ async function dropTurnRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync8, readdirSync as readdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync8, readdirSync as readdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
 import { basename as basename8, dirname as dirname10, join as join25 } from "path";
 class WorktreeArchive {
   dir;
@@ -29900,7 +30435,7 @@ class WorktreeArchive {
     mkdirSync8(dir, { recursive: true });
     for (const id of readdirSync8(dir)) {
       const file = this.filesOf(id).record;
-      if (!existsSync27(file))
+      if (!existsSync28(file))
         continue;
       try {
         this.records.set(id, JSON.parse(readFileSync17(file, "utf8")));
@@ -29950,7 +30485,7 @@ class WorktreeArchive {
     if (!this.records.has(id) || !isPlanPath(rel))
       return null;
     const file = join25(this.filesOf(id).plans, basename8(rel));
-    if (!existsSync27(file))
+    if (!existsSync28(file))
       return null;
     try {
       return readFileSync17(file, "utf8");
@@ -29991,7 +30526,7 @@ function summarize(r, repoId, transcript) {
   };
 }
 function lastUsage(transcript) {
-  if (!existsSync27(transcript))
+  if (!existsSync28(transcript))
     return null;
   const lines = readFileSync17(transcript, "utf8").split(`
 `);
@@ -30007,7 +30542,7 @@ function lastUsage(transcript) {
   return null;
 }
 function firstPrompt(transcript) {
-  if (!existsSync27(transcript))
+  if (!existsSync28(transcript))
     return;
   for (const line of readFileSync17(transcript, "utf8").split(`
 `)) {
@@ -30022,7 +30557,7 @@ function firstPrompt(transcript) {
   return;
 }
 function move(from, to) {
-  if (!existsSync27(from))
+  if (!existsSync28(from))
     return;
   mkdirSync8(dirname10(to), { recursive: true });
   rmSync6(to, { recursive: true, force: true });
@@ -30087,7 +30622,7 @@ class ArchivedGit {
 }
 
 // ../daemon/src/worktrees/spare.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { basename as basename9, join as join26 } from "path";
 class SparePool {
   d;
@@ -30107,7 +30642,7 @@ class SparePool {
     if (!text.trim())
       return;
     const wt = this.d.state.worktree(boxId);
-    if (wt?.kind !== "spare" || !existsSync28(wt.path))
+    if (wt?.kind !== "spare" || !existsSync29(wt.path))
       return;
     const agent = this.d.runtime.ensureAgent(wt).agent;
     if (agent.runningAgent === null)
@@ -30171,7 +30706,7 @@ class SparePool {
     const repoId = repo.id;
     let cut = () => {};
     const added = (async () => {
-      if (existsSync28(wt.path))
+      if (existsSync29(wt.path))
         return;
       await withRepoLock(repo.path, () => gitOrThrow(repo.path, "worktree", "add", "--detach", wt.path, baseOf(repo)));
     })();
@@ -30219,7 +30754,7 @@ class SparePool {
     }
     log.warn(wt.repoId, "spare warm-up failed; rolling back", e);
     this.d.carryDraft?.(wt.id, wt.repoId);
-    if (existsSync28(wt.path)) {
+    if (existsSync29(wt.path)) {
       await this.d.discard(wt.id).catch((re) => log.warn(wt.repoId, "spare rollback failed", re));
       return;
     }
@@ -30276,7 +30811,7 @@ class SparePool {
       const running = this.inflight.get(repoId);
       await running?.added.catch(() => {});
       running?.cut();
-      if (wt.kind !== "spare" || !existsSync28(wt.path))
+      if (wt.kind !== "spare" || !existsSync29(wt.path))
         return null;
     }
     await this.refreshing.get(repoId);
@@ -30513,6 +31048,7 @@ function stopOf(prev, next) {
 // ../daemon/src/worktrees/service.ts
 var LOCAL_CONFIG_FILES = [".env", ".env.local", ".env.development", ".env.development.local", ".dev.vars"];
 var BASE_IGNORE = "base .gitignore";
+var REFUSAL_CHARS = 400;
 async function deleteTree(path) {
   try {
     await rm4(path, { recursive: true, force: true });
@@ -30730,7 +31266,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) => !existsSync29(join27(wt.path, p)));
+`).filter(Boolean) : []).filter((p) => !existsSync30(join27(wt.path, p)));
       const applied = await git(wt.path, "stash", "apply", sha);
       if (applied.ok) {
         const ref = await entry();
@@ -30766,7 +31302,7 @@ class WorktreeService {
     const branch = kind === "pr" ? `pr/${number}` : ref;
     const title = kind === "pr" ? `pr-${number}` : cleanTitle2(ref) || "branch";
     let slug = branchSlug(title) || "branch";
-    if (existsSync29(join27(this.d.paths.worktreesDir, repo.name, slug)))
+    if (existsSync30(join27(this.d.paths.worktreesDir, repo.name, slug)))
       slug = `${slug}-${shortId().slice(0, 4)}`;
     const wtPath = join27(this.d.paths.worktreesDir, repo.name, slug);
     await withRepoLock(repo.path, async () => {
@@ -30811,7 +31347,7 @@ class WorktreeService {
       throw new UserError("that worktree is gone, or Toyon already has it");
     return found;
   }
-  async adopt(worktreeId, createdBy) {
+  async adopt(worktreeId, createdBy, message) {
     const r = this.readable(worktreeId);
     if (!r)
       throw new UserError("that worktree is gone");
@@ -30840,12 +31376,18 @@ class WorktreeService {
         title: found.name,
         createdAt: Date.now(),
         agent: this.d.agents.require(this.d.state.defaultAgent ?? DEFAULT_AGENT_ID).id,
+        parked: true,
+        ...message ? { promptedAt: Date.now() } : {},
         ...createdBy ? { createdBy } : {}
       };
       return rec;
     });
     this.invalidateDiscovered();
     this.launch(wt, repo, repo.path, { setupCommands: false });
+    const { agent } = this.d.runtime.ensureAgent(wt);
+    agent.note({ type: "adopted", branch: wt.branch, ts: Date.now() });
+    if (message)
+      agent.send(message.text, { attachments: message.attachments });
     return wt;
   }
   async ownProcs(worktreeId, names) {
@@ -31015,7 +31557,7 @@ class WorktreeService {
   }
   async teardown(wt, repo) {
     const cmds = repo.config.teardown ?? [];
-    if (cmds.length === 0 || !existsSync29(wt.path))
+    if (cmds.length === 0 || !existsSync30(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") });
@@ -31065,7 +31607,7 @@ class WorktreeService {
   }
   keepPlans(wt) {
     const from = join27(wt.path, PLANS_DIR);
-    if (!existsSync29(from))
+    if (!existsSync30(from))
       return;
     try {
       cpSync(from, this.plansScratch(wt.id), { recursive: true });
@@ -31196,7 +31738,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 = existsSync29(old.path) ? join27(dirname11(old.path), freeSlot(dirname11(old.path)).dir) : old.path;
+    const path = existsSync30(old.path) ? join27(dirname11(old.path), freeSlot(dirname11(old.path)).dir) : old.path;
     const branch = await withRepoLock(repo.path, async () => {
       if (!await commitOf(repo.path, archiveRef(old.id))) {
         throw new UserError(`${old.title}'s kept commits are gone from git`);
@@ -31263,12 +31805,12 @@ class WorktreeService {
       return;
     const repo = this.repoOf(rec);
     const repoPath = repo?.path ?? rec.repoPath;
-    if (rec.kept && existsSync29(repoPath)) {
+    if (rec.kept && existsSync30(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 && existsSync29(repoPath))
+    if (rec.worktree.lands?.length && existsSync30(repoPath))
       await dropLandRefs(repoPath, archiveId);
     this.archive.delete(archiveId);
     this.d.drafts?.drop(archiveId);
@@ -31378,8 +31920,8 @@ class WorktreeService {
   }
   async mirrorBaseIgnore(repo) {
     const src = join27(repo.path, ".gitignore");
-    const tracked = existsSync29(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
-    const mirror = existsSync29(src) && !tracked;
+    const tracked = existsSync30(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
+    const mirror = existsSync30(src) && !tracked;
     const lines = mirror ? readFileSync18(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
@@ -31394,7 +31936,7 @@ class WorktreeService {
     }
     const srcNm = join27(depsSource, "node_modules");
     const dstNm = join27(wt.path, "node_modules");
-    if (existsSync29(srcNm) && !existsSync29(dstNm)) {
+    if (existsSync30(srcNm) && !existsSync30(dstNm)) {
       const r = await cloneTree(srcNm, dstNm);
       if (r.ok)
         this.d.hub.emit("log", wt.id, "setup", `deps via ${r.how} in ${r.ms}ms`);
@@ -31403,7 +31945,7 @@ class WorktreeService {
     }
     for (const f of LOCAL_CONFIG_FILES) {
       const src = join27(depsSource, f);
-      if (!existsSync29(src) || existsSync29(join27(wt.path, f)))
+      if (!existsSync30(src) || existsSync30(join27(wt.path, f)))
         continue;
       const r = await run("cp", [src, join27(wt.path, f)], wt.path);
       if (r.ok)
@@ -31536,13 +32078,15 @@ ${wt.landing.body}` : s;
         const handle = commit ? this.runs.begin(wt.id, "commit", { timeoutMs: ceiling }) : null;
         const run = (onText, signal) => stepRun(cwd, args, onText, signal, {
           timeoutMs: ceiling,
-          ...handle ? { onSpawn: handle.spawned, onHook: (hook) => handle.stage(hook ? `${hook} hook` : undefined) } : {}
+          ...handle ? { onSpawn: handle.spawned } : {},
+          onHook: (hook) => handle?.stage(hook ? `${hook} hook` : undefined)
         });
         const watched = async () => {
           if (!this.d.watch)
             return run(() => {});
+          const command = `${where} ${commandLine(args)}`;
           try {
-            return await this.d.watch(wt.id, `${where} ${commandLine(args)}`, run);
+            return { ...await this.d.watch(wt.id, command, run), command };
           } catch (e) {
             log.warn(wt.id, `landing step runs unwatched: ${e instanceof Error ? e.message : e}`);
             return run(() => {});
@@ -31580,7 +32124,35 @@ ${wt.landing.body}` : s;
     });
     if (out.result.ok && out.archiveIds)
       this.noteLanded(wt, out.result.message, out.archiveIds);
-    return out;
+    return { ...out, result: this.fixShip(wt, out.result, baseOf(repo)) };
+  }
+  fixShip(wt, result, base) {
+    if (result.ok)
+      return result;
+    if (result.hook?.name === "commit-msg") {
+      this.d.hub.emit("messageRefused", wt.id, result.hook.text.trim().slice(-REFUSAL_CHARS));
+      return { ...result, message: "the commit-msg hook refused the message: another is being written" };
+    }
+    const { hook } = result;
+    const failure = hook ? { kind: "hook", hook: hook.name, toolId: hook.toolId, command: hook.command, text: hook.text } : result.conflict ? { kind: "conflict", base, how: result.conflict, ...result.step ? { step: result.step } : {} } : null;
+    return failure && this.d.fix.report(wt.id, failure) ? { ...result, asked: true } : result;
+  }
+  async fixPreview(worktreeId, clientId) {
+    const wt = this.d.state.requireWorktree(worktreeId);
+    const failure = {
+      kind: "preview",
+      procs: this.d.runtime.get(worktreeId)?.procs?.states() ?? [],
+      log: this.d.runtime.recentLogs(worktreeId)
+    };
+    if (!isLead(wt)) {
+      if (!this.d.fix.report(worktreeId, failure, { pressed: true }))
+        throw new UserError("worktree still starting; try again in a moment");
+      return;
+    }
+    await this.create(wt.repoId, fixPrompt(failure), {
+      ...clientId ? { createdBy: clientId } : {},
+      ...isProvisional(wt) ? { worktreeId } : {}
+    });
   }
   async movedMidTurn(wt) {
     const status = this.d.runtime.agentFor(wt.id)?.status;
@@ -31709,11 +32281,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       if (committed && !committed.ok)
         return committed;
       committedHere = committed !== null;
+      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
+      const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+      if (merged)
+        return merged;
       const taken = await takeMainIn(wt.path, base, own, w);
       if (!taken.ok)
         return taken;
       const mark = await landingMark(wt.path, base);
-      const method = policy.merge ?? DEFAULT_MERGE_METHOD;
       const squash = method === "squash" ? await squashMessage(wt.path, base, suggested) : "";
       const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
       if (!landed.ok)
@@ -31744,6 +32319,9 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       return { result: { ok: false, message: `nothing to land: no commits ahead of ${base}` } };
     let sha = "";
     let already = false;
+    const merged = own && method === "rebase" ? await requireLinear(wt.path, base) : null;
+    if (merged)
+      return { result: merged };
     for (let attempt = 0;; attempt++) {
       const fetched = await this.fetchBase(wt, repo, w);
       if (!fetched.ok)
@@ -31881,7 +32459,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       }
       return taken;
     });
-    return { result, base: r.base };
+    return { result: r.wt ? this.fixShip(r.wt, result, r.base) : result, base: r.base };
   }
   async pull(worktreeId) {
     const wt = this.d.state.requireWorktree(worktreeId);
@@ -31903,7 +32481,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     const m = message.trim();
     if (!m)
       throw new UserError("commit message required");
-    return this.ship(wt.id, "commit", () => this.commitRecorded(wt, m));
+    const base = baseOf(this.d.state.requireRepo(wt.repoId));
+    return this.fixShip(wt, await this.ship(wt.id, "commit", () => this.commitRecorded(wt, m)), base);
   }
   setEmpty(wt, empty) {
     if (wt.empty === empty)
@@ -32397,6 +32976,7 @@ var drafts = new DraftStore({
 var runs = new RunService({ state, hub });
 var exec = new ExecService({ state, runtime, shipping: (id) => worktrees.shippingOf(id) });
 var cache = new ArtifactCache({ paths, state, hub });
+var fix = new FixService({ state, hub, runtime });
 var worktrees = new WorktreeService({
   state,
   hub,
@@ -32406,7 +32986,8 @@ var worktrees = new WorktreeService({
   drafts,
   cache,
   watch: (id, command, run) => exec.watch(id, command, run),
-  runs
+  runs,
+  fix
 });
 new BackendShare({ state, hub, runtime, own: (id, names) => worktrees.ownProcs(id, names) });
 var turns = new TurnService({
@@ -32506,6 +33087,13 @@ var idleExit = new IdleExit({
   },
   afterMs: stopAfter
 });
+var keepAwake = new KeepAwake({
+  hub,
+  demand: () => runtime.demand(),
+  assert: idleSleepAssertion(process.env.TOYON_KEEP_AWAKE),
+  mode: () => state.keepAwake,
+  answerable: remote !== null
+});
 var { branded, stop: stopServer } = startServer({
   port,
   token,
@@ -32527,6 +33115,7 @@ var { branded, stop: stopServer } = startServer({
     runtime,
     idle,
     idleExit,
+    keepAwake,
     exec,
     runs,
     refs,
@@ -32534,6 +33123,7 @@ var { branded, stop: stopServer } = startServer({
     drafts,
     prs,
     landing,
+    fix,
     themes,
     agents,
     accounts,
@@ -32606,6 +33196,7 @@ async function shutdown(signal, opts = {}) {
   shuttingDown = true;
   log.info("daemon", `${signal}: stopping dev servers`);
   idleExit.stop();
+  keepAwake.stop();
   idle.shutdown();
   landing.stop();
   runs.stopWatching();