toyon 0.5.0 → 0.6.0

package/dist/daemon.js

@@ -42,6 +42,21 @@ var LOGIN_STREAM = "login";
 function streamKey(worktreeId, stream) {
   return `${worktreeId}/${stream}`;
 }
+function applyLog(lines, proc, line, retract = 0) {
+  let out = lines;
+  for (let left = retract;left > 0; left--) {
+    let i = out.length - 1;
+    while (i >= 0 && out[i]?.proc !== proc)
+      i--;
+    if (i < 0)
+      break;
+    out = out === lines ? [...out] : out;
+    out.splice(i, 1);
+  }
+  if (!line)
+    return out;
+  return [...out, { proc, line }];
+}
 
 // ../shared/src/worktree-caps.ts
 function isMain(wt) {
@@ -302,62 +317,8 @@ function landPolicy(config) {
     ...config.land?.method ? { merge: config.land.method } : {}
   };
 }
-
-// ../shared/src/pair.ts
-var PAIR_TTL_MS = 120000;
-var pairLink = (host, code) => `https://${host}/#pair=${code}`;
-
-// ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 65;
-var FILE_MAX_CHARS = 5000000;
-var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-var IMAGE_MAX_EDGE = 2576;
-var IMAGE_MAX_BYTES = 5 * 1024 * 1024;
-var PASTE_MAX_CHARS = 1e5;
-
-// ../shared/src/paste.ts
-var PREVIEW_CHARS = 80;
-function pasteSummary(text) {
-  const lines = text.split(`
-`);
-  const first = lines.find((l) => l.trim().length > 0)?.trim() ?? "";
-  return { chars: text.length, lines: lines.length, preview: first.slice(0, PREVIEW_CHARS) };
-}
-function lineSpan({ startLine, endLine }) {
-  return startLine === endLine ? `${startLine}` : `${startLine}-${endLine}`;
-}
-
-// ../shared/src/ports.ts
-var DAEMON_DEFAULT_PORT = 4141;
-var SHELL_DEV_PORT = 4142;
-
-// ../shared/src/project.ts
-var PROJECTS_FOLDER = "Projects";
-function hasControlChar(s) {
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code < 32 || code === 127)
-      return true;
-  }
-  return false;
-}
-function projectNameError(raw) {
-  const name = raw.trim();
-  if (!name)
-    return "a project name is required";
-  if (name.length > 100)
-    return "that name is too long: keep it under 100 characters";
-  if (name.includes("/") || name.includes("\\"))
-    return "a project name cannot contain a slash";
-  if (/\s/.test(name))
-    return "a project name cannot contain spaces";
-  if (hasControlChar(name))
-    return "a project name cannot contain control characters";
-  if (name === "." || name === "..")
-    return `"${name}" is not a project name`;
-  if (name.startsWith("-") || name.startsWith("."))
-    return "a project name cannot start with a dot or a dash";
-  return null;
+function shipNoun(op) {
+  return { land: "a land", commit: "a commit", "sync-main": "a sync", "pull-main": "a pull" }[op];
 }
 
 // ../../node_modules/.bun/zod@4.5.4/node_modules/zod/v4/core/util.js
@@ -6254,6 +6215,221 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
+// ../shared/src/managed.ts
+var MANAGED_REMOTE = ["off", "tailscale", "any"];
+var MANAGED_DEFAULTS = {
+  updates: true,
+  deploy: true,
+  remote: "any",
+  agents: null,
+  customAgents: true,
+  brandedListener: true,
+  planSignIn: true
+};
+var MANAGED_STRICTEST = {
+  updates: false,
+  deploy: false,
+  remote: "off",
+  agents: null,
+  customAgents: false,
+  brandedListener: false,
+  planSignIn: false
+};
+var managedFileSchema = object({
+  updates: boolean2().optional(),
+  deploy: boolean2().optional(),
+  remote: _enum(MANAGED_REMOTE).optional(),
+  agents: array(string2()).optional(),
+  customAgents: boolean2().optional(),
+  brandedListener: boolean2().optional(),
+  planSignIn: boolean2().optional()
+});
+var MANAGED_NONE = { ...MANAGED_DEFAULTS, source: null, problem: null };
+function managedSources(platform, user) {
+  if (platform === "darwin") {
+    return [
+      { path: "/Library/Managed Preferences/dev.toyon.plist", kind: "plist" },
+      ...user ? [{ path: `/Library/Managed Preferences/${user}/dev.toyon.plist`, kind: "plist" }] : [],
+      { path: "/Library/Application Support/toyon/policy.json", kind: "json" }
+    ];
+  }
+  if (platform === "linux")
+    return [{ path: "/etc/toyon/policy.json", kind: "json" }];
+  return [];
+}
+var KEYS = ["updates", "deploy", "remote", "agents", "customAgents", "brandedListener", "planSignIn"];
+function stricter(key, a, b) {
+  if (key === "remote") {
+    const ra = MANAGED_REMOTE.indexOf(a);
+    const rb = MANAGED_REMOTE.indexOf(b);
+    return ra <= rb ? a : b;
+  }
+  if (key === "agents") {
+    const la = a;
+    const lb = b;
+    if (la === null)
+      return b;
+    if (lb === null)
+      return a;
+    return la.filter((id) => lb.includes(id));
+  }
+  return a && b;
+}
+function merge2(into, from) {
+  const out = { ...into };
+  for (const key of KEYS) {
+    const v = from[key];
+    if (v === undefined)
+      continue;
+    out[key] = stricter(key, into[key], v);
+  }
+  return out;
+}
+function textHash(text) {
+  let h = 2166136261;
+  for (let i = 0;i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function describeIssue(e) {
+  const issue = e.issues[0];
+  if (!issue)
+    return "not a policy";
+  const at = issue.path.map(String).join(".");
+  return at ? `"${at}" ${issue.message.toLowerCase()}` : issue.message.toLowerCase();
+}
+function resolveManaged(reads) {
+  let policy = MANAGED_DEFAULTS;
+  const sources = [];
+  const applied = [];
+  let source = null;
+  let problem = null;
+  for (const r of reads) {
+    const spec = { path: r.path, kind: r.kind };
+    let why = r.problem ?? (r.owned === false ? "not owned by root, or writable by others" : null);
+    if (why === null && r.text === undefined) {
+      sources.push({ ...spec, state: "absent" });
+      continue;
+    }
+    let parsed = null;
+    if (why === null) {
+      try {
+        const json = JSON.parse(r.text ?? "");
+        const result = managedFileSchema.safeParse(json);
+        if (result.success)
+          parsed = result.data;
+        else
+          why = describeIssue(result.error);
+      } catch {
+        why = r.kind === "plist" ? "not a plist plutil can read" : "not valid JSON";
+      }
+    }
+    if (why !== null || parsed === null) {
+      sources.push({ ...spec, state: "invalid", problem: why ?? "unreadable" });
+      if (problem === null) {
+        problem = `${r.path}: ${why ?? "unreadable"}`;
+        source = r.path;
+      }
+      continue;
+    }
+    sources.push({ ...spec, state: "applied" });
+    applied.push(r.text ?? "");
+    if (problem === null && source === null)
+      source = r.path;
+    policy = merge2(policy, parsed);
+  }
+  if (problem !== null)
+    policy = MANAGED_STRICTEST;
+  return {
+    policy,
+    sources,
+    hash: applied.length ? textHash(applied.join(`
+`)) : null,
+    source,
+    problem
+  };
+}
+function managedView(r) {
+  return { ...r.policy, source: r.source, problem: r.problem };
+}
+function describeManaged(p) {
+  const out = [];
+  if (!p.updates)
+    out.push("updates off");
+  if (!p.deploy)
+    out.push("deploy off");
+  if (p.remote !== "any")
+    out.push(`remote ${p.remote}`);
+  if (p.agents !== null)
+    out.push(`agents ${p.agents.join(", ") || "none"}`);
+  if (!p.customAgents)
+    out.push("custom agents off");
+  if (!p.brandedListener)
+    out.push("toyon.localhost listener off");
+  if (!p.planSignIn)
+    out.push("plan sign-in off");
+  return out;
+}
+
+// ../shared/src/pair.ts
+var PAIR_TTL_MS = 120000;
+var pairLink = (host, code) => `https://${host}/#pair=${code}`;
+
+// ../shared/src/protocol/limits.ts
+var PROTOCOL_VERSION = 69;
+var FILE_MAX_CHARS = 5000000;
+var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var IMAGE_MAX_EDGE = 2576;
+var IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+var PASTE_MAX_CHARS = 1e5;
+
+// ../shared/src/paste.ts
+var PREVIEW_CHARS = 80;
+function pasteSummary(text) {
+  const lines = text.split(`
+`);
+  const first = lines.find((l) => l.trim().length > 0)?.trim() ?? "";
+  return { chars: text.length, lines: lines.length, preview: first.slice(0, PREVIEW_CHARS) };
+}
+function lineSpan({ startLine, endLine }) {
+  return startLine === endLine ? `${startLine}` : `${startLine}-${endLine}`;
+}
+
+// ../shared/src/ports.ts
+var DAEMON_DEFAULT_PORT = 4141;
+var SHELL_DEV_PORT = 4142;
+
+// ../shared/src/project.ts
+var PROJECTS_FOLDER = "Projects";
+function hasControlChar(s) {
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127)
+      return true;
+  }
+  return false;
+}
+function projectNameError(raw) {
+  const name = raw.trim();
+  if (!name)
+    return "a project name is required";
+  if (name.length > 100)
+    return "that name is too long: keep it under 100 characters";
+  if (name.includes("/") || name.includes("\\"))
+    return "a project name cannot contain a slash";
+  if (/\s/.test(name))
+    return "a project name cannot contain spaces";
+  if (hasControlChar(name))
+    return "a project name cannot contain control characters";
+  if (name === "." || name === "..")
+    return `"${name}" is not a project name`;
+  if (name.startsWith("-") || name.startsWith("."))
+    return "a project name cannot start with a dot or a dash";
+  return null;
+}
+
 // ../shared/src/protocol/pick.ts
 var pickMetaSchema = object({
   component: string2().nullable(),
@@ -7559,6 +7735,10 @@ var VIEWERS = [[/\.(png|jpe?g|gif|webp|avif|bmp|ico)$/i, "image"]];
 function viewerOf(path) {
   return VIEWERS.find(([re]) => re.test(path))?.[1] ?? null;
 }
+var PAGE_ASSETS = /\.(css|svg|woff2?|ttf|otf|mp4|webm|mp3|ogg|wav)$/i;
+function isPageAsset(path) {
+  return PAGE_ASSETS.test(path);
+}
 
 // ../shared/src/vscode-theme.ts
 var workbenchKeys = {
@@ -7736,10 +7916,59 @@ function pickSyntax(tokenColors) {
 function slug(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "theme";
 }
+
+// ../shared/src/managed-load.ts
+import { readFileSync, statSync } from "fs";
+import { userInfo } from "os";
+async function plutilJson(path) {
+  const p = Bun.spawn(["plutil", "-convert", "json", "-o", "-", path], { stdout: "pipe", stderr: "pipe" });
+  const [out, err] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
+  await p.exited;
+  if (p.exitCode !== 0)
+    throw new Error(err.trim().split(`
+`)[0] || `plutil exited ${p.exitCode}`);
+  return out;
+}
+function ownedByRoot(st) {
+  return st.uid === 0 && (st.mode & 18) === 0;
+}
+async function loadManaged(opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const user = opts.user ?? safeUser();
+  const sources = opts.sources ?? managedSources(platform, user);
+  const reads = [];
+  for (const s of sources) {
+    let st;
+    try {
+      st = statSync(s.path);
+    } catch {
+      reads.push(s);
+      continue;
+    }
+    if (s.kind === "json" && !ownedByRoot(st)) {
+      reads.push({ ...s, owned: false });
+      continue;
+    }
+    try {
+      const text = s.kind === "plist" ? await (opts.plist ?? plutilJson)(s.path) : readFileSync(s.path, "utf8");
+      reads.push({ ...s, text });
+    } catch (e) {
+      reads.push({ ...s, problem: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return resolveManaged(reads);
+}
+function safeUser() {
+  try {
+    return userInfo().username || undefined;
+  } catch {
+    return;
+  }
+}
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.5.0",
+  version: "0.6.0",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -12084,6 +12313,7 @@ function spawnAcp(app, launch, cwd, tag) {
 }
 
 // ../daemon/src/agent/attachments.ts
+import { createHash } from "crypto";
 import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
 var EXT = {
@@ -12093,7 +12323,17 @@ var EXT = {
   "image/webp": "webp"
 };
 var ID = /^[A-Za-z0-9_-]{1,64}$/;
-var FILE = /^\d{1,6}\.(png|jpg|gif|webp|txt)$/;
+var FILE = /^(\d{1,6}|[0-9a-f]{16})\.(png|jpg|gif|webp|txt)$/;
+function toolImage(data, mimeType) {
+  const ext = EXT[mimeType];
+  if (!ext)
+    return null;
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.length === 0)
+    return null;
+  const file = `${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}.${ext}`;
+  return { ref: { file, mimeType, bytes: bytes.length }, bytes };
+}
 var isAttachmentFile = (file) => FILE.test(file);
 function attachmentsDirFor(attachmentsDir, worktreeId) {
   return join(attachmentsDir, worktreeId);
@@ -12101,9 +12341,21 @@ function attachmentsDirFor(attachmentsDir, worktreeId) {
 
 class AttachmentStore {
   dir;
+  pending = new Map;
   constructor(dir) {
     this.dir = dir;
   }
+  async putToolImage(worktreeId, file, bytes) {
+    if (!ID.test(worktreeId) || !FILE.test(file))
+      throw new UserError("bad tool image");
+    const path = join(attachmentsDirFor(this.dir, worktreeId), file);
+    if (this.pending.has(path) || await Bun.file(path).exists())
+      return;
+    await this.write(worktreeId, file, bytes);
+  }
+  whenWritten(worktreeId, file) {
+    return this.pending.get(join(attachmentsDirFor(this.dir, worktreeId), file)) ?? Promise.resolve();
+  }
   async put(worktreeId, n, input) {
     if (!ID.test(worktreeId))
       throw new UserError("bad worktree id");
@@ -12148,10 +12400,12 @@ class AttachmentStore {
       ref: { kind: "paste", n, ...name ? { name } : {}, ...source ? { source } : {}, ...pasteSummary(text), file }
     };
   }
-  async write(worktreeId, file, data) {
+  write(worktreeId, file, data) {
     const wtDir = attachmentsDirFor(this.dir, worktreeId);
-    await mkdir(wtDir, { recursive: true });
-    await writeFile(join(wtDir, file), data);
+    const path = join(wtDir, file);
+    const done = mkdir(wtDir, { recursive: true }).then(() => writeFile(path, data)).finally(() => this.pending.delete(path));
+    this.pending.set(path, done);
+    return done;
   }
   fileFor(worktreeId, file) {
     if (!ID.test(worktreeId) || !FILE.test(file))
@@ -12313,7 +12567,7 @@ class OptionProbe {
 }
 
 // ../daemon/src/agent/registry.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname3, isAbsolute, join as join5, resolve as resolve3 } from "path";
 
@@ -12339,8 +12593,9 @@ var cloud = {
 };
 
 // ../daemon/src/git/exec.ts
-import { createHash } from "crypto";
-import { existsSync, readFileSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
 
 // ../daemon/src/core/metrics.ts
@@ -12380,10 +12635,10 @@ var LOCKFILES = [
   "Cargo.lock"
 ];
 function lockfileHash(dir) {
-  const h = createHash("sha1");
+  const h = createHash2("sha1");
   for (const f of LOCKFILES) {
     try {
-      h.update(readFileSync(join2(dir, f)));
+      h.update(readFileSync2(join2(dir, f)));
     } catch {}
   }
   return h.digest("hex");
@@ -12494,6 +12749,80 @@ async function runLive(cmd, args, cwd, opts = {}) {
     }
   }
 }
+function runWatched(cmd, args, cwd, opts = {}) {
+  const started = Date.now();
+  return new Promise((resolve) => {
+    let timer;
+    let timedOut = false;
+    let stop;
+    let settled = false;
+    const settle = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (stop)
+        opts.signal?.removeEventListener("abort", stop);
+      if (cmd === GIT) {
+        lastGit.cmd = `git ${args.slice(0, 3).join(" ")}`;
+        lastGit.ms = Date.now() - started;
+        lastGit.at = Date.now();
+      }
+      resolve(r);
+    };
+    const failed = (msg) => settle({ ok: false, out: "", err: msg, exit: msg, text: msg });
+    let child;
+    try {
+      child = spawn2(cmd, args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
+        env: { ...process.env, ...SPAWN_ENV, ...opts.env }
+      });
+    } catch (e) {
+      failed(e instanceof Error ? e.message : String(e));
+      return;
+    }
+    child.on("error", (e) => failed(e.message));
+    const exited = new Promise((r) => child.once("exit", () => r()));
+    const kill = () => {
+      if (child.pid)
+        fireAndForget("git", killGroup(child.pid, exited), `stopping ${cmd} ${args[0] ?? ""}`);
+    };
+    if (opts.timeoutMs) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        kill();
+      }, opts.timeoutMs);
+    }
+    if (opts.signal) {
+      stop = kill;
+      if (opts.signal.aborted)
+        kill();
+      else
+        opts.signal.addEventListener("abort", stop, { once: true });
+    }
+    let text = "";
+    const out = [];
+    const err = [];
+    const read = (stream, into) => {
+      const dec = new TextDecoder;
+      stream?.on("data", (b) => {
+        const chunk = dec.decode(b, { stream: true });
+        into.push(chunk);
+        text += chunk;
+        opts.onText?.(chunk);
+      });
+    };
+    read(child.stdout, out);
+    read(child.stderr, err);
+    child.on("close", (code, signal) => {
+      const exit = timedOut ? "timeout" : signal ?? code;
+      settle({ ok: code === 0 && !timedOut, out: out.join("").trim(), err: err.join("").trim(), exit, text });
+    });
+  });
+}
 async function git(cwd, ...args) {
   const { rawOut: _raw, ...r } = await run(GIT, args, cwd);
   return r;
@@ -12526,7 +12855,7 @@ async function defaultBranch(path) {
 }
 
 // ../daemon/src/agent/confine.ts
-import { statSync } from "fs";
+import { statSync as statSync2 } from "fs";
 var SANDBOX_EXEC = "/usr/bin/sandbox-exec";
 var uniq = (xs) => [...new Set(xs)];
 var literal2 = (p) => `"${p.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
@@ -12544,7 +12873,7 @@ function seatbeltProfile(b, extraWrite = []) {
 }
 function kindOf(p) {
   try {
-    return statSync(p).isDirectory() ? "dir" : "file";
+    return statSync2(p).isDirectory() ? "dir" : "file";
   } catch {
     return null;
   }
@@ -12584,7 +12913,7 @@ function confine(launch, b, extraWrite = [], platform = process.platform, which
 }
 
 // ../daemon/src/agent/native.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
 var OS = { darwin: "darwin", linux: "linux", win32: "windows" };
 function nativePackage(pkg, host) {
   const os = OS[host.platform];
@@ -12614,7 +12943,7 @@ function muslLoader() {
 }
 function cpuFlags() {
   try {
-    return readFileSync2("/proc/cpuinfo", "utf8").match(/^flags\s*:(.*)$/m)?.[1]?.trim().split(/\s+/) ?? [];
+    return readFileSync3("/proc/cpuinfo", "utf8").match(/^flags\s*:(.*)$/m)?.[1]?.trim().split(/\s+/) ?? [];
   } catch {
     return [];
   }
@@ -12677,7 +13006,7 @@ function opencodeEnv() {
 }
 
 // ../daemon/src/agent/sandbox.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, tmpdir } from "os";
 import { join as join4, resolve as resolve2 } from "path";
 
@@ -12717,7 +13046,7 @@ function ensureDirs(p) {
 }
 
 // ../daemon/src/git/exclude.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { dirname } from "path";
 async function excludeFile(cwd) {
   const r = await git(cwd, "rev-parse", "--path-format=absolute", "--git-path", "info/exclude");
@@ -12730,7 +13059,7 @@ async function excludeFromGit(cwd, pattern) {
   const file = await excludeFile(cwd);
   if (!file)
     return;
-  const current = existsSync3(file) ? readFileSync3(file, "utf8") : "";
+  const current = existsSync3(file) ? readFileSync4(file, "utf8") : "";
   if (current.split(`
 `).some((l) => l.trim() === pattern))
     return;
@@ -12746,7 +13075,7 @@ async function excludeBlock(cwd, name, patterns) {
     return;
   const open = `# toyon ${name}`;
   const close = `# toyon end ${name}`;
-  const current = existsSync3(file) ? readFileSync3(file, "utf8") : "";
+  const current = existsSync3(file) ? readFileSync4(file, "utf8") : "";
   const lines = current.split(`
 `);
   const from = lines.indexOf(open);
@@ -12767,7 +13096,7 @@ async function unexcludeFromGit(cwd, pattern) {
   const file = await excludeFile(cwd);
   if (!file || !existsSync3(file))
     return;
-  const lines = readFileSync3(file, "utf8").split(`
+  const lines = readFileSync4(file, "utf8").split(`
 `);
   const kept = lines.filter((l) => l.trim() !== pattern);
   if (kept.length === lines.length)
@@ -12846,7 +13175,7 @@ async function writeClaudeLocalSettings(cwd, b) {
   let existing = {};
   if (existsSync5(file)) {
     try {
-      const parsed = JSON.parse(readFileSync4(file, "utf8"));
+      const parsed = JSON.parse(readFileSync5(file, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
         existing = parsed;
     } catch (e) {
@@ -12870,6 +13199,7 @@ async function writeClaudeLocalSettings(cwd, b) {
 
 // ../daemon/src/agent/registry.ts
 var CONFINEMENTS = ["claude-settings", "adapter-sandbox", "toyon-sandbox", "none"];
+var DEFAULT_AGENT_ID = "claude";
 var BUILTIN_AGENTS = [
   {
     id: "claude",
@@ -12878,7 +13208,9 @@ var BUILTIN_AGENTS = [
     builtin: true,
     run: { kind: "npm-bin", pkg: "@agentclientprotocol/claude-agent-acp", version: "0.75.1", bin: "claude-agent-acp" },
     ...cloud.enabled ? { env: { NO_BROWSER: "1" } } : {},
-    terminalLogins: { "claude-login": { args: ["--cli", "auth", "login", "--claudeai"], env: { NO_BROWSER: "1" } } },
+    terminalLogins: {
+      "claude-login": { args: ["--cli", "auth", "login", "--claudeai"], env: { NO_BROWSER: "1" }, plan: true }
+    },
     confinement: "claude-settings",
     setup: (cwd, bounds) => writeClaudeLocalSettings(cwd, bounds).then(() => {
       return;
@@ -12952,6 +13284,13 @@ class AgentRegistry {
   list() {
     return [...this.specs.values()];
   }
+  defaultId(persisted) {
+    if (persisted !== undefined && this.specs.has(persisted))
+      return persisted;
+    if (this.specs.has(DEFAULT_AGENT_ID))
+      return DEFAULT_AGENT_ID;
+    return this.list()[0]?.id ?? DEFAULT_AGENT_ID;
+  }
   get(id) {
     return this.specs.get(id);
   }
@@ -12984,7 +13323,7 @@ class AgentRegistry {
     if (!existsSync6(pkgJson))
       return null;
     try {
-      const meta = JSON.parse(readFileSync5(pkgJson, "utf8"));
+      const meta = JSON.parse(readFileSync6(pkgJson, "utf8"));
       const rel = typeof meta.bin === "string" ? meta.bin : meta.bin?.[spec.run.bin];
       if (!rel)
         return null;
@@ -13071,7 +13410,7 @@ class AgentRegistry {
       return null;
     const pkgJson = join5(this.dir, spec.id, "node_modules", name, "package.json");
     try {
-      return JSON.parse(readFileSync5(pkgJson, "utf8")).version ?? null;
+      return JSON.parse(readFileSync6(pkgJson, "utf8")).version ?? null;
     } catch {
       return null;
     }
@@ -13139,9 +13478,13 @@ function parseCustomAgents(raw) {
   }
   return out;
 }
-function loadAgentRegistry(agentsFile, agentsDir, sandbox) {
-  const custom = existsSync6(agentsFile) ? parseCustomAgents(readFileSync5(agentsFile, "utf8")) : [];
-  return new AgentRegistry([...BUILTIN_AGENTS, ...custom], agentsDir, undefined, undefined, sandbox);
+function managedSpecs(specs, managed) {
+  const kept = managed.customAgents ? specs : specs.filter((s) => s.builtin);
+  return managed.agents === null ? kept : kept.filter((s) => managed.agents?.includes(s.id));
+}
+function loadAgentRegistry(agentsFile, agentsDir, sandbox, managed = MANAGED_DEFAULTS) {
+  const custom = managed.customAgents && existsSync6(agentsFile) ? parseCustomAgents(readFileSync6(agentsFile, "utf8")) : [];
+  return new AgentRegistry(managedSpecs([...BUILTIN_AGENTS, ...custom], managed), agentsDir, undefined, undefined, sandbox);
 }
 
 // ../daemon/src/agent/acp/session.ts
@@ -13366,7 +13709,7 @@ ${a.text}
 }
 
 // ../daemon/src/agent/transcript.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { appendFile } from "fs/promises";
 import { join as join6 } from "path";
 function transcriptPathFor(transcriptsDir, worktreeId) {
@@ -13377,8 +13720,16 @@ function coalesce(entries) {
   for (const entry of entries) {
     const last = out.at(-1);
     const { event } = entry;
-    if ((event.type === "text-delta" || event.type === "thinking-delta") && last?.event.type === event.type) {
-      out[out.length - 1] = { seq: last.seq, event: { type: event.type, text: last.event.text + event.text } };
+    if (event.type === "text-delta" && last?.event.type === "text-delta") {
+      const messageId = event.messageId ?? last.event.messageId;
+      out[out.length - 1] = {
+        seq: last.seq,
+        event: { type: "text-delta", text: last.event.text + event.text, ...messageId ? { messageId } : {} }
+      };
+    } else if (event.type === "thinking-delta" && last?.event.type === "thinking-delta") {
+      out[out.length - 1] = { seq: last.seq, event: { type: "thinking-delta", text: last.event.text + event.text } };
+    } else if (event.type === "tool-delta" && last?.event.type === "tool-delta" && last.event.toolId === event.toolId) {
+      out[out.length - 1] = { seq: last.seq, event: { ...event, text: last.event.text + event.text } };
     } else {
       out.push(entry);
     }
@@ -13416,7 +13767,7 @@ class Transcript {
     this.seq = (this.entries.at(-1)?.seq ?? -1) + 1;
   }
   read() {
-    return existsSync7(this.path) ? parseTranscript(readFileSync6(this.path, "utf8"), this.tag) : [];
+    return existsSync7(this.path) ? parseTranscript(readFileSync7(this.path, "utf8"), this.tag) : [];
   }
   append(event) {
     const entry = { seq: this.seq++, event };
@@ -13724,7 +14075,7 @@ function abandoned(memos, parent) {
   }
   return out;
 }
-function mapUpdate(update, memos, tag) {
+function mapUpdate(update, memos, tag, sink) {
   switch (update.sessionUpdate) {
     case "agent_message_chunk": {
       const { parentToolId } = spawnOf(update._meta);
@@ -13732,7 +14083,7 @@ function mapUpdate(update, memos, tag) {
       const text = textOf(update.content, tag, "message");
       if (text === null)
         return out;
-      out.push(parentToolId ? { type: "tool-delta", toolId: parentToolId, text } : { type: "text-delta", text });
+      out.push(parentToolId ? { type: "tool-delta", toolId: parentToolId, text } : { type: "text-delta", text, ...update.messageId ? { messageId: update.messageId } : {} });
       return out;
     }
     case "agent_thought_chunk": {
@@ -13768,7 +14119,7 @@ function mapUpdate(update, memos, tag) {
         ...spawn
       });
       if (update.status === "completed" || update.status === "failed")
-        out.push(endOf(update.toolCallId, memo, update.status));
+        out.push(endOf(update.toolCallId, memo, update.status, sink));
       return out;
     }
     case "tool_call_update": {
@@ -13821,7 +14172,7 @@ function mapUpdate(update, memos, tag) {
       if (update.rawOutput !== undefined)
         memo.rawOutput = update.rawOutput;
       if ((update.status === "completed" || update.status === "failed") && !memo.ended) {
-        out.push(endOf(update.toolCallId, memo, update.status));
+        out.push(endOf(update.toolCallId, memo, update.status, sink));
       }
       return out;
     }
@@ -13852,25 +14203,43 @@ function textOf(content, tag, what) {
   log.debug(tag, `acp: dropping non-text ${what} block (${content.type})`);
   return null;
 }
-function endOf(toolId, memo, status) {
+function endOf(toolId, memo, status, sink) {
   memo.ended = true;
+  const images = sink ? toolImages(memo.content, sink) : [];
   return {
     type: "tool-end",
     toolId,
     output: summarizeToolOutput(memo.content, memo.rawOutput),
-    isError: status === "failed" || exitCodeOf(memo.rawOutput) > 0
+    isError: status === "failed" || exitCodeOf(memo.rawOutput) > 0,
+    ...images.length ? { images } : {}
   };
 }
+function toolImages(content, sink) {
+  const out = [];
+  for (const c of content) {
+    if (c.type !== "content" || c.content.type !== "image")
+      continue;
+    const img = toolImage(c.content.data, c.content.mimeType);
+    if (!img)
+      continue;
+    sink(img.ref.file, img.bytes);
+    out.push(img.ref);
+  }
+  return out;
+}
 function exitCodeOf(rawOutput) {
   const exit = rawOutput?.metadata?.exit;
   return typeof exit === "number" ? exit : 0;
 }
 function summarizeToolOutput(content, rawOutput) {
   const parts = [];
+  let pictured = false;
   for (const c of content) {
     if (c.type === "content") {
       if (c.content.type === "text")
         parts.push(c.content.text);
+      else if (c.content.type === "image")
+        pictured = true;
     } else if (c.type === "diff") {
       const body = unifiedDiff(c.oldText ?? "", c.newText);
       if (body)
@@ -13882,6 +14251,8 @@ ${body}
   if (parts.length > 0)
     return truncate(parts.join(`
 `));
+  if (pictured)
+    return "";
   if (typeof rawOutput === "string")
     return truncate(rawOutput);
   if (rawOutput && typeof rawOutput === "object") {
@@ -13943,6 +14314,7 @@ class AcpSession {
   running = false;
   interrupted = false;
   stopped = false;
+  held = false;
   conn = null;
   connecting = null;
   live = null;
@@ -14056,7 +14428,7 @@ class AcpSession {
       return log.warn(this.d.worktreeId, "send after close dropped");
     const { context, attachments } = opts;
     const item = { text, context, ...attachments?.length ? { attachments } : {} };
-    if ((this.running || this.own) && !this.interrupted && this.live?.conn.steering) {
+    if ((this.running || this.own) && !this.interrupted && !this.held && this.live?.conn.steering) {
       return fireAndForget(this.d.worktreeId, this.steer(item), "agent steer");
     }
     this.enqueue(item);
@@ -14064,9 +14436,21 @@ class AcpSession {
   enqueue(item) {
     this.queue.push(item);
     this.queueChanged();
-    if (!this.running)
+    if (!this.running && !this.held)
       fireAndForget(this.d.worktreeId, this.drain(), "agent drain");
   }
+  hold() {
+    this.held = true;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      this.held = false;
+      if (!this.running && this.queue.length > 0)
+        fireAndForget(this.d.worktreeId, this.drain(), "agent drain");
+    };
+  }
   async steer(item) {
     item.recorded ??= await this.record(item);
     const live = this.live;
@@ -14144,7 +14528,7 @@ class AcpSession {
     this.setStatus("working");
     let item = null;
     try {
-      while (this.queue.length > 0) {
+      while (this.queue.length > 0 && !this.held) {
         item = this.queue.shift();
         this.queueChanged();
         try {
@@ -14168,7 +14552,7 @@ class AcpSession {
           type: "agent-auth-required",
           agent: this.conn.spec.id,
           agentName: this.conn.spec.name,
-          methods: this.conn.authMethods.map(authMethodInfo),
+          ...this.offeredMethods(this.conn),
           ...rejected ? { rejected: true } : {},
           ts: Date.now()
         });
@@ -14208,9 +14592,6 @@ class AcpSession {
         caps: { close: conn.closeSupported, delete: conn.deleteSupported },
         tag: this.d.worktreeId
       });
-    } catch (e) {
-      log.warn(this.d.worktreeId, "ask failed", e);
-      return null;
     } finally {
       this.asking--;
       this.maybeArmReaper();
@@ -14221,6 +14602,9 @@ class AcpSession {
     const method = conn.authMethods.find((m) => m.id === methodId);
     if (!method)
       throw new UserError(`${conn.spec.name} offers no login method "${methodId}"`);
+    if (this.planWithheld(conn, methodId)) {
+      throw new UserError("Signing in with a Claude plan is turned off by your organization's policy");
+    }
     const login = terminalLogin(method);
     if (login) {
       const l = this.d.launch(conn.spec);
@@ -14256,6 +14640,14 @@ class AcpSession {
     if (item)
       this.send(item.text, item);
   }
+  planWithheld(conn, methodId) {
+    return this.d.planSignIn?.() === false && conn.spec.terminalLogins?.[methodId]?.plan === true;
+  }
+  offeredMethods(conn) {
+    const kept = conn.authMethods.filter((m) => !this.planWithheld(conn, m.id));
+    const methods2 = kept.map(authMethodInfo);
+    return kept.length === conn.authMethods.length ? { methods: methods2 } : { methods: methods2, withheld: true };
+  }
   rejectedCredential(e) {
     if (!this.conn?.authMethods.length)
       return false;
@@ -14517,7 +14909,7 @@ class AcpSession {
     }
     if (params.update.sessionUpdate === "config_option_update")
       this.absorb(live, params.update.configOptions);
-    const events = mapUpdate(params.update, live.tools, this.d.worktreeId);
+    const events = mapUpdate(params.update, live.tools, this.d.worktreeId, (file, bytes) => fireAndForget(this.d.worktreeId, this.d.attachments.putToolImage(this.d.worktreeId, file, bytes), "tool image"));
     if (!this.running)
       this.trackOwn(events);
     for (const ev of events) {
@@ -14775,7 +15167,7 @@ function sameCommands(a, b) {
 }
 
 // ../daemon/src/agent/planDoc.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
 import { join as join7 } from "path";
 var PLANS_DIR = join7(".toyon", "plans");
 var PLAN_NAME = /^(\d+)\.md$/;
@@ -14813,7 +15205,7 @@ function planEdited(cwd, rel, proposed) {
   if (!existsSync8(file))
     return false;
   try {
-    return readFileSync7(file, "utf8").trim() !== proposed.trim();
+    return readFileSync8(file, "utf8").trim() !== proposed.trim();
   } catch (e) {
     log.warn(cwd, `could not read ${rel}`, e);
     return false;
@@ -15097,8 +15489,8 @@ function expandEnv(env, vars) {
 
 // ../daemon/src/core/remote.ts
 import { createHmac, timingSafeEqual } from "crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-function loadRemote(file, env = process.env) {
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+function loadRemote(file, env = process.env, managed = MANAGED_DEFAULTS) {
   if (env.TOYON_CLOUD === "1") {
     const host = (env.TOYON_PUBLIC_HOST ?? "").toLowerCase();
     if (!isRemoteHost(host)) {
@@ -15112,11 +15504,19 @@ function loadRemote(file, env = process.env) {
   }
   if (!existsSync9(file))
     return null;
-  const view = parseRemote(readFileSync8(file, "utf8"));
+  if (managed.remote === "off") {
+    log.warn("remote", `${file} is ignored: remote access is turned off by your organization's policy`);
+    return null;
+  }
+  const view = parseRemote(readFileSync9(file, "utf8"));
   if (!view) {
     log.warn("remote", `${file} names no valid host or previews; remote access is off`);
     return null;
   }
+  if (managed.remote === "tailscale" && !view.host.endsWith(".ts.net")) {
+    log.warn("remote", `${file} names ${view.host}; your organization's policy allows a tailnet name only, so remote access is off`);
+    return null;
+  }
   return { ...view, front: "local" };
 }
 function sameSecret(given, want) {
@@ -15485,31 +15885,50 @@ class PtyStream {
 // ../daemon/src/runtime/lines.ts
 var MAX_PENDING = 64 * 1024;
 var ANSI = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)|[@-Z\\-_])/g;
+var UP = /\u001b\[(\d*)[AF]/g;
 function clean(raw) {
   const parts = raw.replace(ANSI, "").split("\r");
   while (parts.length > 1 && !parts[parts.length - 1]?.trim())
     parts.pop();
   return (parts[parts.length - 1] ?? "").trimEnd();
 }
+function takeUps(raw) {
+  let n = 0;
+  const rest = raw.replace(UP, (_, count) => {
+    n += count === "" ? 1 : Number(count);
+    return "";
+  });
+  return [rest, n];
+}
 
 class LineSplitter {
   pending = "";
   feed(chunk) {
     this.pending += chunk;
     const out = [];
+    const emit = (raw) => {
+      const [rest, retract] = takeUps(raw);
+      const line = clean(rest);
+      if (line || retract)
+        out.push({ line, retract });
+    };
     for (let nl = this.pending.indexOf(`
 `);nl !== -1; nl = this.pending.indexOf(`
 `)) {
-      const line = clean(this.pending.slice(0, nl));
+      const raw = this.pending.slice(0, nl);
       this.pending = this.pending.slice(nl + 1);
-      if (line)
-        out.push(line);
+      emit(raw);
     }
     if (this.pending.length > MAX_PENDING) {
-      const line = clean(this.pending);
+      const raw = this.pending;
       this.pending = "";
-      if (line)
-        out.push(line);
+      emit(raw);
+      return out;
+    }
+    const [rest, retract] = takeUps(this.pending);
+    if (retract) {
+      this.pending = rest;
+      out.push({ line: "", retract });
     }
     return out;
   }
@@ -15655,8 +16074,8 @@ class WorktreeProcs {
         ring: PROC_RING
       }, (data) => {
         this.onData(name, data);
-        for (const line of mp.lines.feed(data))
-          this.pushLine(name, line);
+        for (const ev of mp.lines.feed(data))
+          this.pushLine(name, ev.line, ev.retract);
       }, (code) => this.handleExit(mp, code));
     } catch (e) {
       mp.state.status = "crashed";
@@ -15822,11 +16241,11 @@ class WorktreeProcs {
   states() {
     return [...this.procs.values()].map((p) => ({ ...p.state }));
   }
-  pushLine(proc, line) {
-    this.lines.push({ proc, line });
+  pushLine(proc, line, retract = 0) {
+    this.lines = applyLog(this.lines, proc, line, retract);
     if (this.lines.length > LOG_RING_SIZE)
       this.lines.shift();
-    this.onLog(proc, line);
+    this.onLog(proc, line, retract);
   }
 }
 function execForm(command) {
@@ -15871,7 +16290,6 @@ function terminalEnv(base, own, urls) {
   }
   return { ...env, ...urls, TERM: "xterm-256color", COLORTERM: "truecolor", ...own };
 }
-var DEFAULT_AGENT_ID = "claude";
 var PREVIEW_WAKE_MS = 8000;
 var PREVIEW_POLL_MS = 100;
 function defaultAgent(wt, d, preview, onProcess) {
@@ -15883,7 +16301,7 @@ function defaultAgent(wt, d, preview, onProcess) {
     spec: () => {
       const w = d.state.requireWorktree(wt.id);
       if (!w.agent) {
-        w.agent = d.state.defaultAgent ?? DEFAULT_AGENT_ID;
+        w.agent = d.agents.defaultId(d.state.defaultAgent);
         d.state.save();
         d.hub.emit("worktreesChanged");
       }
@@ -15891,6 +16309,7 @@ function defaultAgent(wt, d, preview, onProcess) {
     },
     connect: (app, spec, prepared) => spawnAcp(app, d.agents.launch(spec, prepared), wt.path, wt.id),
     launch: (spec) => d.agents.command(spec),
+    planSignIn: () => d.managed?.planSignIn ?? true,
     transcriptsDir: d.paths.transcriptsDir,
     attachments: d.attachments ?? new AttachmentStore(d.paths.attachmentsDir),
     getSessionId: () => d.state.session(wt.id),
@@ -16429,7 +16848,7 @@ class RuntimeRegistry {
       for (const g of rt.procs?.groups() ?? [])
         live.push(g);
       if (rt.agent.pgid !== null) {
-        const agentId = this.deps.state.worktree(id)?.agent ?? this.deps.state.defaultAgent ?? DEFAULT_AGENT_ID;
+        const agentId = this.deps.state.worktree(id)?.agent ?? this.deps.agents.defaultId(this.deps.state.defaultAgent);
         live.push({ name: `agent:${agentId}`, pgid: rt.agent.pgid });
       }
       if (rt.shell?.alive)
@@ -16894,7 +17313,7 @@ function makePlanner(agents) {
 }
 
 // ../daemon/src/core/assets.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, rmSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync3, rmSync, statSync as statSync3 } from "fs";
 import { join as join9, resolve as resolve5 } from "path";
 function locateAssets(here, env = process.env) {
   const packaged = existsSync11(join9(here, "shell", "index.html"));
@@ -16918,7 +17337,7 @@ function pruneAssets(shellDist) {
   for (const name of names) {
     const path = join9(dir, name);
     try {
-      found.push({ path, mtime: statSync2(path).mtimeMs });
+      found.push({ path, mtime: statSync3(path).mtimeMs });
     } catch {}
   }
   if (found.length === 0)
@@ -17025,7 +17444,7 @@ class Hub {
 }
 
 // ../daemon/src/core/restart.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { openSync } from "fs";
 function restartable(env = process.env) {
   if (env.TOYON_WORKTREE !== undefined) {
@@ -17035,7 +17454,7 @@ function restartable(env = process.env) {
 }
 function respawn(logFile) {
   const logFd = openSync(logFile, "a");
-  const child = spawn2(process.execPath, process.argv.slice(1), {
+  const child = spawn3(process.execPath, process.argv.slice(1), {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env }
@@ -17177,7 +17596,7 @@ class SelfWatch {
 
 // ../daemon/src/core/state.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
 var GROUPS_SAVE_MS = 250;
 var SEEN_WORKTREES = 50;
 var empty = { repos: [], worktrees: [], sessions: {} };
@@ -17188,7 +17607,7 @@ function loadState(paths) {
     return structuredClone(empty);
   let raw;
   try {
-    raw = readFileSync9(STATE_FILE, "utf8");
+    raw = readFileSync10(STATE_FILE, "utf8");
   } catch (e) {
     log.error("state", `cannot read ${STATE_FILE}; starting empty`, e);
     return structuredClone(empty);
@@ -17237,7 +17656,7 @@ function loadOrCreateToken(paths) {
   ensureDirs(paths);
   const TOKEN_FILE = paths.tokenFile;
   if (existsSync13(TOKEN_FILE))
-    return readFileSync9(TOKEN_FILE, "utf8").trim();
+    return readFileSync10(TOKEN_FILE, "utf8").trim();
   const token = randomBytes2(32).toString("hex");
   writeFileSync5(TOKEN_FILE, token, { mode: 384 });
   return token;
@@ -17414,6 +17833,12 @@ class StateStore {
     this.state.defaultAgent = id;
     this.save();
   }
+  clearDefaultAgent() {
+    if (this.state.defaultAgent === undefined)
+      return;
+    delete this.state.defaultAgent;
+    this.save();
+  }
   get theme() {
     return this.state.theme;
   }
@@ -18018,7 +18443,7 @@ async function loadProjectTypescript(root) {
 }
 
 // ../daemon/src/drafts/store.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "fs";
 var SAVE_DELAY_MS = 1000;
 
 class DraftStore {
@@ -18030,7 +18455,7 @@ class DraftStore {
     if (!existsSync14(d.file))
       return;
     try {
-      const raw = JSON.parse(readFileSync10(d.file, "utf8"));
+      const raw = JSON.parse(readFileSync11(d.file, "utf8"));
       if (!raw || typeof raw !== "object")
         return;
       for (const [id, text] of Object.entries(raw)) {
@@ -18106,6 +18531,7 @@ var OUTPUT_CAP = 200000;
 var TIMEOUT_MS = 10 * 60000;
 var KILL_GRACE_MS2 = 3000;
 var DRAIN_GRACE_MS = 500;
+var LIVE_AFTER_MS = 1500;
 
 class ExecService {
   deps;
@@ -18114,18 +18540,26 @@ class ExecService {
   constructor(deps) {
     this.deps = deps;
   }
+  agentFor(worktreeId) {
+    const wt = this.deps.state.requireWorktree(worktreeId);
+    if (wt.kind === "spare")
+      throw new UserError("no shell for a spare worktree");
+    const agent = this.deps.runtime.agentFor(worktreeId);
+    if (!agent)
+      throw new UserError("worktree still starting; try again in a moment");
+    return agent;
+  }
   run(worktreeId, command) {
+    const op = this.deps.shipping?.(worktreeId);
+    if (op)
+      throw new UserError(`${shipNoun(op.op)} is running here; run the command once it is done`);
     fireAndForget(worktreeId, this.exec(worktreeId, command), `exec ${command}`);
   }
   exec(worktreeId, command, name = SHELL_TOOL, opts = {}) {
     const wt = this.deps.state.requireWorktree(worktreeId);
-    if (wt.kind === "spare")
-      throw new UserError("no shell for a spare worktree");
     if (wt.kind === "main")
       throw new UserError("nothing runs on main: the plus starts a worktree for it");
-    const agent = this.deps.runtime.agentFor(worktreeId);
-    if (!agent)
-      throw new UserError("worktree still starting; try again in a moment");
+    const agent = this.agentFor(worktreeId);
     const toolId = `${name}-${Date.now().toString(36)}-${++this.n}`;
     const start = { type: "tool-start", toolId, name, input: { command }, kind: "execute" };
     if (!opts.quiet)
@@ -18149,22 +18583,58 @@ class ExecService {
       return Promise.resolve({ exit: reason, text: "" });
     }
     const timer = setTimeout(() => this.kill(worktreeId, toolId), TIMEOUT_MS);
-    this.track(worktreeId, toolId, { proc, timer });
+    const stop = () => {
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.running.get(worktreeId)?.has(toolId))
+          proc.kill("SIGKILL");
+      }, KILL_GRACE_MS2);
+    };
+    this.track(worktreeId, toolId, { stop, timer });
     this.deps.runtime.hold(worktreeId, `exec:${toolId}`);
     return this.collect(worktreeId, toolId, proc, agent, opts.quiet ? start : undefined);
   }
-  record(worktreeId, command, text, exit) {
-    const wt = this.deps.state.requireWorktree(worktreeId);
-    if (wt.kind === "spare")
-      throw new UserError("no shell for a spare worktree");
-    const agent = this.deps.runtime.agentFor(worktreeId);
-    if (!agent)
-      throw new UserError("worktree still starting; try again in a moment");
+  async watch(worktreeId, command, run) {
+    const agent = this.agentFor(worktreeId);
     const toolId = `${SHELL_TOOL}-${Date.now().toString(36)}-${++this.n}`;
-    agent.note({ type: "tool-start", toolId, name: SHELL_TOOL, input: { command }, kind: "execute" });
-    const truncated = text.length > OUTPUT_CAP;
-    const shown = truncated ? text.slice(0, OUTPUT_CAP) : text;
-    agent.note({ type: "tool-end", toolId, output: formatOutput(shown, exit, truncated), isError: exit !== 0 });
+    const ctl = new AbortController;
+    this.track(worktreeId, toolId, { stop: () => ctl.abort() });
+    const start = { type: "tool-start", toolId, name: SHELL_TOOL, input: { command }, kind: "execute" };
+    let text = "";
+    let truncated = false;
+    let up = false;
+    const raise = () => {
+      if (up)
+        return;
+      up = true;
+      agent.note(start);
+      if (text)
+        agent.note({ type: "tool-delta", toolId, text });
+    };
+    const timer = setTimeout(raise, this.deps.liveAfterMs ?? LIVE_AFTER_MS);
+    const onText = (chunk) => {
+      if (truncated)
+        return;
+      const take = chunk.slice(0, OUTPUT_CAP - text.length);
+      text += take;
+      if (take.length < chunk.length)
+        truncated = true;
+      if (up && take)
+        agent.note({ type: "tool-delta", toolId, text: take });
+    };
+    let r;
+    try {
+      r = await run(onText, ctl.signal);
+    } finally {
+      clearTimeout(timer);
+      this.untrack(worktreeId, toolId);
+    }
+    if (!up && r.exit === 0)
+      return { ...r, shown: false };
+    if (!up)
+      agent.note(start);
+    agent.note({ type: "tool-end", toolId, output: formatOutput(text, r.exit, truncated), isError: r.exit !== 0 });
+    return { ...r, shown: true };
   }
   stop(worktreeId) {
     for (const toolId of this.running.get(worktreeId)?.keys() ?? [])
@@ -18187,18 +18657,12 @@ class ExecService {
     return r;
   }
   kill(worktreeId, toolId) {
-    const r = this.running.get(worktreeId)?.get(toolId);
-    if (!r)
-      return;
-    r.proc.kill("SIGTERM");
-    setTimeout(() => {
-      if (this.running.get(worktreeId)?.has(toolId))
-        r.proc.kill("SIGKILL");
-    }, KILL_GRACE_MS2);
+    this.running.get(worktreeId)?.get(toolId)?.stop();
   }
   async collect(worktreeId, toolId, proc, agent, heldStart) {
     let text = "";
     let truncated = false;
+    const live = !heldStart;
     const drain = async (stream) => {
       if (!stream || typeof stream === "number")
         return;
@@ -18210,11 +18674,13 @@ class ExecService {
           return;
         if (truncated)
           continue;
-        text += decoder.decode(value, { stream: true });
-        if (text.length > OUTPUT_CAP) {
-          text = text.slice(0, OUTPUT_CAP);
+        const chunk = decoder.decode(value, { stream: true });
+        const take = chunk.slice(0, OUTPUT_CAP - text.length);
+        text += take;
+        if (take.length < chunk.length)
           truncated = true;
-        }
+        if (live && take)
+          agent.note({ type: "tool-delta", toolId, text: take });
       }
     };
     let exit = null;
@@ -18259,7 +18725,7 @@ ${body}
 }
 
 // ../daemon/src/files/service.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { stat, unlink } from "fs/promises";
 
 // ../daemon/src/git/lock.ts
@@ -18797,7 +19263,7 @@ class FileService {
   }
   async viewableFile(worktreeId, path) {
     const r = this.readable(worktreeId);
-    if (!r || viewerOf(path) === null)
+    if (!r || viewerOf(path) === null && !isPageAsset(path))
       return null;
     try {
       const target = resolveInside(r.path, path);
@@ -18920,7 +19386,7 @@ class FileService {
   revealPath(target) {
     if (process.platform !== "darwin")
       throw new UserError("reveal is only available on macOS");
-    const child = spawn3("open", ["-R", target], { stdio: "ignore" });
+    const child = spawn4("open", ["-R", target], { stdio: "ignore" });
     child.on("error", () => {});
     child.unref();
   }
@@ -19030,11 +19496,11 @@ function runSetup(cmd, cwd, onLine, extra = {}) {
         args: ["-c", cmd],
         ring: SETUP_RING
       }, (data) => {
-        for (const line of lines.feed(data))
-          onLine(line);
+        for (const ev of lines.feed(data))
+          onLine(ev.line, ev.retract);
       }, resolve);
     } catch (e) {
-      onLine(`could not run: ${e instanceof Error ? e.message : String(e)}`);
+      onLine(`could not run: ${e instanceof Error ? e.message : String(e)}`, 0);
       resolve(1);
     }
   });
@@ -19084,9 +19550,10 @@ class AfterLand {
     for (const command of commands) {
       this.tellMain(repo, `afterLand: ${command}`);
       let last = "";
-      const code = await runSetup(command, repo.path, (line) => {
-        last = line;
-        this.tellMain(repo, line);
+      const code = await runSetup(command, repo.path, (line, retract) => {
+        if (line)
+          last = line;
+        this.tellMain(repo, line, retract);
       });
       if (code === 0)
         continue;
@@ -19106,10 +19573,10 @@ class AfterLand {
         this.d.hub.emit("failed", main.id, notice);
     }
   }
-  tellMain(repo, line) {
+  tellMain(repo, line, retract) {
     const main = this.mainOf(repo);
     if (main)
-      this.d.hub.emit("log", main.id, "land", line);
+      this.d.hub.emit("log", main.id, "land", line, retract);
   }
   mainOf(repo) {
     return this.d.state.worktrees.find((w) => w.repoId === repo.id && w.kind === "main");
@@ -19122,7 +19589,7 @@ import { homedir as homedir7 } from "os";
 import { basename as basename3, dirname as dirname6, join as join16 } from "path";
 
 // ../daemon/src/repos/browse.ts
-import { existsSync as existsSync15, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, statSync as statSync4 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname4, join as join12 } from "path";
@@ -19151,7 +19618,7 @@ var NOWHERE = { exists: false, isDir: false, isRepo: false, parentExists: false
 function describe2(typed, parent) {
   let isDir = false;
   try {
-    isDir = statSync3(typed).isDirectory();
+    isDir = statSync4(typed).isDirectory();
   } catch {}
   return {
     exists: existsSync15(typed),
@@ -19189,7 +19656,7 @@ async function browsePath(raw) {
 }
 
 // ../daemon/src/repos/config.ts
-import { closeSync, existsSync as existsSync16, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync11, readSync } from "fs";
+import { closeSync, existsSync as existsSync16, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync12, readSync } from "fs";
 import { join as join13 } from "path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -20579,7 +21046,7 @@ function readConfigFile(repoPath) {
   for (const rel of files) {
     let raw;
     try {
-      raw = parseSettings(readFileSync11(join13(repoPath, rel), "utf8"));
+      raw = parseSettings(readFileSync12(join13(repoPath, rel), "utf8"));
     } catch (e) {
       return { ok: false, reason: `${rel} is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
     }
@@ -20641,7 +21108,7 @@ function configBody(repoPath, rel, config) {
     return config;
   let shared;
   try {
-    shared = parseSettings(readFileSync11(abs, "utf8"));
+    shared = parseSettings(readFileSync12(abs, "utf8"));
   } catch {
     return config;
   }
@@ -20654,7 +21121,7 @@ function configText(repoPath, rel, config) {
   let text;
   let was;
   try {
-    text = readFileSync11(join13(repoPath, rel), "utf8");
+    text = readFileSync12(join13(repoPath, rel), "utf8");
     was = parseSettings(text);
   } catch {
     return fresh;
@@ -20686,7 +21153,7 @@ function detectConfig(repoPath) {
     log.warn("config", `${repoPath}: ${explicit.reason}; detecting instead`);
   const pkgPath = join13(repoPath, "package.json");
   if (existsSync16(pkgPath)) {
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const runner = detectRunner(repoPath, pkg.packageManager);
     const pages = detectPages(repoPath, scripts, runner);
@@ -20832,7 +21299,7 @@ function detectPages(repoPath, scripts, runner) {
   const cfg = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"].map((f) => join13(repoPath, f)).find((f) => existsSync16(f));
   if (!cfg)
     return null;
-  const out = readFileSync11(cfg, "utf8").match(/pages_build_output_dir"?\s*[:=]\s*"([^"]+)"/)?.[1];
+  const out = readFileSync12(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` };
@@ -20848,7 +21315,7 @@ function detectRunner(repoPath, packageManager) {
 }
 
 // ../daemon/src/repos/create.ts
-import { existsSync as existsSync17, readdirSync as readdirSync5, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync5, realpathSync as realpathSync2, statSync as statSync5 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir2, rm } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname5, join as join14, resolve as resolve7 } from "path";
@@ -20879,7 +21346,7 @@ function planInPlace(opts) {
     throw new UserError(`${opts.name} is not a folder name`);
   }
   const typed = join14(resolveParent(opts.parent), name);
-  if (!existsSync17(typed) || !statSync4(typed).isDirectory())
+  if (!existsSync17(typed) || !statSync5(typed).isDirectory())
     throw new UserError(`${typed} is not a folder`);
   const dir = realpathSync2(typed);
   if (existsSync17(join14(dir, ".git")))
@@ -20895,7 +21362,7 @@ function resolveParent(raw) {
     throw new UserError(`${raw} is not a folder path`);
   if (!existsSync17(typed))
     throw new UserError(`${raw} does not exist; make it first`);
-  if (!statSync4(typed).isDirectory())
+  if (!statSync5(typed).isDirectory())
     throw new UserError(`${raw} is not a folder`);
   return realpathSync2(typed);
 }
@@ -22824,7 +23291,7 @@ class RouteService {
 }
 
 // ../daemon/src/runtime/bridge-script.ts
-import { existsSync as existsSync20, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync13, statSync as statSync6 } from "fs";
 var LEARNED_MAX = 8;
 
 class BridgeScript {
@@ -22856,14 +23323,14 @@ class BridgeScript {
   get() {
     if (!existsSync20(this.path))
       return "// toyon bridge not built";
-    const s = statSync5(this.path);
+    const s = statSync6(this.path);
     const stamp = `${s.mtimeMs}:${s.size}`;
     if (this.cache && stamp === this.stamp)
       return this.cache;
     this.stamp = stamp;
     const origins = [...this.origins, ...this.learned];
     this.cache = `window.__toyonShellOrigins=${JSON.stringify(origins)};
-${readFileSync12(this.path, "utf8")}`;
+${readFileSync13(this.path, "utf8")}`;
     return this.cache;
   }
 }
@@ -23183,7 +23650,7 @@ class PairCodes {
 }
 
 // ../daemon/src/agent/config.ts
-import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join18 } from "path";
 function agentConfigFiles(spec, repoPath, home = homedir8()) {
@@ -23226,7 +23693,7 @@ function readJson(path) {
   if (!existsSync21(path))
     return null;
   try {
-    const v = JSON.parse(readFileSync13(path, "utf8"));
+    const v = JSON.parse(readFileSync14(path, "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : null;
   } catch (e) {
     log.warn("agent-config", `${path} is not valid JSON`, e);
@@ -23248,7 +23715,7 @@ function codexServers(path) {
     return [];
   const out = [];
   let current = null;
-  for (const raw of readFileSync13(path, "utf8").split(`
+  for (const raw of readFileSync14(path, "utf8").split(`
 `)) {
     const line = raw.trim();
     const header = /^\[mcp_servers\.("?)([^\]"]+)\1\]$/.exec(line);
@@ -24259,6 +24726,7 @@ function createFetch(opts) {
     pid: process.pid,
     branded: opts.branded(),
     remote: remote && { host: remote.host, previews: remote.previews },
+    managed: opts.managed,
     ...opts.metrics()
   });
   return async function fetch2(req, srv) {
@@ -24371,6 +24839,8 @@ function createFetch(opts) {
         return new Response("unauthorized", { status: 401 });
       const [worktreeId, file, extra] = url.pathname.slice("/attachments/".length).split("/");
       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 && existsSync22(p));
       if (!path)
         return new Response("not found", { status: 404 });
@@ -24523,7 +24993,7 @@ function startServer(opts) {
   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 }));
-  s.hub.on("log", (worktreeId, proc, line) => sendTo(worktreeId, { t: "log", worktreeId, proc, line }));
+  s.hub.on("log", (worktreeId, proc, line, retract) => sendTo(worktreeId, retract ? { t: "log", worktreeId, proc, line, retract } : { t: "log", worktreeId, proc, line }));
   s.hub.on("queue", (worktreeId, items) => sendTo(worktreeId, { t: "queue", worktreeId, items }));
   s.hub.on("agentCommands", (worktreeId, commands) => sendTo(worktreeId, { t: "agent-commands", worktreeId, commands }));
   s.hub.on("termData", (worktreeId, stream, data) => queueTerm(worktreeId, stream, data));
@@ -24603,7 +25073,7 @@ function startServer(opts) {
   const agentsMsg = () => ({
     t: "agents",
     agents: agentInfos(),
-    defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID,
+    defaultAgent: s.agents.defaultId(s.state.defaultAgent),
     agentChosen: s.state.defaultAgent !== undefined
   });
   s.hub.on("agentsChanged", () => broadcast(agentsMsg()));
@@ -24626,7 +25096,7 @@ function startServer(opts) {
       themes: s.themes.themes,
       themePrefs: s.themes.prefs,
       agents: agentInfos(),
-      defaultAgent: s.state.defaultAgent ?? DEFAULT_AGENT_ID,
+      defaultAgent: s.agents.defaultId(s.state.defaultAgent),
       agentChosen: s.state.defaultAgent !== undefined,
       home: homedir9(),
       folderDialog: process.platform === "darwin" && !cloud.enabled,
@@ -24637,7 +25107,8 @@ function startServer(opts) {
       visits: s.routes.historyAll(),
       self: s.self.get(),
       update: s.update.get(),
-      drafts: s.drafts.all()
+      drafts: s.drafts.all(),
+      managed: managedView(opts.managed)
     };
   };
   let branded = false;
@@ -24655,6 +25126,7 @@ function startServer(opts) {
       metrics,
       noteShellOrigin: opts.noteShellOrigin,
       remote: opts.remote,
+      managed: { source: opts.managed.source, hash: opts.managed.hash },
       preview: (id) => s.runtime.get(id)?.proxy?.handler ?? null,
       bootstrap: helloFrame,
       restart: (now) => s.restarter.request({ now }),
@@ -24753,7 +25225,7 @@ function startServer(opts) {
   };
   const server = Bun.serve({ ...serverConfig, port: opts.port });
   let brandedServer = null;
-  if (opts.port !== 80 && !cloud.enabled) {
+  if (opts.port !== 80 && !cloud.enabled && opts.managed.policy.brandedListener) {
     try {
       brandedServer = Bun.serve({ ...serverConfig, hostname: "0.0.0.0", port: 80 });
       branded = true;
@@ -24770,7 +25242,7 @@ function startServer(opts) {
 }
 
 // ../daemon/src/themes/store.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync7, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir10 } from "os";
 import { basename as basename4, dirname as dirname7, join as join20, resolve as resolve8 } from "path";
 var home = homedir10();
@@ -24870,7 +25342,7 @@ class ThemeStore {
   }
 }
 function readJsonc(file) {
-  return parse6(readFileSync14(file, "utf8"), [], { allowTrailingComma: true });
+  return parse6(readFileSync15(file, "utf8"), [], { allowTrailingComma: true });
 }
 function readVscodeTheme(file, depth = 0) {
   const json = readJsonc(file);
@@ -24927,9 +25399,9 @@ function discover(dir) {
     const extDir = join20(dir, name);
     const pkgFile = join20(extDir, "package.json");
     try {
-      if (!statSync6(extDir).isDirectory() || !existsSync23(pkgFile))
+      if (!statSync7(extDir).isDirectory() || !existsSync23(pkgFile))
         continue;
-      const pkg = JSON.parse(readFileSync14(pkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync15(pkgFile, "utf8"));
       const themes = pkg.contributes?.themes;
       if (!Array.isArray(themes))
         continue;
@@ -24938,7 +25410,7 @@ function discover(dir) {
       const nlsFile = join20(extDir, "package.nls.json");
       if (existsSync23(nlsFile)) {
         try {
-          nls = JSON.parse(readFileSync14(nlsFile, "utf8"));
+          nls = JSON.parse(readFileSync15(nlsFile, "utf8"));
         } catch {}
       }
       for (const c of themes) {
@@ -25052,7 +25524,7 @@ class UpdateService {
     this.announce();
   }
   async check() {
-    if (this.d.method === "none" || this.d.managed)
+    if (this.d.method === "none" || this.d.managedBy)
       return;
     const answer = await this.d.latest();
     if (answer.version === null) {
@@ -25065,8 +25537,7 @@ class UpdateService {
     await this.auto();
   }
   async updateNow() {
-    if (this.d.managed)
-      throw new UserError("Updates are turned off for this machine (TOYON_UPDATES=off)");
+    this.refuseManaged();
     const target = this.target();
     if (target === null)
       throw new UserError("Toyon is up to date");
@@ -25078,8 +25549,7 @@ class UpdateService {
     await this.proceed();
   }
   async checkNow() {
-    if (this.d.managed)
-      throw new UserError("Updates are turned off for this machine (TOYON_UPDATES=off)");
+    this.refuseManaged();
     if (this.d.method === "none") {
       throw new UserError(`Toyon ${this.d.running} runs from a checkout, which does not update itself`);
     }
@@ -25108,10 +25578,16 @@ class UpdateService {
     };
   }
   status() {
-    return { managed: this.d.managed, unreachable: this.unreachable, latest: this.latest };
+    return { managedBy: this.d.managedBy, unreachable: this.unreachable, latest: this.latest };
+  }
+  refuseManaged() {
+    if (this.d.managedBy === "policy")
+      throw new UserError("Updates are turned off by your organization's policy");
+    if (this.d.managedBy === "env")
+      throw new UserError("Updates are turned off for this machine (TOYON_UPDATES=off)");
   }
   async auto() {
-    if (this.wanted || this.installing || this.d.managed)
+    if (this.wanted || this.installing || this.d.managedBy)
       return;
     const target = this.target();
     if (target === null)
@@ -25313,6 +25789,7 @@ class LandingService {
   d;
   judging = new Map;
   busy = new Set;
+  stopping = false;
   constructor(d) {
     this.d = d;
     d.hub.on("turnSettled", (id, turn) => fireAndForget(id, this.settle(id, turn), "landing verdict"));
@@ -25332,6 +25809,16 @@ class LandingService {
     this.judging.delete(worktreeId);
     this.d.worktrees.setLanding(worktreeId, undefined);
   }
+  boot() {
+    for (const wt of this.d.state.worktrees) {
+      if (wt.landing?.check !== "pending" || !canLand(wt))
+        continue;
+      fireAndForget(wt.id, this.run(wt, { at: wt.landing.at, ask: true, quiet: false }), "landing verdict resumed");
+    }
+  }
+  stop() {
+    this.stopping = true;
+  }
   async settle(worktreeId, turn) {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt || !canLand(wt))
@@ -25409,7 +25896,7 @@ class LandingService {
     this.judging.set(worktreeId, opts.at);
     const started = Date.now();
     this.d.worktrees.setLanding(worktreeId, { at: opts.at, check: "pending", ready: false, fingerprint: "", ...kept });
-    const live = () => this.judging.get(worktreeId) === opts.at && !!this.d.state.worktree(worktreeId);
+    const live = () => !this.stopping && this.judging.get(worktreeId) === opts.at && !!this.d.state.worktree(worktreeId);
     let check = "none";
     let checkTail;
     const command = repo.config.check?.trim();
@@ -25434,7 +25921,10 @@ class LandingService {
       try {
         verdict = await this.d.judge(wt, prompt);
       } catch (e) {
-        log.warn(worktreeId, "landing verdict failed", e);
+        if (!live())
+          return;
+        log.warn(worktreeId, "landing verdict unanswered; no verdict written", e);
+        return this.clear(worktreeId);
       }
       if (!live())
         return;
@@ -25597,7 +26087,7 @@ async function mergedBranches(repoPath, defaultBr) {
 }
 
 // ../daemon/src/worktrees/discover.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { basename as basename5 } from "path";
 
 // ../daemon/src/git/worktrees.ts
@@ -25666,7 +26156,7 @@ async function listWorktrees(repoPath) {
 
 // ../daemon/src/worktrees/discover.ts
 function discoveredId(path) {
-  return `disc-${createHash2("sha1").update(canonical(path)).digest("hex").slice(0, 12)}`;
+  return `disc-${createHash3("sha1").update(canonical(path)).digest("hex").slice(0, 12)}`;
 }
 function knownPaths(known) {
   const paths = new Set;
@@ -25849,12 +26339,15 @@ function rankRefs({ refs, merged, prs, query, defaultBranch, rowIdForPath }) {
 }
 
 // ../daemon/src/worktrees/service.ts
-import { cpSync, existsSync as existsSync26, readFileSync as readFileSync16, rmSync as rmSync5 } from "fs";
+import { cpSync, existsSync as existsSync26, readFileSync as readFileSync17, rmSync as rmSync5 } from "fs";
+import { rm as rm2 } from "fs/promises";
 import { dirname as dirname9, join as join23 } from "path";
 
 // ../daemon/src/git/archive.ts
 import { rmSync as rmSync3 } from "fs";
 var archiveRef = (worktreeId) => `refs/toyon/archive/${worktreeId}`;
+var SNAPSHOT_SUBJECT = "toyon: uncommitted work";
+var SNAPSHOT_AUTHOR = "toyon";
 async function keepState(repoPath, wtPath, ref, indexFile) {
   const head = await git(wtPath, "rev-parse", "--verify", "HEAD");
   if (!head.ok)
@@ -25882,7 +26375,7 @@ async function snapshotCommit(wtPath, head, indexFile) {
       return null;
     const commit = await run(GIT, [
       "-c",
-      "user.name=toyon",
+      `user.name=${SNAPSHOT_AUTHOR}`,
       "-c",
       "user.email=toyon@localhost",
       "commit-tree",
@@ -25890,13 +26383,29 @@ async function snapshotCommit(wtPath, head, indexFile) {
       "-p",
       head,
       "-m",
-      "toyon: uncommitted work"
+      SNAPSHOT_SUBJECT
     ], wtPath);
     return commit.ok ? commit.out : null;
   } finally {
     rmSync3(indexFile, { force: true });
   }
 }
+async function keptAt(repoPath, ref) {
+  const r = await git(repoPath, "log", "-1", "--format=%H%n%P%n%an%n%s", ref);
+  if (!r.ok)
+    return null;
+  const [commit, parents, author, subject] = r.out.split(`
+`);
+  if (!commit)
+    return null;
+  const snapshot = subject === SNAPSHOT_SUBJECT && author === SNAPSHOT_AUTHOR && parents && !parents.includes(" ");
+  if (!snapshot)
+    return { head: commit };
+  const files = await git(repoPath, "diff", "--name-only", parents, commit);
+  const dirty = files.ok ? files.out.split(`
+`).filter(Boolean).length : 0;
+  return { head: parents, snapshot: commit, ...dirty ? { dirty } : {} };
+}
 async function checkOutKept(repoPath, wtPath, kept, branch) {
   await git(repoPath, "worktree", "prune");
   if (branch.create)
@@ -25956,16 +26465,27 @@ async function dropLandRefs(repoPath, worktreeId) {
 }
 
 // ../daemon/src/git/land.ts
-async function commitWorktree(worktreePath, message) {
+var STEP_TIMEOUT_MS = 10 * 60000;
+var stepRun = (cwd, args, onText, signal) => runWatched(GIT, args, cwd, { env: NO_PROMPT, onText, timeoutMs: STEP_TIMEOUT_MS, signal });
+var UNWATCHED = {
+  step() {},
+  git: (cwd, args) => stepRun(cwd, args)
+};
+function refused(what, r, n = 200) {
+  if (r.exit === "timeout") {
+    const minutes = Math.round(STEP_TIMEOUT_MS / 60000);
+    return `${what} gave up after ${minutes} minutes${r.shown ? "; what it printed is on the chat" : ""}`;
+  }
+  return `${what}: ${r.shown ? "what git and its hooks printed is on the chat" : r.err.slice(0, n)}`;
+}
+async function commitWorktree(worktreePath, message, w = UNWATCHED) {
   if ((await statusFiles(worktreePath)).length === 0)
     return { ok: false, message: "nothing to commit" };
   await git(worktreePath, "add", "-A");
-  const c = await git(worktreePath, "commit", "-m", message);
-  if (!c.ok) {
-    const output = [c.out, c.err].filter(Boolean).join(`
-`);
-    return { ok: false, message: `commit failed: ${c.err.slice(0, 200)}`, output, exit: c.exit };
-  }
+  w.step("committing");
+  const c = await w.git(worktreePath, ["commit", "-m", message]);
+  if (!c.ok)
+    return { ok: false, message: refused("commit refused", c) };
   return { ok: true, message: `committed: ${message}` };
 }
 async function requireClean(worktreePath) {
@@ -25984,7 +26504,7 @@ async function requireMainReady(repoPath, defaultBr) {
   }
   return null;
 }
-async function takeMainIn(worktreePath, defaultBr, own) {
+async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED) {
   const cErr = await requireClean(worktreePath);
   if (cErr)
     return cErr;
@@ -25992,26 +26512,27 @@ async function takeMainIn(worktreePath, defaultBr, own) {
   if (behind === 0)
     return { ok: true, message: `already up to date with ${defaultBr}` };
   if (own) {
-    const r = await git(worktreePath, "rebase", defaultBr);
+    w.step(`rebasing onto ${defaultBr}`);
+    const r = await w.git(worktreePath, ["rebase", defaultBr]);
     if (!r.ok) {
       await git(worktreePath, "rebase", "--abort");
-      const said = [r.out, r.err].filter(Boolean).join(`
-`);
+      const ask = `rebase onto ${defaultBr} conflicts: ask the agent to bring ${defaultBr} in and resolve them`;
       return {
         ok: false,
         conflict: true,
-        message: `rebase onto ${defaultBr} conflicts: ask the agent to bring ${defaultBr} in and resolve them (${said.slice(0, 200)})`
+        message: r.shown ? `${ask}; the conflicts are on the chat` : `${ask} (${r.text.slice(0, 200)})`
       };
     }
     return { ok: true, message: `rebased onto ${defaultBr}, ${behind} commit(s) behind before` };
   }
-  const m = await git(worktreePath, "merge", "--no-edit", defaultBr);
+  w.step(`merging ${defaultBr} in`);
+  const m = await w.git(worktreePath, ["merge", "--no-edit", defaultBr]);
   if (!m.ok) {
     return mergeFailure(worktreePath, m, `sync conflicts with ${defaultBr}: ask the agent to merge ${defaultBr} and resolve them`);
   }
   return { ok: true, message: `synced ${behind} commit(s) from ${defaultBr}` };
 }
-async function landLocally(worktreePath, branch, repoPath, defaultBr, method, message) {
+async function landLocally(worktreePath, branch, repoPath, defaultBr, method, message, w = UNWATCHED) {
   const cErr = await requireClean(worktreePath);
   if (cErr)
     return cErr;
@@ -26022,25 +26543,28 @@ async function landLocally(worktreePath, branch, repoPath, defaultBr, method, me
   if (mErr)
     return mErr;
   if (method === "rebase") {
-    const ff = await git(repoPath, "merge", "--ff-only", branch);
+    w.step(`moving ${defaultBr} onto the branch`);
+    const ff = await w.git(repoPath, ["merge", "--ff-only", branch]);
     if (!ff.ok)
       return { ok: false, message: `${branch} is not a fast-forward of ${defaultBr}: take ${defaultBr} in first` };
     return { ok: true, message: `${defaultBr} moved onto ${branch}` };
   }
   if (method === "squash") {
-    const s = await git(repoPath, "merge", "--squash", branch);
+    w.step(`squashing onto ${defaultBr}`);
+    const s = await w.git(repoPath, ["merge", "--squash", branch]);
     if (!s.ok) {
       await git(repoPath, "reset", "--hard", "HEAD");
       return mergeFailure(repoPath, s, `merge conflicts with ${defaultBr}: take ${defaultBr} in first`);
     }
-    const c = await git(repoPath, "commit", "-m", message);
+    const c = await w.git(repoPath, ["commit", "-m", message]);
     if (!c.ok) {
       await git(repoPath, "reset", "--hard", "HEAD");
-      return { ok: false, message: `squash commit failed: ${c.err.slice(0, 200)}` };
+      return { ok: false, message: refused("squash commit refused", c) };
     }
     return { ok: true, message: `squashed ${branch} onto ${defaultBr}` };
   }
-  const m = await git(repoPath, "merge", "--no-ff", "--no-edit", branch);
+  w.step(`merging into ${defaultBr}`);
+  const m = await w.git(repoPath, ["merge", "--no-ff", "--no-edit", branch]);
   if (!m.ok)
     return mergeFailure(repoPath, m, `merge conflicts with ${defaultBr}: take ${defaultBr} in first`);
   return { ok: true, message: `merged ${branch} into ${defaultBr}` };
@@ -26057,20 +26581,21 @@ async function squashMessage(worktreePath, defaultBr, suggested) {
   const subjects = await git(worktreePath, "log", "--format=%s", `${defaultBr}..HEAD`);
   return subjects.out.trim() || "land";
 }
-async function pullMain(repoPath, defaultBr) {
+async function pullMain(repoPath, defaultBr, w = UNWATCHED) {
   const cErr = await requireClean(repoPath);
   if (cErr)
     return cErr;
-  return fastForwardMain(repoPath, defaultBr);
+  return fastForwardMain(repoPath, defaultBr, w);
 }
-async function fastForwardMain(repoPath, defaultBr) {
+async function fastForwardMain(repoPath, defaultBr, w = UNWATCHED) {
   const current = await git(repoPath, "branch", "--show-current");
   if (current.out !== defaultBr) {
     return { ok: false, message: `main checkout is on '${current.out}', not ${defaultBr}; switch it first` };
   }
-  const f = await run(GIT, ["fetch", "--quiet"], repoPath, NO_PROMPT);
+  w.step(`pulling ${defaultBr} from origin`);
+  const f = await w.git(repoPath, ["fetch", "--quiet"]);
   if (!f.ok)
-    return { ok: false, message: `fetch failed: ${f.err.slice(0, 200)}` };
+    return { ok: false, message: refused("fetch failed", f) };
   return fastForwardFetched(repoPath, defaultBr);
 }
 async function fastForwardFetched(repoPath, defaultBr) {
@@ -26103,45 +26628,77 @@ ${m.err}`);
   }
   return { ok: true, moved: true, message: `pulled ${behind} commit(s) from origin` };
 }
-async function pushMain(repoPath, defaultBr) {
-  const p = await run(GIT, ["push", "origin", defaultBr], repoPath, NO_PROMPT);
+async function pushMain(repoPath, defaultBr, w = UNWATCHED) {
+  w.step(`pushing ${defaultBr}`);
+  const p = await w.git(repoPath, ["push", "origin", defaultBr]);
   if (p.ok)
     return { ok: true, message: `pushed ${defaultBr} to origin` };
-  const moved = /rejected|fetch first|non-fast-forward/.test(p.err);
+  const moved = /\[rejected\]|fetch first|non-fast-forward/.test(p.err);
   return {
     ok: false,
-    message: moved ? `${defaultBr} on origin moved; pull ${defaultBr} and land again` : `push failed: ${p.err.slice(0, 300)}`
+    message: moved ? `${defaultBr} on origin moved; pull ${defaultBr} and land again` : refused("push failed", p, 300)
   };
 }
 async function mergeFailure(cwd, m, conflictMessage) {
-  const said = [m.out, m.err].filter(Boolean).join(`
-`);
-  const conflict = /CONFLICT|Automatic merge failed/.test(said);
+  const conflict = /CONFLICT|Automatic merge failed/.test(m.text);
   if (conflict) {
     await git(cwd, "merge", "--abort");
-    return { ok: false, conflict: true, message: `${conflictMessage} (${said.slice(0, 200)})` };
+    return {
+      ok: false,
+      conflict: true,
+      message: m.shown ? `${conflictMessage}; the conflicts are on the chat` : `${conflictMessage} (${m.text.slice(0, 200)})`
+    };
+  }
+  return {
+    ok: false,
+    message: m.shown ? "merge failed: what git printed is on the chat" : `merge failed: ${m.text.slice(0, 300)}`
+  };
+}
+async function fetchTrunk(worktreePath, defaultBr, w = UNWATCHED) {
+  const [remote, up] = await Promise.all([
+    git(worktreePath, "config", "--get", `branch.${defaultBr}.remote`),
+    git(worktreePath, "rev-parse", "--abbrev-ref", `${defaultBr}@{upstream}`)
+  ]);
+  if (!remote.ok || !remote.out || !up.ok || !up.out) {
+    return { ok: true, base: defaultBr, message: `${defaultBr} has no upstream` };
   }
-  return { ok: false, message: `merge failed: ${said.slice(0, 300)}` };
+  w.step(`fetching ${up.out}`);
+  const f = await w.git(worktreePath, ["fetch", "--quiet", remote.out, defaultBr]);
+  if (!f.ok)
+    return { ok: false, base: up.out, message: refused("fetch failed", f) };
+  return { ok: true, base: up.out, message: `fetched ${up.out}` };
 }
-async function pushBranch(worktreePath, branch) {
-  const push = await run(GIT, ["push", "-u", "--force-with-lease", "origin", branch], worktreePath, NO_PROMPT);
+async function pushBranch(worktreePath, branch, w = UNWATCHED) {
+  const args = ["push", "-u", "--force-with-lease", "origin", branch];
+  w.step(`pushing ${branch}`);
+  let push = await w.git(worktreePath, args);
+  if (!push.ok && /stale info/.test(push.err) && await goneFromOrigin(worktreePath, branch)) {
+    await git(worktreePath, "update-ref", "-d", `refs/remotes/origin/${branch}`);
+    push = await w.git(worktreePath, args);
+  }
   if (!push.ok)
-    return { ok: false, message: `push failed: ${push.err.slice(0, 300)}` };
+    return { ok: false, message: refused("push failed", push, 300) };
   return { ok: true, message: `pushed ${branch}` };
 }
-async function openPr(o) {
+async function goneFromOrigin(worktreePath, branch) {
+  const r = await run(GIT, ["ls-remote", "--exit-code", "--heads", "origin", branch], worktreePath, NO_PROMPT);
+  return !r.ok && r.exit === 2;
+}
+async function openPr(o, w = UNWATCHED) {
   const cErr = await requireClean(o.worktreePath);
   if (cErr)
     return cErr;
-  const { ahead } = await aheadBehind(o.worktreePath, o.defaultBr);
+  const base = o.base ?? o.defaultBr;
+  const { ahead } = await aheadBehind(o.worktreePath, base);
   if (ahead === 0)
-    return { ok: false, message: `nothing to ship: no commits ahead of ${o.defaultBr}` };
+    return { ok: false, message: `nothing to ship: no commits ahead of ${base}` };
   const remote = await git(o.worktreePath, "remote", "get-url", "origin");
   if (!remote.ok)
     return { ok: false, message: "no 'origin' remote: add one, or land by merging here" };
-  const push = await pushBranch(o.worktreePath, o.branch);
+  const push = await pushBranch(o.worktreePath, o.branch, w);
   if (!push.ok)
     return push;
+  w.step("opening the PR");
   const titled = o.subject ? ["--title", o.subject, "--body", o.body ?? ""] : ["--fill"];
   const created = await gh(["pr", "create", "--head", o.branch, "--base", o.defaultBr, ...titled], o.worktreePath);
   let url = null;
@@ -26174,7 +26731,8 @@ ${created.exit}`)) {
     pr: { number, url, state: "open", ...o.automerge ? { automerge: true } : {} }
   };
 }
-async function mergePr(worktreePath, number, wanted) {
+async function mergePr(worktreePath, number, wanted, w = UNWATCHED) {
+  w.step("merging the PR");
   const method = await ghMethod(worktreePath, wanted);
   if (!method)
     return { ok: false, message: "the repo allows no merge method gh can use" };
@@ -26191,7 +26749,7 @@ function compareUrl(remoteUrl, base, branch) {
 }
 
 // ../daemon/src/worktrees/archive.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync7, readdirSync as readdirSync7, readFileSync as readFileSync15, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync7, readdirSync as readdirSync7, readFileSync as readFileSync16, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
 import { basename as basename6, dirname as dirname8, join as join21 } from "path";
 class WorktreeArchive {
   dir;
@@ -26204,7 +26762,7 @@ class WorktreeArchive {
       if (!existsSync24(file))
         continue;
       try {
-        this.records.set(id, JSON.parse(readFileSync15(file, "utf8")));
+        this.records.set(id, JSON.parse(readFileSync16(file, "utf8")));
       } catch (e) {
         log.warn("archive", `skipped an unreadable record: ${file}`, e);
       }
@@ -26254,7 +26812,7 @@ class WorktreeArchive {
     if (!existsSync24(file))
       return null;
     try {
-      return readFileSync15(file, "utf8");
+      return readFileSync16(file, "utf8");
     } catch (e) {
       log.warn(id, `could not read its archived plan ${rel}`, e);
       return null;
@@ -26293,7 +26851,7 @@ function summarize(r, repoId, transcript) {
 function lastUsage(transcript) {
   if (!existsSync24(transcript))
     return null;
-  const lines = readFileSync15(transcript, "utf8").split(`
+  const lines = readFileSync16(transcript, "utf8").split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
     if (!lines[i]?.includes('"usage"'))
@@ -26309,7 +26867,7 @@ function lastUsage(transcript) {
 function firstPrompt(transcript) {
   if (!existsSync24(transcript))
     return;
-  for (const line of readFileSync15(transcript, "utf8").split(`
+  for (const line of readFileSync16(transcript, "utf8").split(`
 `)) {
     if (!line.includes('"user-message"'))
       continue;
@@ -26541,8 +27099,10 @@ class SparePool {
         this.d.state.save();
         for (const cmd of repo.config.setup ?? []) {
           const tail = [];
-          const code = await runSetup(cmd, wt.path, (line) => {
-            tail.push(line);
+          const code = await runSetup(cmd, wt.path, (line, retract) => {
+            tail.splice(Math.max(0, tail.length - retract), retract);
+            if (line)
+              tail.push(line);
             if (tail.length > 20)
               tail.shift();
           }, worktreeEnv(wt, repo));
@@ -26770,6 +27330,15 @@ 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";
+async function deleteTree(path) {
+  try {
+    await rm2(path, { recursive: true, force: true });
+    return true;
+  } catch (e) {
+    log.warn("rm", `could not delete ${path}`, e);
+    return false;
+  }
+}
 function withoutAttachments(event) {
   if (event.type !== "user-message")
     return event;
@@ -26783,16 +27352,20 @@ function withCarry(context, c) {
   const line = c.moved ? `This worktree started with ${files} the person moved here from ${c.branch} by hand. They are part of the task, not something to clean up.` : `${c.branch} has ${files} the person chose to leave there. This worktree does not have them.`;
   return [...context ?? [], line];
 }
+var commandLine = (args) => args.map((a) => /^[\w./:=@,+-]+$/.test(a) ? a : JSON.stringify(a.split(`
+`, 1)[0])).join(" ");
 
 class WorktreeService {
   d;
   spare;
+  ops = new Map;
   trunk;
   archive;
   archiving = new Map;
   going = new Set;
   countsCache = new Map;
   handChecked = new Map;
+  naming = new Set;
   discoverCache = new Map;
   usage = new Map;
   constructor(d) {
@@ -26842,6 +27415,12 @@ class WorktreeService {
     });
     d.hub.on("turnSettled", (worktreeId, turn) => {
       this.countsCache.delete(worktreeId);
+      if (turn.end === "done") {
+        const wt = d.state.worktree(worktreeId);
+        const prompt = wt?.unnamed ? firstAskOf(d.runtime.agentFor(worktreeId)?.transcript() ?? []) : undefined;
+        if (wt && prompt)
+          this.scheduleNaming(wt, prompt, wt.variant);
+      }
       if (turn.end !== "done" && turn.end !== "stopped")
         return;
       for (const p of d.runtime.get(worktreeId)?.procs?.states() ?? []) {
@@ -27139,16 +27718,13 @@ class WorktreeService {
   scheduleNaming(wt, prompt, variant) {
     if (!prompt.trim())
       return;
-    if (!variant) {
-      fireAndForget(wt.id, (this.d.namer ?? makeNamer(this.d.runtime))(prompt, wt).then((name) => {
-        if (name)
-          return this.rename(wt.id, name);
-      }), "auto-naming");
+    if (variant && variant.index !== 1)
       return;
-    }
-    if (variant.index !== 1)
+    if (this.naming.has(wt.id))
       return;
-    fireAndForget(wt.id, (this.d.namer ?? makeNamer(this.d.runtime))(prompt, wt).then(async (name) => {
+    this.naming.add(wt.id);
+    const asked = (this.d.namer ?? makeNamer(this.d.runtime))(prompt, wt);
+    const applied = variant ? asked.then(async (name) => {
       if (!name)
         return;
       for (const sibling of [wt, ...siblingsOf(wt, this.d.state.worktrees)]) {
@@ -27156,7 +27732,11 @@ class WorktreeService {
           log.warn(sibling.id, "variant rename failed", e);
         });
       }
-    }), "auto-naming");
+    }) : asked.then((name) => {
+      if (name)
+        return this.rename(wt.id, name);
+    });
+    fireAndForget(wt.id, applied.finally(() => this.naming.delete(wt.id)), "auto-naming");
   }
   archiveWorktree(worktreeId, opts = {}) {
     const running = this.archiving.get(worktreeId);
@@ -27198,7 +27778,7 @@ class WorktreeService {
       if (archive)
         this.keepPlans(wt);
       try {
-        await gitOrThrow(repo.path, "worktree", "remove", "--force", wt.path);
+        await this.removeDirectory(repo, wt);
       } catch (e) {
         rmSync5(this.plansScratch(wt.id), { recursive: true, force: true });
         throw e;
@@ -27226,13 +27806,41 @@ class WorktreeService {
   }
   async keep(repo, wt) {
     const index = join23(this.d.paths.archiveDir, `${wt.id}.index`);
-    const kept = await keepState(repo.path, wt.path, archiveRef(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");
     else if (kept.lost)
       log.warn(wt.id, "could not keep its uncommitted changes: only its commits are archived");
     return kept;
   }
+  async keepUnlinked(repo, wt) {
+    if (await this.listed(repo, wt))
+      return null;
+    const ref = archiveRef(wt.id);
+    const already = await keptAt(repo.path, ref);
+    if (already)
+      return already;
+    const head = await commitOf(repo.path, `refs/heads/${wt.branch}`);
+    if (!head || !(await git(repo.path, "update-ref", ref, head)).ok)
+      return null;
+    return { head };
+  }
+  async listed(repo, wt) {
+    const path = canonical(wt.path);
+    return (await listWorktrees(repo.path)).some((g) => canonical(g.path) === path);
+  }
+  async removeDirectory(repo, wt) {
+    const r = await git(repo.path, "worktree", "remove", "--force", wt.path);
+    if (r.ok)
+      return;
+    if (await this.listed(repo, wt))
+      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], dirname9(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 join23(this.d.paths.archiveDir, `${worktreeId}.plans`);
   }
@@ -27536,7 +28144,7 @@ class WorktreeService {
     const src = join23(repo.path, ".gitignore");
     const tracked = existsSync26(src) && (await git(repo.path, "ls-files", "--", ".gitignore")).out !== "";
     const mirror = existsSync26(src) && !tracked;
-    const lines = mirror ? readFileSync16(src, "utf8").split(`
+    const lines = mirror ? readFileSync17(src, "utf8").split(`
 `).filter((l) => l.trim() !== "") : [];
     await excludeBlock(repo.path, BASE_IGNORE, lines);
   }
@@ -27570,7 +28178,7 @@ class WorktreeService {
         log.warn(wt.id, `could not copy ${f}`, r.err);
     }
     for (const cmd of setupCommands ? repo.config.setup ?? [] : []) {
-      const code = await runSetup(cmd, wt.path, (line) => this.d.hub.emit("log", wt.id, "setup", line), worktreeEnv(wt, repo));
+      const code = await runSetup(cmd, wt.path, (line, retract) => this.d.hub.emit("log", wt.id, "setup", line, retract), worktreeEnv(wt, repo));
       if (code !== 0)
         this.d.hub.emit("log", wt.id, "setup", `setup failed (exit ${code}): ${cmd}`);
     }
@@ -27631,23 +28239,29 @@ ${wt.landing.body}` : s;
     return this.commitRecorded(wt, this.commitMessage(wt, typed));
   }
   async commitRecorded(wt, message) {
-    const result = await commitWorktree(wt.path, message);
+    const result = await commitWorktree(wt.path, message, this.landWatch(wt));
     if (result.ok) {
       await this.verdictSurvives(wt, { dropMessage: true });
       this.headMoved(wt.id);
-      return result;
-    }
-    if (!result.output?.trim() || !this.d.record)
-      return result;
-    const subject = message.split(`
-`, 1)[0] ?? "";
-    try {
-      this.d.record(wt.id, `git commit -m ${JSON.stringify(subject)}`, result.output, result.exit ?? null);
-    } catch (e) {
-      log.warn(wt.id, `could not put the refused commit on the transcript: ${e instanceof Error ? e.message : e}`);
-      return result;
     }
-    return { ...result, message: "commit refused: what git and its hooks printed is on the chat" };
+    return result;
+  }
+  landWatch(wt) {
+    return {
+      step: (name) => this.step(wt.id, name),
+      git: async (cwd, args) => {
+        const where = cwd === wt.path ? "git" : `git -C ${cwd}`;
+        const run = (onText, signal) => stepRun(cwd, args, onText, signal);
+        if (!this.d.watch)
+          return run(() => {});
+        try {
+          return await this.d.watch(wt.id, `${where} ${commandLine(args)}`, run);
+        } catch (e) {
+          log.warn(wt.id, `landing step runs unwatched: ${e instanceof Error ? e.message : e}`);
+          return run(() => {});
+        }
+      }
+    };
   }
   async verdictSurvives(wt, opts) {
     const l = wt.landing;
@@ -27667,25 +28281,62 @@ ${wt.landing.body}` : s;
   }
   async land(worktreeId, message) {
     const { wt, repo } = this.landable(worktreeId, "land");
+    return this.ship(wt.id, "land", () => this.landOp(wt, repo, message));
+  }
+  shippingOf(id) {
+    return this.ops.get(id);
+  }
+  async ship(id, op, run) {
+    const out = this.ops.get(id);
+    if (out)
+      throw new UserError(`${shipNoun(out.op)} is already running here`);
+    const release = this.d.runtime.agentFor(id)?.hold();
+    this.ops.set(id, { op });
+    this.d.hub.emit("worktreesChanged");
+    try {
+      return await run();
+    } finally {
+      this.ops.delete(id);
+      release?.();
+      this.d.hub.emit("worktreesChanged");
+    }
+  }
+  step(id, name) {
+    const out = this.ops.get(id);
+    if (!out || out.step === name)
+      return;
+    out.step = name;
+    this.d.hub.emit("worktreesChanged");
+  }
+  async landOp(wt, repo, message) {
     const policy = landPolicy(repo.config);
     const own = hasOwnBranch(wt);
+    const w = this.landWatch(wt);
     const suggested = wt.landing?.subject ? wt.landing.body ? `${wt.landing.subject}
 
 ${wt.landing.body}` : wt.landing.subject : undefined;
     if (policy.land === "pr") {
+      if (wt.pr?.state === "merged" && !wt.landed) {
+        const r = await this.prMergedOp(wt.id, undefined, w);
+        return { result: r.ok ? r : { ...r, message: `PR #${wt.pr.number} merged, but ${r.message}` } };
+      }
+      const trunk = await fetchTrunk(wt.path, repo.defaultBranch, w);
+      if (!trunk.ok)
+        return { result: trunk };
+      const base = trunk.base;
       if (wt.pr?.state === "open") {
         const dirty = (await statusFiles(wt.path)).length > 0;
         const missing = dirty || (await aheadUpstream(wt.path) ?? 0) > 0;
         if (!missing)
-          return { result: await mergePr(wt.path, wt.pr.number, policy.merge) };
+          return { result: await mergePr(wt.path, wt.pr.number, policy.merge, w) };
         const committed = await this.commitIfDirty(wt, message);
         if (committed && !committed.ok)
           return { result: committed };
-        const taken = await takeMainIn(wt.path, repo.defaultBranch, own);
+        const taken = await takeMainIn(wt.path, base, own, w);
         if (!taken.ok)
           return { result: taken };
         this.headMoved(wt.id);
-        const pushed = await pushBranch(wt.path, wt.branch);
+        const pushed = await pushBranch(wt.path, wt.branch, w);
         if (!pushed.ok)
           return { result: pushed };
         this.headMoved(wt.id);
@@ -27696,19 +28347,26 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       const committed = await this.commitIfDirty(wt, message);
       if (committed && !committed.ok)
         return { result: committed };
-      const taken = await takeMainIn(wt.path, repo.defaultBranch, own);
+      const mark = await landingMark(wt.path, repo.defaultBranch);
+      const taken = await takeMainIn(wt.path, base, own, w);
       if (!taken.ok)
         return { result: taken };
       this.headMoved(wt.id);
+      if ((await aheadBehind(wt.path, base)).ahead === 0) {
+        const r = await this.prMergedOp(wt.id, mark, w);
+        const on = `origin's ${repo.defaultBranch} has this work already`;
+        return { result: { ...r, message: r.ok ? `${on}; ${r.message}` : `${on}, but ${r.message}` } };
+      }
       const result = await openPr({
         worktreePath: wt.path,
         branch: wt.branch,
         defaultBr: repo.defaultBranch,
+        base,
         subject: wt.landing?.subject,
         body: wt.landing?.body,
         automerge: policy.automerge,
         method: policy.merge
-      });
+      }, w);
       if (result.ok) {
         this.setLanding(wt.id, undefined);
         if (result.pr)
@@ -27724,24 +28382,24 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         return committed;
       committedHere = committed !== null;
       if (policy.land === "push") {
-        const pulled = await fastForwardMain(repo.path, repo.defaultBranch);
+        const pulled = await fastForwardMain(repo.path, repo.defaultBranch, w);
         if (!pulled.ok && !/no upstream/.test(pulled.message))
           return pulled;
       }
-      const taken = await takeMainIn(wt.path, repo.defaultBranch, own);
+      const taken = await takeMainIn(wt.path, repo.defaultBranch, own, w);
       if (!taken.ok)
         return taken;
       const mark = await landingMark(wt.path, repo.defaultBranch);
       const method = policy.merge ?? DEFAULT_MERGE_METHOD;
       const squash = method === "squash" ? await squashMessage(wt.path, repo.defaultBranch, suggested) : "";
-      const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash);
+      const landed = await landLocally(wt.path, wt.branch, repo.path, repo.defaultBranch, method, squash, w);
       if (!landed.ok)
         return landed;
       mergedHere = true;
       await this.noteLand(repo, wt, mark);
       await this.restartFromMain(wt, repo.defaultBranch);
       if (policy.land === "push") {
-        const pushed = await pushMain(repo.path, repo.defaultBranch);
+        const pushed = await pushMain(repo.path, repo.defaultBranch, w);
         if (!pushed.ok)
           return { ...pushed, message: `merged into ${repo.defaultBranch} here, but ${pushed.message}` };
       }
@@ -27780,10 +28438,16 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     this.headMoved(wt.id);
   }
   async prMerged(worktreeId) {
+    const out = this.ops.get(worktreeId);
+    if (out)
+      return { ok: false, message: `${shipNoun(out.op)} is already running here` };
+    return this.ship(worktreeId, "land", () => this.prMergedOp(worktreeId));
+  }
+  async prMergedOp(worktreeId, carried, w = UNWATCHED) {
     const { wt, repo } = this.d.state.requireWorktreeWithRepo(worktreeId);
     const result = await withRepoLock(repo.path, async () => {
-      const mark = await landingMark(wt.path, repo.defaultBranch);
-      const pulled = await fastForwardMain(repo.path, repo.defaultBranch);
+      const mark = carried === undefined ? await landingMark(wt.path, repo.defaultBranch) : carried;
+      const pulled = await fastForwardMain(repo.path, repo.defaultBranch, w);
       if (!pulled.ok)
         return pulled;
       await this.noteLand(repo, wt, mark);
@@ -27811,12 +28475,16 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       throw new UserError(`${r.name} is held by another tool`);
     const repo = this.d.state.requireRepo(r.repoId);
     const own = r.wt ? hasOwnBranch(r.wt) : false;
-    const result = await withRepoLock(repo.path, () => takeMainIn(r.path, repo.defaultBranch, own));
-    if (result.ok) {
-      this.headMoved(worktreeId);
-      if (r.wt)
-        await this.verdictSurvives(r.wt, { dropMessage: false });
-    }
+    const w = r.wt ? this.landWatch(r.wt) : UNWATCHED;
+    const result = await this.ship(worktreeId, "sync-main", async () => {
+      const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, repo.defaultBranch, own, w));
+      if (taken.ok) {
+        this.headMoved(worktreeId);
+        if (r.wt)
+          await this.verdictSurvives(r.wt, { dropMessage: false });
+      }
+      return taken;
+    });
     return { result, defaultBranch: repo.defaultBranch };
   }
   async pull(worktreeId) {
@@ -27824,19 +28492,22 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     if (!isMain(wt))
       throw new UserError("pull on main; a worktree syncs from main instead");
     const repo = this.d.state.requireRepo(wt.repoId);
-    const result = await withRepoLock(repo.path, () => pullMain(repo.path, repo.defaultBranch));
-    if (result.ok) {
-      this.invalidateCounts();
-      this.headMoved(worktreeId);
-    }
-    return result;
+    const w = { step: (name) => this.step(worktreeId, name), git: UNWATCHED.git };
+    return this.ship(worktreeId, "pull-main", async () => {
+      const result = await withRepoLock(repo.path, () => pullMain(repo.path, repo.defaultBranch, w));
+      if (result.ok) {
+        this.invalidateCounts();
+        this.headMoved(worktreeId);
+      }
+      return result;
+    });
   }
   async commit(worktreeId, message) {
     const wt = this.d.state.requireWorktree(worktreeId);
     const m = message.trim();
     if (!m)
       throw new UserError("commit message required");
-    return this.commitRecorded(wt, m);
+    return this.ship(wt.id, "commit", () => this.commitRecorded(wt, m));
   }
   setEmpty(wt, empty) {
     if (wt.empty === empty)
@@ -27848,8 +28519,14 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
   syncTrunk(repoId) {
     return this.trunk.sync(repoId);
   }
-  trunks(opts = {}) {
-    return this.trunk.all(opts);
+  async trunks(opts = {}) {
+    const all = await this.trunk.all(opts);
+    for (const t of Object.values(all)) {
+      const shipping = this.ops.get(t.id);
+      if (shipping)
+        t.shipping = shipping;
+    }
+    return all;
   }
   usageFor(worktreeId) {
     const known = this.usage.get(worktreeId);
@@ -28112,7 +28789,8 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         unseen: isUnseen(wt) || undefined,
         usage: this.usageFor(wt.id),
         transcript: transcriptPathFor(this.d.paths.transcriptsDir, wt.id),
-        sessionId: this.d.state.session(wt.id)
+        sessionId: this.d.state.session(wt.id),
+        shipping: this.ops.get(wt.id)
       };
     }));
   }
@@ -28121,7 +28799,16 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
     return Promise.all(found.map(async (f) => {
       const repo = this.d.state.repo(f.repoId);
       const { ahead, behind, dirty } = !repo ? {} : quick ? this.countsQuick(f.id, quick) : await this.counts(f.id, f.path, repo.defaultBranch, !!f.branch);
-      return { ...f, procs: [], agent: "idle", login: false, ahead, behind, dirty };
+      return {
+        ...f,
+        procs: [],
+        agent: "idle",
+        login: false,
+        ahead,
+        behind,
+        dirty,
+        shipping: this.ops.get(f.id)
+      };
     }));
   }
 }
@@ -28227,11 +28914,12 @@ var {
 var pruned = pruneAssets(SHELL_DIST);
 if (pruned > 0)
   log.debug("daemon", `pruned ${pruned} assets from builds this one has outlived`);
+var managed = await loadManaged();
 var paths = makePaths();
 ensureDirs(paths);
 var token = loadOrCreateToken(paths);
 var port = Number(process.env.TOYON_PORT ?? DAEMON_DEFAULT_PORT);
-var remote = loadRemote(paths.remoteFile);
+var remote = loadRemote(paths.remoteFile, process.env, managed.policy);
 if (remote && addressedByPort(remote.previews))
   pinProxyPorts(PREVIEW_PORTS);
 var state = new StateStore(paths);
@@ -28239,7 +28927,9 @@ var hub = new Hub;
 var bridge = new BridgeScript(BRIDGE_JS);
 var linuxSandbox = new LinuxSandbox;
 await linuxSandbox.refresh();
-var agents = loadAgentRegistry(paths.agentsFile, paths.agentsDir, linuxSandbox);
+var agents = loadAgentRegistry(paths.agentsFile, paths.agentsDir, linuxSandbox, managed.policy);
+if (state.defaultAgent !== undefined && !agents.get(state.defaultAgent))
+  state.clearDefaultAgent();
 var probe = new OptionProbe({
   infos: () => agents.infos(),
   require: (id) => agents.require(id),
@@ -28266,6 +28956,7 @@ var runtime = new RuntimeRegistry({
   state,
   paths,
   agents,
+  managed: managed.policy,
   accounts,
   attachments: attachments2,
   bridgeScript: () => bridge.get(),
@@ -28276,7 +28967,7 @@ var runtime = new RuntimeRegistry({
   mainLeads: (repoId) => worktrees.spare.current(repoId) === null
 });
 var drafts = new DraftStore({ file: paths.draftsFile, hub });
-var exec = new ExecService({ state, runtime });
+var exec = new ExecService({ state, runtime, shipping: (id) => worktrees.shippingOf(id) });
 var worktrees = new WorktreeService({
   state,
   hub,
@@ -28284,7 +28975,7 @@ var worktrees = new WorktreeService({
   paths,
   agents,
   drafts,
-  record: (id, command, text, exit) => exec.record(id, command, text, exit)
+  watch: (id, command, run) => exec.watch(id, command, run)
 });
 var turns = new TurnService({
   state,
@@ -28359,7 +29050,7 @@ var update = new UpdateService({
   command: (version) => installCommand(method, version),
   install: runInstall,
   busy: () => runtime.anyBusy(),
-  managed: process.env.TOYON_UPDATES === "off"
+  managedBy: !managed.policy.updates ? "policy" : process.env.TOYON_UPDATES === "off" ? "env" : null
 });
 var { branded, stop: stopServer } = startServer({
   port,
@@ -28368,6 +29059,7 @@ var { branded, stop: stopServer } = startServer({
   version: package_default.version,
   noteShellOrigin: (origin) => bridge.learnShellOrigin(origin),
   remote,
+  managed,
   services: {
     state,
     hub,
@@ -28415,6 +29107,7 @@ await runtime.reclaimOrphans();
 await repos.boot();
 drafts.prune((id) => !!state.worktree(id) || worktrees.hasArchived(id));
 idle.boot();
+landing.boot();
 fireAndForget("agents", agents.installMissing().then(() => probe.missing()), "agent adapter install");
 var repoArg = process.argv[2];
 if (repoArg) {
@@ -28438,6 +29131,12 @@ if (remote?.front === "edge") {
     console.log("         the token grants a shell on this machine; keep the link to yourself");
   }
 }
+for (const src of managed.sources) {
+  if (src.state === "absent")
+    continue;
+  const what = src.state === "applied" ? describeManaged(managed.policy).join(", ") || "nothing turned off" : `${src.problem}; everything it governs is off`;
+  console.log(`         policy: ${src.path}: ${what}`);
+}
 var shuttingDown = false;
 async function shutdown(signal, opts = {}) {
   if (shuttingDown)
@@ -28445,6 +29144,7 @@ async function shutdown(signal, opts = {}) {
   shuttingDown = true;
   log.info("daemon", `${signal}: stopping dev servers`);
   idle.shutdown();
+  landing.stop();
   repos.stopWatchers();
   prs.stop();
   sweep.stop();