@band-app/server 0.47.0 → 0.48.1

package/dist/start-server.mjs

@@ -1329,7 +1329,7 @@ var require_sonic_boom = __commonJS({
     var kContentModeUtf8 = "utf8";
     var [major, minor] = (process.versions.node || "0.0").split(".").map(Number);
     var kCopyBuffer = major >= 22 && minor >= 7;
-    function openFile(file2, sonic) {
+    function openFile(file3, sonic) {
       sonic._opening = true;
       sonic._writing = true;
       sonic._asyncDrainScheduled = false;
@@ -1351,7 +1351,7 @@ var require_sonic_boom = __commonJS({
         }
         const reopening = sonic._reopening;
         sonic.fd = fd;
-        sonic.file = file2;
+        sonic.file = file3;
         sonic._reopening = false;
         sonic._opening = false;
         sonic._writing = false;
@@ -1373,20 +1373,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs3.mkdirSync(path2.dirname(file2), { recursive: true });
-          const fd = fs3.openSync(file2, flags, mode);
+          if (sonic.mkdir) fs3.mkdirSync(path2.dirname(file3), { recursive: true });
+          const fd = fs3.openSync(file3, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs3.mkdir(path2.dirname(file2), { recursive: true }, (err) => {
+        fs3.mkdir(path2.dirname(file3), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs3.open(file2, flags, mode, fileOpened);
+          fs3.open(file3, flags, mode, fileOpened);
         });
       } else {
-        fs3.open(file2, flags, mode, fileOpened);
+        fs3.open(file3, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -1692,13 +1692,13 @@ var require_sonic_boom = __commonJS({
       }
       this._actualWrite();
     }
-    SonicBoom.prototype.reopen = function(file2) {
+    SonicBoom.prototype.reopen = function(file3) {
       if (this.destroyed) {
         throw new Error("SonicBoom destroyed");
       }
       if (this._opening) {
         this.once("ready", () => {
-          this.reopen(file2);
+          this.reopen(file3);
         });
         return;
       }
@@ -1708,8 +1708,8 @@ var require_sonic_boom = __commonJS({
       if (!this.file) {
         throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
       }
-      if (file2) {
-        this.file = file2;
+      if (file3) {
+        this.file = file3;
       }
       this._reopening = true;
       if (this._writing) {
@@ -2326,7 +2326,7 @@ var require_thread_stream = __commonJS({
         }
         if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) {
           try {
-            writeSync(this);
+            writeSync2(this);
             this[kImpl].flushing = true;
           } catch (err) {
             destroy(this, err);
@@ -2336,7 +2336,7 @@ var require_thread_stream = __commonJS({
         this[kImpl].buf += data;
         if (this[kImpl].sync) {
           try {
-            writeSync(this);
+            writeSync2(this);
             return true;
           } catch (err) {
             destroy(this, err);
@@ -2382,7 +2382,7 @@ var require_thread_stream = __commonJS({
         if (this[kImpl].destroyed) {
           return;
         }
-        writeSync(this);
+        writeSync2(this);
         flushSync(this);
       }
       unref() {
@@ -2486,7 +2486,7 @@ var require_thread_stream = __commonJS({
         destroy(stream, err);
       }
     }
-    function writeSync(stream) {
+    function writeSync2(stream) {
       const cb = () => {
         if (stream[kImpl].ending) {
           end(stream);
@@ -2987,11 +2987,11 @@ var require_tools = __commonJS({
         }
       }
     }
-    function buildFormatters(level, bindings, log77) {
+    function buildFormatters(level, bindings, log78) {
       return {
         level,
         bindings,
-        log: log77
+        log: log78
       };
     }
     function normalizeDestFileDescriptor(destination) {
@@ -3374,11 +3374,11 @@ var require_proto = __commonJS({
         }
       } else instance[serializersSym] = serializers;
       if (options.hasOwnProperty("formatters")) {
-        const { level, bindings: chindings, log: log77 } = options.formatters;
+        const { level, bindings: chindings, log: log78 } = options.formatters;
         instance[formattersSym] = buildFormatters(
           level || formatters.level,
           chindings || resetChildingsFormatter,
-          log77 || formatters.log
+          log78 || formatters.log
         );
       } else {
         instance[formattersSym] = buildFormatters(
@@ -4447,16 +4447,109 @@ var require_pino = __commonJS({
 });
 
 // ../../packages/logger/src/index.ts
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync
+} from "node:fs";
+import { dirname } from "node:path";
+function logFile() {
+  if (file) return file;
+  const path2 = process.env.BAND_LOG_FILE;
+  if (!path2) return void 0;
+  const max2 = Number(process.env.BAND_LOG_MAX_BYTES);
+  const keep = Number(process.env.BAND_LOG_KEEP);
+  const target = new RotatingFile(
+    path2,
+    max2 > 0 ? max2 : DEFAULT_LOG_MAX_BYTES,
+    keep >= 1 ? keep : DEFAULT_LOG_KEEP
+  );
+  for (const stream of [process.stdout, process.stderr]) {
+    stream.write = ((chunk, ...rest) => {
+      target.write(chunk);
+      const cb = rest.find((r) => typeof r === "function");
+      cb?.();
+      return true;
+    });
+  }
+  file = target;
+  return target;
+}
 function createLogger(name4) {
-  return (0, import_pino.default)({
-    name: name4,
-    level: process.env.LOG_LEVEL || "info"
-  });
+  const options = { name: name4, level: process.env.LOG_LEVEL || "info" };
+  const target = logFile();
+  return target ? (0, import_pino.default)(options, { write: (line2) => target.write(line2) }) : (0, import_pino.default)(options);
 }
-var import_pino;
+var import_pino, DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_KEEP, RotatingFile, file;
 var init_src = __esm({
   "../../packages/logger/src/index.ts"() {
     import_pino = __toESM(require_pino(), 1);
+    DEFAULT_LOG_MAX_BYTES = 10 * 1024 * 1024;
+    DEFAULT_LOG_KEEP = 3;
+    RotatingFile = class {
+      constructor(path2, maxBytes = DEFAULT_LOG_MAX_BYTES, keep = DEFAULT_LOG_KEEP) {
+        this.path = path2;
+        this.maxBytes = maxBytes;
+        this.keep = keep;
+        mkdirSync(dirname(path2), { recursive: true });
+        if (existsSync(path2) && statSync(path2).size >= maxBytes) this.shift();
+        this.open();
+      }
+      fd;
+      size = 0;
+      write(chunk) {
+        const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        if (this.fd === void 0) return;
+        if (this.size > 0 && this.size + buf.length > this.maxBytes) {
+          this.close();
+          this.shift();
+          this.open();
+        }
+        if (this.fd === void 0) return;
+        try {
+          writeSync(this.fd, buf);
+          this.size += buf.length;
+        } catch {
+        }
+      }
+      close() {
+        if (this.fd === void 0) return;
+        try {
+          closeSync(this.fd);
+        } catch {
+        }
+        this.fd = void 0;
+      }
+      open() {
+        try {
+          this.fd = openSync(this.path, "a", 384);
+          this.size = statSync(this.path).size;
+        } catch {
+          this.fd = void 0;
+        }
+      }
+      shift() {
+        try {
+          const oldest = this.keep - 1;
+          if (oldest < 1) {
+            rmSync(this.path, { force: true });
+            return;
+          }
+          rmSync(`${this.path}.${oldest}`, { force: true });
+          for (let i = oldest - 1; i >= 1; i--) {
+            if (existsSync(`${this.path}.${i}`))
+              renameSync(`${this.path}.${i}`, `${this.path}.${i + 1}`);
+          }
+          renameSync(this.path, `${this.path}.1`);
+        } catch {
+        }
+      }
+    };
   }
 });
 
@@ -4520,14 +4613,14 @@ import {
   chmodSync,
   linkSync,
   lstatSync,
-  mkdirSync,
-  renameSync,
-  statSync,
+  mkdirSync as mkdirSync2,
+  renameSync as renameSync2,
+  statSync as statSync2,
   unlinkSync
 } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname as dirname2, join } from "node:path";
 function ensurePrivateDir(dir) {
-  mkdirSync(dir, { recursive: true, mode: 448 });
+  mkdirSync2(dir, { recursive: true, mode: 448 });
   const stats = lstatSync(dir);
   const uid = process.getuid?.();
   if (!stats.isDirectory()) throw new Error(`${dir} is not a directory`);
@@ -4536,7 +4629,7 @@ function ensurePrivateDir(dir) {
 }
 function checkEndpointOwner(socketPath) {
   const uid = process.getuid?.();
-  const dir = dirname(socketPath);
+  const dir = dirname2(socketPath);
   let dirStats;
   try {
     dirStats = lstatSync(dir);
@@ -4584,7 +4677,7 @@ var init_endpoint = __esm({
 // ../../packages/host-local/src/terminals/daemon/protocol.ts
 import { createHash } from "node:crypto";
 import { readdirSync } from "node:fs";
-import { basename, dirname as dirname2, join as join2 } from "node:path";
+import { basename, dirname as dirname3, join as join2 } from "node:path";
 function daemonPaths(runDir, version2 = PROTOCOL_VERSION) {
   const inRunDir = join2(runDir, `terminal-daemon-v${version2}.sock`);
   const socket = Buffer.byteLength(inRunDir) <= MAX_SOCKET_PATH_BYTES ? inRunDir : join2(
@@ -4602,7 +4695,7 @@ function daemonPaths(runDir, version2 = PROTOCOL_VERSION) {
 function retiredDaemonPaths(paths, tag) {
   return {
     ...paths,
-    socket: join2(dirname2(paths.socket), `.r${tag}`),
+    socket: join2(dirname3(paths.socket), `.r${tag}`),
     token: paths.token.replace(/\.token$/, `.retired-${tag}.token`),
     pid: paths.pid.replace(/\.pid$/, `.retired-${tag}.pid`)
   };
@@ -4935,10 +5028,10 @@ var init_client = __esm({
 
 // ../../packages/host-local/src/terminals/daemon/exit-records.ts
 import {
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
   readFileSync,
-  renameSync as renameSync2,
+  renameSync as renameSync3,
   unlinkSync as unlinkSync2,
   writeFileSync
 } from "node:fs";
@@ -4956,16 +5049,16 @@ function drainExitRecords(runDir) {
   }
   const events2 = [];
   for (const name4 of names) {
-    const file2 = join3(dir, name4);
+    const file3 = join3(dir, name4);
     try {
-      const event = JSON.parse(readFileSync(file2, "utf8"));
+      const event = JSON.parse(readFileSync(file3, "utf8"));
       if (typeof event.terminalId === "string" && typeof event.worktreeId === "string") {
         events2.push(event);
       }
     } catch {
     }
     try {
-      unlinkSync2(file2);
+      unlinkSync2(file3);
     } catch {
     }
   }
@@ -4981,15 +5074,15 @@ var init_exit_records = __esm({
 
 // ../../packages/host-local/src/terminals/daemon/launch.ts
 import { fork } from "node:child_process";
-import { closeSync, openSync, readFileSync as readFileSync2, renameSync as renameSync3, statSync as statSync2 } from "node:fs";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync2, renameSync as renameSync4, statSync as statSync3 } from "node:fs";
 async function launchDaemon(options) {
   const { entry, paths, cwd, buildId, supersede, recordExits, execArgv } = options;
   ensurePrivateDir(paths.runDir);
   rotateLog(paths.log);
-  const logFd = openSync(paths.log, "a", 384);
+  const logFd = openSync2(paths.log, "a", 384);
   let logSize = 0;
   try {
-    logSize = statSync2(paths.log).size;
+    logSize = statSync3(paths.log).size;
   } catch {
   }
   const child = (() => {
@@ -5005,7 +5098,7 @@ async function launchDaemon(options) {
         env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
       });
     } finally {
-      closeSync(logFd);
+      closeSync2(logFd);
     }
   })();
   child.on("error", () => {
@@ -5061,7 +5154,7 @@ async function retireOlderDaemons(runDir, buildId) {
 }
 function rotateLog(path2) {
   try {
-    if (statSync2(path2).size > LOG_ROTATE_BYTES) renameSync3(path2, `${path2}.1`);
+    if (statSync3(path2).size > LOG_ROTATE_BYTES) renameSync4(path2, `${path2}.1`);
   } catch {
   }
 }
@@ -5087,7 +5180,7 @@ var init_launch = __esm({
 });
 
 // ../../packages/host-local/src/terminals/daemon/daemon-backend.ts
-import { existsSync, lstatSync as lstatSync2, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync3 } from "node:fs";
 function sameEntry(a, b2) {
   return a === b2 || a !== null && b2 !== null && a.dev === b2.dev && a.ino === b2.ino;
 }
@@ -5540,7 +5633,7 @@ var init_daemon_backend = __esm({
         if (client2.buildId !== this.options.buildId) return false;
         const record3 = readPidRecord(this.paths.pid);
         if (record3?.pid !== client2.pid || record3.entry === void 0) return true;
-        return existsSync(record3.entry);
+        return existsSync2(record3.entry);
       }
       /** Stop starting sessions on `client`; keep using it for the ones it has. */
       demote(client2) {
@@ -5648,13 +5741,13 @@ var init_daemon_backend = __esm({
 
 // ../../packages/host-local/src/process/path.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { delimiter } from "node:path";
 function defaultShell() {
   if (process.env.SHELL) return process.env.SHELL;
   if (process.platform === "win32") return process.env.ComSpec || "cmd.exe";
   for (const candidate of ["/bin/zsh", "/bin/bash", "/bin/sh"]) {
-    if (existsSync2(candidate)) return candidate;
+    if (existsSync3(candidate)) return candidate;
   }
   return "/bin/sh";
 }
@@ -5665,7 +5758,7 @@ function extraBinDirs() {
   } else if (process.platform === "linux") {
     const dirs = [];
     const linuxbrew = "/home/linuxbrew/.linuxbrew/bin";
-    if (existsSync2(linuxbrew)) dirs.push(linuxbrew);
+    if (existsSync3(linuxbrew)) dirs.push(linuxbrew);
     dirs.push("/usr/local/bin");
     cachedBinDirs = dirs;
   } else {
@@ -5738,7 +5831,7 @@ var init_path = __esm({
 });
 
 // ../../packages/host-local/src/terminals/claude-resume.ts
-import { readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
 import { homedir } from "node:os";
 import { join as join4 } from "node:path";
 function isResumableClaudeCommand(command2) {
@@ -5761,7 +5854,7 @@ function findLatestClaudeSessionId(cwd) {
   for (const name4 of names) {
     let mtimeMs;
     try {
-      mtimeMs = statSync3(join4(dir, name4)).mtimeMs;
+      mtimeMs = statSync4(join4(dir, name4)).mtimeMs;
     } catch {
       continue;
     }
@@ -5818,7 +5911,7 @@ var init_pty_error_hints = __esm({
 });
 
 // ../../packages/host-local/src/terminals/terminal-history.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync4, rmSync } from "node:fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
 import { mkdir, rename, writeFile } from "node:fs/promises";
 import { join as join5 } from "node:path";
 function readJson(path2) {
@@ -5884,7 +5977,7 @@ var init_terminal_history = __esm({
       /** Drop a terminal's saved history: its tab or worktree was actually closed or deleted. */
       removeSession(terminalId) {
         try {
-          rmSync(this.sessionDir(terminalId), { recursive: true, force: true });
+          rmSync2(this.sessionDir(terminalId), { recursive: true, force: true });
         } catch (err) {
           log2.warn({ err, terminalId }, "failed to remove terminal history directory");
         }
@@ -5908,7 +6001,7 @@ var init_terminal_history = __esm({
           const meta = readJson(join5(dir, "meta.json"));
           if (meta?.worktreeId !== worktreeId4) continue;
           try {
-            rmSync(dir, { recursive: true, force: true });
+            rmSync2(dir, { recursive: true, force: true });
           } catch (err) {
             log2.warn({ err, dir }, "failed to remove terminal history directory");
           }
@@ -10405,7 +10498,7 @@ var require_addon_unicode11 = __commonJS({
 
 // ../../packages/host-local/src/terminals/terminal-pool.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join6, sep } from "node:path";
 function resolveSafeCwd(candidate, worktreeRoot, label2, original) {
@@ -10413,7 +10506,7 @@ function resolveSafeCwd(candidate, worktreeRoot, label2, original) {
     log3.warn("Ignoring %s %s \u2014 resolves outside worktree root %s", label2, original, worktreeRoot);
     return null;
   }
-  if (!existsSync3(candidate)) {
+  if (!existsSync4(candidate)) {
     log3.warn("Ignoring %s %s \u2014 directory does not exist", label2, original);
     return null;
   }
@@ -10574,10 +10667,10 @@ var init_terminal_pool = __esm({
             checkpoint.cwd
           ) ?? cwd;
         }
-        if (!existsSync3(cwd)) {
+        if (!existsSync4(cwd)) {
           throw new Error(`Worktree directory does not exist: ${cwd}`);
         }
-        if (!existsSync3(shell)) {
+        if (!existsSync4(shell)) {
           throw new Error(`Shell not found: ${shell}`);
         }
         log3.debug(
@@ -15807,6 +15900,15 @@ var init_wrapper = __esm({
   }
 });
 
+// ../../packages/shared/src/chat-events.ts
+var HISTORY_PAGE_SIZE, HISTORY_PAGE_MAX_ROWS;
+var init_chat_events = __esm({
+  "../../packages/shared/src/chat-events.ts"() {
+    HISTORY_PAGE_SIZE = 20;
+    HISTORY_PAGE_MAX_ROWS = 300;
+  }
+});
+
 // src/server/services/_utils/queued-message-store.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 function toWireQueuedMessages(messages) {
@@ -25752,28 +25854,28 @@ var init_to_json_schema = __esm({
               }
               case "file": {
                 const json3 = _json;
-                const file2 = {
+                const file3 = {
                   type: "string",
                   format: "binary",
                   contentEncoding: "binary"
                 };
                 const { minimum, maximum, mime } = schema._zod.bag;
                 if (minimum !== void 0)
-                  file2.minLength = minimum;
+                  file3.minLength = minimum;
                 if (maximum !== void 0)
-                  file2.maxLength = maximum;
+                  file3.maxLength = maximum;
                 if (mime) {
                   if (mime.length === 1) {
-                    file2.contentMediaType = mime[0];
-                    Object.assign(json3, file2);
+                    file3.contentMediaType = mime[0];
+                    Object.assign(json3, file3);
                   } else {
                     json3.anyOf = mime.map((m2) => {
-                      const mFile = { ...file2, contentMediaType: m2 };
+                      const mFile = { ...file3, contentMediaType: m2 };
                       return mFile;
                     });
                   }
                 } else {
-                  Object.assign(json3, file2);
+                  Object.assign(json3, file3);
                 }
                 break;
               }
@@ -26681,7 +26783,7 @@ function literal(value, params) {
     ...util_exports.normalizeParams(params)
   });
 }
-function file(params) {
+function file2(params) {
   return _file(ZodFile, params);
 }
 function transform(fn) {
@@ -27539,7 +27641,7 @@ __export(external_exports, {
   emoji: () => emoji2,
   endsWith: () => _endsWith,
   enum: () => _enum2,
-  file: () => file,
+  file: () => file2,
   flattenError: () => flattenError,
   float32: () => float32,
   float64: () => float64,
@@ -40205,7 +40307,7 @@ var init_node_sqlite = __esm({
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.1_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_better-sql_95478898f63cc8c3fbbd0c5f8c1e464f/node_modules/drizzle-orm/migrator.js
 import crypto2 from "node:crypto";
-import fs2, { existsSync as existsSync6, readdirSync as readdirSync6 } from "node:fs";
+import fs2, { existsSync as existsSync7, readdirSync as readdirSync6 } from "node:fs";
 import { join as join10 } from "node:path";
 function readMigrationFiles(config2) {
   if (fs2.existsSync(`${config2.migrationsFolder}/meta/_journal.json`)) throw Error('We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"');
@@ -40214,7 +40316,7 @@ function readMigrationFiles(config2) {
   const migrations = readdirSync6(migrationFolderTo).map((subdir) => ({
     path: join10(migrationFolderTo, subdir, "migration.sql"),
     name: subdir
-  })).filter((it) => existsSync6(it.path));
+  })).filter((it) => existsSync7(it.path));
   migrations.sort((a, b2) => a.name.localeCompare(b2.name));
   for (const migration of migrations) {
     const migrationPath = migration.path;
@@ -40253,9 +40355,9 @@ var init_migrator2 = __esm({
 
 // src/server/infra/db/queries/settings.ts
 import { randomBytes } from "node:crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync as renameSync4, statSync as statSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync5, statSync as statSync8, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join11 } from "node:path";
+import { dirname as dirname4, join as join11 } from "node:path";
 function bandHome() {
   if (process.env.BAND_HOME) return process.env.BAND_HOME;
   return join11(homedir2(), ".band");
@@ -40294,7 +40396,7 @@ var init_settings = __esm({
         const filePath = settingsFile();
         let mtimeMs;
         try {
-          mtimeMs = statSync7(filePath).mtimeMs;
+          mtimeMs = statSync8(filePath).mtimeMs;
         } catch {
           settingsCache.delete(filePath);
           return {};
@@ -40337,11 +40439,11 @@ var init_settings = __esm({
         const merged = { ...existing, ...patch };
         const data = `${JSON.stringify(merged, null, 2)}
 `;
-        const dir = dirname3(filePath);
-        mkdirSync3(dir, { recursive: true });
+        const dir = dirname4(filePath);
+        mkdirSync4(dir, { recursive: true });
         const tmpPath = `${filePath}.tmp.${process.pid}`;
         writeFileSync3(tmpPath, data, "utf-8");
-        renameSync4(tmpPath, filePath);
+        renameSync5(tmpPath, filePath);
         settingsCache.delete(filePath);
       }
       /**
@@ -41075,13 +41177,13 @@ var init_schema2 = __esm({
 });
 
 // src/server/infra/db/connection.ts
-import { mkdirSync as mkdirSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5 } from "node:fs";
 import { join as join12 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function getDb() {
   if (_db) return _db;
   const home = bandHome();
-  mkdirSync4(home, { recursive: true });
+  mkdirSync5(home, { recursive: true });
   const dbPath = join12(home, "band.db");
   _sqlite = new DatabaseSync2(dbPath);
   _sqlite.exec("PRAGMA journal_mode = WAL");
@@ -41147,9 +41249,10 @@ function indexFields(event) {
   };
 }
 var ChatEventQueries;
-var init_chat_events = __esm({
+var init_chat_events2 = __esm({
   "src/server/infra/db/queries/chat-events.ts"() {
     "use strict";
+    init_chat_events();
     init_drizzle_orm();
     init_connection();
     init_schema2();
@@ -41185,8 +41288,9 @@ var init_chat_events = __esm({
       }
       /**
        * The last `turns` turns before `beforeId` (the whole revision when
-       * `beforeId` is undefined), oldest first. `hasOlder` says whether rows
-       * exist before the returned window.
+       * `beforeId` is undefined), oldest first, shortened to the newest whole
+       * turns that fit `HISTORY_PAGE_MAX_ROWS` (the newest turn is always kept).
+       * `hasOlder` says whether rows exist before the returned window.
        */
       readTurns(sessionId, revision, turns, beforeId) {
         const db = getDb();
@@ -41196,7 +41300,18 @@ var init_chat_events = __esm({
           beforeId === void 0 ? void 0 : lt(chatEvents.id, beforeId)
         );
         const starts = db.select({ id: chatEvents.id }).from(chatEvents).where(and(scope3, eq(chatEvents.turnStart, true))).orderBy(desc(chatEvents.id)).limit(turns).all();
-        const from = starts.length < turns ? void 0 : starts[starts.length - 1].id;
+        let kept = starts.length;
+        if (starts.length > 1) {
+          const ids = db.select({ id: chatEvents.id }).from(chatEvents).where(and(scope3, sql`${chatEvents.id} >= ${starts[starts.length - 1].id}`)).orderBy(desc(chatEvents.id)).limit(HISTORY_PAGE_MAX_ROWS + 1).all().map((r) => r.id);
+          for (let i = 1; i < starts.length; i++) {
+            const count2 = ids.findIndex((id) => id < starts[i].id);
+            if ((count2 === -1 ? ids.length : count2) > HISTORY_PAGE_MAX_ROWS) {
+              kept = i;
+              break;
+            }
+          }
+        }
+        const from = kept === starts.length && starts.length < turns ? void 0 : starts[kept - 1]?.id;
         const rows = db.select().from(chatEvents).where(and(scope3, from === void 0 ? void 0 : sql`${chatEvents.id} >= ${from}`)).orderBy(chatEvents.id).all().map(toRow);
         if (from === void 0) return { rows, hasOlder: false };
         const older = db.select({ id: chatEvents.id }).from(chatEvents).where(
@@ -41411,16 +41526,63 @@ var init_cli_invocation = __esm({
 });
 
 // ../../packages/coding-agent/src/hook-status.ts
+function hasBackgroundWork(payload) {
+  const crons = payload.session_crons;
+  if (Array.isArray(crons) && crons.length > 0) return true;
+  const tasks3 = payload.background_tasks;
+  if (!Array.isArray(tasks3)) return false;
+  return tasks3.some((task) => {
+    if (typeof task !== "object" || task === null) return true;
+    const { type, status } = task;
+    if (typeof type === "string" && type.trim().toLowerCase() === "teammate") return false;
+    const state2 = typeof status === "string" ? status.trim().toLowerCase() : "";
+    return !TERMINAL_TASK_STATUSES.has(state2);
+  });
+}
 function mapClaudeCodeHookStatus(payload) {
   const hookEvent = typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
   const toolName2 = typeof payload.tool_name === "string" ? payload.tool_name : "";
-  if (hookEvent === "Stop") {
-    return "needs_attention";
+  switch (hookEvent) {
+    case "PermissionRequest":
+      return "question";
+    case "PreToolUse":
+      return CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName2) ? "question" : "working";
+    case "Stop":
+      return hasBackgroundWork(payload) ? "monitoring" : "done";
+    case "StopFailure":
+      return "failed";
+    case "PostCompact":
+      return payload.trigger === "manual" ? "done" : "working";
+    default:
+      return "working";
   }
-  if ((hookEvent === "PreToolUse" || hookEvent === "PermissionRequest") && CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName2)) {
-    return "needs_attention";
+}
+function foldSubagents(hold, payload, mapped) {
+  const hookEvent = typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
+  const agentId = typeof payload.agent_id === "string" ? payload.agent_id : "";
+  if (hookEvent === "SubagentStart") {
+    if (agentId) hold.running.add(agentId);
+    return hold.deferred ? "working" : mapped;
+  }
+  if (hookEvent === "SubagentStop") {
+    hold.running.delete(agentId);
+    if (hold.running.size === 0 && hold.deferred) {
+      const settled = hold.deferred;
+      hold.deferred = null;
+      return settled;
+    }
+    return mapped;
+  }
+  if ((hookEvent === "Stop" || hookEvent === "StopFailure") && !agentId) {
+    if (hold.running.size > 0 && (mapped === "done" || mapped === "monitoring")) {
+      hold.deferred = mapped;
+      return "working";
+    }
+    hold.deferred = null;
+    return mapped;
   }
-  return "working";
+  if (hookEvent === "UserPromptSubmit") hold.deferred = null;
+  return mapped;
 }
 async function mapHookPayloadToStatus(agentType, payload) {
   switch (agentType) {
@@ -41441,10 +41603,31 @@ function isHookSessionEnd(agentType, payload) {
 function hookSessionId(payload) {
   return typeof payload.session_id === "string" && payload.session_id ? payload.session_id : null;
 }
-var CLAUDE_CODE_INTERACTIVE_TOOLS;
+var CLAUDE_CODE_INTERACTIVE_TOOLS, TERMINAL_TASK_STATUSES;
 var init_hook_status = __esm({
   "../../packages/coding-agent/src/hook-status.ts"() {
     CLAUDE_CODE_INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+    TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
+      "idle",
+      "done",
+      "success",
+      "succeeded",
+      "complete",
+      "completed",
+      "finished",
+      "failed",
+      "error",
+      "terminated",
+      "exited",
+      "aborted",
+      "expired",
+      "skipped",
+      "crashed",
+      "killed",
+      "cancelled",
+      "canceled",
+      "timed_out"
+    ]);
   }
 });
 
@@ -41510,8 +41693,8 @@ var init_pricing = __esm({
 // ../../packages/coding-agent/src/usage/read-lines.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { createInterface } from "node:readline";
-async function* readLines(file2) {
-  const input = createReadStream2(file2);
+async function* readLines(file3) {
+  const input = createReadStream2(file3);
   const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
   try {
     for await (const line2 of rl) yield line2;
@@ -41568,10 +41751,10 @@ async function repoDirsFor(canonical) {
   }
   return dirs;
 }
-async function readSessionCwd(file2) {
+async function readSessionCwd(file3) {
   let handle;
   try {
-    handle = await open(file2, "r");
+    handle = await open(file3, "r");
     const buf = Buffer.alloc(SESSION_HEAD_BYTES);
     const { bytesRead } = await handle.read(buf, 0, SESSION_HEAD_BYTES, 0);
     if (bytesRead === 0) return null;
@@ -41617,13 +41800,13 @@ async function listSessions(dir) {
       if (!name4.endsWith(".jsonl")) return;
       const sessionId = name4.slice(0, -".jsonl".length);
       if (!SESSION_ID_RE.test(sessionId)) return;
-      const file2 = join14(repoDir, name4);
-      const cwd = await readSessionCwd(file2);
+      const file3 = join14(repoDir, name4);
+      const cwd = await readSessionCwd(file3);
       if (cwd === null) return;
       if (cwd !== void 0 && cwd !== dir && cwd !== canonical) return;
       let lastModified;
       try {
-        lastModified = (await stat(file2)).mtimeMs;
+        lastModified = (await stat(file3)).mtimeMs;
       } catch {
         return;
       }
@@ -41637,9 +41820,9 @@ async function listSessions(dir) {
 }
 async function findSessionFile(sessionId, dir) {
   for (const repoDir of await repoDirsFor(await canonicalDir(dir))) {
-    const file2 = join14(repoDir, `${sessionId}.jsonl`);
+    const file3 = join14(repoDir, `${sessionId}.jsonl`);
     try {
-      if ((await stat(file2)).size > 0) return file2;
+      if ((await stat(file3)).size > 0) return file3;
     } catch {
     }
   }
@@ -41647,15 +41830,15 @@ async function findSessionFile(sessionId, dir) {
 }
 async function getSessionUsage(sessionId, dir) {
   if (!SESSION_ID_RE.test(sessionId)) return null;
-  const file2 = await findSessionFile(sessionId, dir);
-  if (!file2) return null;
+  const file3 = await findSessionFile(sessionId, dir);
+  if (!file3) return null;
   const turns = [];
   const turnByMessageId = /* @__PURE__ */ new Map();
   let conversationRecords = 0;
   let startedAt = Number.POSITIVE_INFINITY;
   let updatedAt = 0;
   let modelFallback = "";
-  for await (const line2 of readLines(file2)) {
+  for await (const line2 of readLines(file3)) {
     if (!line2.trim()) continue;
     let record3;
     try {
@@ -41768,9 +41951,9 @@ async function findSessionFiles() {
   }
   return results;
 }
-async function readSessionMeta(file2) {
+async function readSessionMeta(file3) {
   let first;
-  for await (const line2 of readLines(file2)) {
+  for await (const line2 of readLines(file3)) {
     if (!line2.trim()) continue;
     first = line2;
     break;
@@ -41782,27 +41965,27 @@ async function readSessionMeta(file2) {
   }
   return void 0;
 }
-async function getSessionMeta(file2) {
-  const cached2 = metaCache.get(file2.path);
-  if (cached2 && cached2.mtimeMs === file2.mtimeMs) return cached2.meta;
+async function getSessionMeta(file3) {
+  const cached2 = metaCache.get(file3.path);
+  if (cached2 && cached2.mtimeMs === file3.mtimeMs) return cached2.meta;
   try {
-    const meta = await readSessionMeta(file2.path);
-    metaCache.set(file2.path, { mtimeMs: file2.mtimeMs, meta });
+    const meta = await readSessionMeta(file3.path);
+    metaCache.set(file3.path, { mtimeMs: file3.mtimeMs, meta });
     return meta;
   } catch (err) {
-    metaCache.set(file2.path, { mtimeMs: file2.mtimeMs, meta: void 0 });
+    metaCache.set(file3.path, { mtimeMs: file3.mtimeMs, meta: void 0 });
     throw err;
   }
 }
 async function listSessions2(dir) {
   const sessions = [];
-  for (const file2 of await findSessionFiles()) {
+  for (const file3 of await findSessionFiles()) {
     try {
-      const meta = await getSessionMeta(file2);
+      const meta = await getSessionMeta(file3);
       if (!meta || meta.cwd !== dir) continue;
-      sessions.push({ sessionId: meta.id, lastModified: file2.mtimeMs });
+      sessions.push({ sessionId: meta.id, lastModified: file3.mtimeMs });
     } catch (err) {
-      log7.debug({ err, file: file2.path }, "failed to parse codex session file");
+      log7.debug({ err, file: file3.path }, "failed to parse codex session file");
     }
   }
   return sessions.sort((a, b2) => b2.lastModified - a.lastModified);
@@ -42064,10 +42247,10 @@ var init_src3 = __esm({
 });
 
 // ../../packages/host-local/src/agents/acp-launch.ts
-import { accessSync, constants, existsSync as existsSync7, statSync as statSync8 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync8, statSync as statSync9 } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir as homedir6 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname4, join as join16, resolve as resolvePath } from "node:path";
+import { delimiter as delimiter2, dirname as dirname5, join as join16, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 function findOnPath(name4, path2, extra = []) {
   for (const dir of [...path2.split(delimiter2), ...extra]) {
@@ -42075,24 +42258,24 @@ function findOnPath(name4, path2, extra = []) {
     const candidate = join16(dir, name4);
     try {
       accessSync(candidate, constants.X_OK);
-      if (statSync8(candidate).isFile()) return candidate;
+      if (statSync9(candidate).isFile()) return candidate;
     } catch {
     }
   }
   return null;
 }
 function adapterScript(pkg, bundledName) {
-  const bundled = join16(dirname4(fileURLToPath(import.meta.url)), "agents", `${bundledName}.mjs`);
-  if (existsSync7(bundled)) return bundled;
-  return join16(dirname4(require2.resolve(`${pkg}/package.json`)), "dist", "index.js");
+  const bundled = join16(dirname5(fileURLToPath(import.meta.url)), "agents", `${bundledName}.mjs`);
+  if (existsSync8(bundled)) return bundled;
+  return join16(dirname5(require2.resolve(`${pkg}/package.json`)), "dist", "index.js");
 }
 function nodeFor(path2) {
   return findOnPath("node", path2) ?? process.execPath;
 }
-function isExecutableFile(file2) {
+function isExecutableFile(file3) {
   try {
-    accessSync(file2, constants.X_OK);
-    return statSync8(file2).isFile();
+    accessSync(file3, constants.X_OK);
+    return statSync9(file3).isFile();
   } catch {
     return false;
   }
@@ -42165,7 +42348,7 @@ var init_acp_launch = __esm({
 
 // ../../packages/host-local/src/agents/claude-defaults.ts
 import { execFile as execFile3 } from "node:child_process";
-import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync6, readSync, realpathSync as realpathSync2, statSync as statSync9 } from "node:fs";
+import { closeSync as closeSync3, openSync as openSync3, readFileSync as readFileSync6, readSync, realpathSync as realpathSync2, statSync as statSync10 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join17, resolve as resolvePath2 } from "node:path";
 function claudeConfigDir2(env) {
@@ -42258,16 +42441,16 @@ function transcriptPath(env, cwd, sessionId) {
 function readTail(path2, bytes) {
   let fd;
   try {
-    const size = statSync9(path2).size;
+    const size = statSync10(path2).size;
     const length = Math.min(size, bytes);
     const buf = Buffer.alloc(length);
-    fd = openSync2(path2, "r");
+    fd = openSync3(path2, "r");
     readSync(fd, buf, 0, length, size - length);
     return buf.toString("utf8");
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) closeSync2(fd);
+    if (fd !== void 0) closeSync3(fd);
   }
 }
 function reportedClaudeDefaults(opts) {
@@ -42368,113 +42551,225 @@ var init_claude_defaults = __esm({
 });
 
 // ../../packages/host-local/src/agents/hooks-install.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import {
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
+  realpathSync as realpathSync3,
+  renameSync as renameSync6,
+  statSync as statSync11,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync4
+} from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname5, join as join18 } from "node:path";
+import { dirname as dirname6, join as join18 } from "node:path";
 function claudeSettingsPath() {
   return join18(homedir8(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
+  let text3;
   try {
-    const data = readFileSync7(claudeSettingsPath(), "utf-8");
-    return JSON.parse(data);
+    text3 = readFileSync7(claudeSettingsPath(), "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { settings: {}, indent: 2, trailingNewline: false };
+    }
+    throw err;
+  }
+  if (text3.trim() === "") return { settings: {}, indent: 2, trailingNewline: false };
+  let parsed;
+  try {
+    parsed = JSON.parse(text3);
   } catch {
-    return {};
+    throw new Error(`${claudeSettingsPath()} is not valid JSON; fix it before installing hooks.`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `${claudeSettingsPath()} is not a JSON object; fix it before installing hooks.`
+    );
+  }
+  const indentMatch = /^([ \t]+)\S/m.exec(text3);
+  return {
+    settings: parsed,
+    indent: indentMatch ? indentMatch[1] : 2,
+    trailingNewline: text3.endsWith("\n")
+  };
+}
+function saveClaudeSettings({ settings: settings3, indent, trailingNewline }) {
+  let path2 = claudeSettingsPath();
+  mkdirSync6(dirname6(path2), { recursive: true });
+  let mode = 384;
+  try {
+    path2 = realpathSync3(path2);
+    mode = statSync11(path2).mode & 511;
+  } catch {
+  }
+  const temp = `${path2}.band-${process.pid}-${Date.now()}.tmp`;
+  try {
+    writeFileSync4(temp, JSON.stringify(settings3, null, indent) + (trailingNewline ? "\n" : ""), {
+      encoding: "utf-8",
+      mode,
+      flag: "wx"
+    });
+    renameSync6(temp, path2);
+  } catch (err) {
+    try {
+      unlinkSync4(temp);
+    } catch {
+    }
+    throw err;
   }
 }
 function isBandHook(command2) {
-  return command2.includes("band") && command2.includes("notify");
+  return BAND_NOTIFY.test(command2);
 }
-async function checkHooks() {
-  const settings3 = loadClaudeSettings();
+function isBandEntry(entry) {
+  const hooks = entry?.hooks;
+  return Array.isArray(hooks) && hooks.some(
+    (h) => h?.type === "command" && typeof h.command === "string" && isBandHook(h.command)
+  );
+}
+function isCurrentCommand(hook) {
+  const command2 = hook.command ?? "";
+  return command2.includes("--agent claude-code") && command2.includes(">/dev/null 2>&1") && command2.trimEnd().endsWith("|| true") && hook.async === true;
+}
+function hooksOf(settings3) {
   const hooks = settings3.hooks;
-  if (!hooks) {
-    return { installed: false, other_hooks_exist: false };
+  return hooks !== null && typeof hooks === "object" && !Array.isArray(hooks) ? hooks : {};
+}
+async function checkHooks() {
+  let settings3;
+  try {
+    settings3 = loadClaudeSettings().settings;
+  } catch {
+    return statusOf(0, 0, false);
   }
-  let bandHookCount = 0;
+  const hooks = hooksOf(settings3);
+  let current3 = 0;
+  let bandEvents = 0;
   let otherHookCount = 0;
-  for (const [, eventHooks] of Object.entries(hooks)) {
+  for (const [event, eventHooks] of Object.entries(hooks)) {
     if (!Array.isArray(eventHooks)) continue;
-    for (const hook of eventHooks) {
-      const h = hook;
-      if (!h.hooks || !Array.isArray(h.hooks)) continue;
-      for (const inner of h.hooks) {
-        if (inner.type === "command" && inner.command) {
-          if (isBandHook(inner.command)) {
-            bandHookCount++;
-          } else {
-            otherHookCount++;
-          }
+    let eventHasBand = false;
+    let eventIsCurrent = false;
+    for (const entry of eventHooks) {
+      const inner = entry?.hooks;
+      if (!Array.isArray(inner)) continue;
+      for (const h of inner) {
+        if (h?.type !== "command" || typeof h.command !== "string") continue;
+        if (isBandHook(h.command)) {
+          eventHasBand = true;
+          if (HOOK_EVENTS.includes(event) && isCurrentCommand(h)) eventIsCurrent = true;
+        } else {
+          otherHookCount++;
         }
       }
     }
+    if (eventHasBand) bandEvents++;
+    if (eventIsCurrent) current3++;
   }
+  return statusOf(bandEvents, current3, otherHookCount > 0);
+}
+function statusOf(bandEvents, currentEvents, otherHooksExist) {
+  const installed = currentEvents >= HOOK_EVENTS.length && bandEvents === currentEvents;
   return {
-    installed: bandHookCount >= HOOK_EVENTS.length,
-    other_hooks_exist: otherHookCount > 0
+    installed,
+    outdated: !installed && bandEvents > 0,
+    other_hooks_exist: otherHooksExist,
+    version: HOOKS_VERSION
   };
 }
-async function installHooks() {
-  let bandPath = null;
+function hookCommand(bandPath) {
+  return `"${bandPath}" notify --agent claude-code >/dev/null 2>&1 || true`;
+}
+async function findBand() {
   if (process.platform !== "win32") {
     try {
       await import("node:fs/promises").then((m2) => m2.stat("/usr/local/bin/band"));
-      bandPath = "/usr/local/bin/band";
+      return "/usr/local/bin/band";
     } catch {
     }
   }
-  if (!bandPath) {
-    bandPath = await whichBinary("band");
-  }
-  if (!bandPath) {
-    throw new Error("Could not find band CLI binary. Please install it first.");
-  }
-  const settingsPath = claudeSettingsPath();
-  mkdirSync5(dirname5(settingsPath), { recursive: true });
-  const settings3 = loadClaudeSettings();
-  const hooks = settings3.hooks || {};
+  const found = await whichBinary("band");
+  if (!found) throw new Error("Could not find band CLI binary. Please install it first.");
+  return found;
+}
+function withoutBandEntries(hooks) {
+  const result = {};
   for (const [event, eventHooks] of Object.entries(hooks)) {
-    if (HOOK_EVENTS.includes(event)) continue;
-    if (!Array.isArray(eventHooks)) continue;
-    const filtered = eventHooks.filter((entry) => {
+    if (!Array.isArray(eventHooks)) {
+      result[event] = eventHooks;
+      continue;
+    }
+    const kept = [];
+    for (const entry of eventHooks) {
+      if (!isBandEntry(entry)) {
+        kept.push(entry);
+        continue;
+      }
       const e = entry;
-      if (!e.hooks || !Array.isArray(e.hooks)) return true;
-      return !e.hooks.some((h) => h.type === "command" && h.command && isBandHook(h.command));
-    });
-    if (filtered.length > 0) {
-      hooks[event] = filtered;
-    } else {
-      delete hooks[event];
+      const rest = (e.hooks ?? []).filter(
+        (h) => !(h?.type === "command" && typeof h.command === "string" && isBandHook(h.command))
+      );
+      if (rest.length > 0) kept.push({ ...e, hooks: rest });
     }
+    if (kept.length > 0 || eventHooks.length === 0) result[event] = kept;
   }
+  return result;
+}
+async function installHooks() {
+  const bandPath = await findBand();
+  const loaded = loadClaudeSettings();
+  const hooks = withoutBandEntries(hooksOf(loaded.settings));
   for (const event of HOOK_EVENTS) {
-    const existing = hooks[event] || [];
-    const filtered = existing.filter((entry) => {
-      const e = entry;
-      if (!e.hooks || !Array.isArray(e.hooks)) return true;
-      return !e.hooks.some((h) => h.type === "command" && h.command && isBandHook(h.command));
-    });
-    filtered.push({
-      hooks: [{ type: "command", command: `${bandPath} notify --agent claude-code` }]
-    });
-    hooks[event] = filtered;
+    const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
+    hooks[event] = [
+      ...existing,
+      {
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(bandPath),
+            async: true,
+            timeout: HOOK_TIMEOUT_SECONDS
+          }
+        ]
+      }
+    ];
   }
-  settings3.hooks = hooks;
-  writeFileSync4(settingsPath, JSON.stringify(settings3, null, 2), "utf-8");
+  loaded.settings.hooks = hooks;
+  saveClaudeSettings(loaded);
 }
-var HOOK_EVENTS;
+async function removeHooks() {
+  const loaded = loadClaudeSettings();
+  if (!("hooks" in loaded.settings)) return;
+  const before = hooksOf(loaded.settings);
+  const after = withoutBandEntries(before);
+  if (JSON.stringify(after) === JSON.stringify(before)) return;
+  if (Object.keys(after).length > 0) loaded.settings.hooks = after;
+  else delete loaded.settings.hooks;
+  saveClaudeSettings(loaded);
+}
+var HOOK_EVENTS, HOOKS_VERSION, HOOK_TIMEOUT_SECONDS, BAND_NOTIFY;
 var init_hooks_install = __esm({
   "../../packages/host-local/src/agents/hooks-install.ts"() {
     "use strict";
     init_path();
     HOOK_EVENTS = [
-      "PreToolUse",
-      "PermissionRequest",
       "UserPromptSubmit",
+      "PreToolUse",
       "PostToolUse",
+      "PostToolUseFailure",
+      "PermissionRequest",
       "Stop",
+      "StopFailure",
+      "SubagentStart",
+      "SubagentStop",
+      "PostCompact",
       "SessionEnd"
     ];
+    HOOKS_VERSION = 2;
+    HOOK_TIMEOUT_SECONDS = 5;
+    BAND_NOTIFY = /(^|[\s"'/\\])band(\.exe|\.cmd)?["']?\s+notify(\s|$)/;
   }
 });
 
@@ -42553,11 +42848,11 @@ var init_mcp_stdio = __esm({
 });
 
 // ../../packages/host-local/src/process/cli-binary.ts
-import { lstatSync as lstatSync3, realpathSync as realpathSync3 } from "node:fs";
+import { lstatSync as lstatSync3, realpathSync as realpathSync4 } from "node:fs";
 import { platform } from "node:os";
 import { delimiter as delimiter3, join as join19, resolve as resolve4 } from "node:path";
 function findCliBinaryAt(opts) {
-  const { cwd, dirname: dirname16 } = opts;
+  const { cwd, dirname: dirname17 } = opts;
   const exe = platform() === "win32" ? "band.exe" : "band";
   const explicit = process.env.BAND_CLI_PATH;
   if (explicit) {
@@ -42573,7 +42868,7 @@ function findCliBinaryAt(opts) {
     // cwd = repo root (fallback)
     resolve4(cwd, "apps"),
     // From this source file in dev (packages/host-local/src/process/ → apps/)
-    resolve4(dirname16, "..", "..", "..", "..", "apps"),
+    resolve4(dirname17, "..", "..", "..", "..", "apps"),
     // From bundled `dist/` file (<Resources>/web/dist/ → <Resources>/) only
     // — in dev mode this resolves to `packages/`, which has no
     // `cli/target/<profile>/band` and is harmless; the walk above is the
@@ -42581,7 +42876,7 @@ function findCliBinaryAt(opts) {
     // layout under <Resources>/cli/ would still resolve. Today's Electron
     // bundle ships the binary under `binaries/` (handled by Strategy B),
     // so this strategy never hits in production either.
-    resolve4(dirname16, "..", "..", "..")
+    resolve4(dirname17, "..", "..", "..")
   ];
   for (const appsDir of appsStrategies) {
     for (const profile of ["release", "debug"]) {
@@ -42598,7 +42893,7 @@ function findCliBinaryAt(opts) {
     resolve4(cwd, "..", "binaries", exe),
     // From the bundled dist file (<Resources>/web/dist/start-server.mjs)
     // → <Resources>/binaries/band
-    resolve4(dirname16, "..", "..", "binaries", exe)
+    resolve4(dirname17, "..", "..", "binaries", exe)
   ];
   for (const p2 of electronCandidates) {
     try {
@@ -42610,7 +42905,7 @@ function findCliBinaryAt(opts) {
   for (const dir of (process.env.PATH ?? "").split(delimiter3)) {
     if (!dir) continue;
     try {
-      return realpathSync3(join19(dir, exe));
+      return realpathSync4(join19(dir, exe));
     } catch {
     }
   }
@@ -42627,21 +42922,21 @@ var init_cli_binary = __esm({
 
 // ../../packages/host-local/src/agents/skills-install.ts
 import { execFile as execFile4 } from "node:child_process";
-import { statSync as statSync10 } from "node:fs";
+import { statSync as statSync12 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { join as join20 } from "node:path";
 async function findBandBinary() {
   const override = process.env.BAND_CLI_BIN;
   if (override) {
     try {
-      statSync10(override);
+      statSync12(override);
       return override;
     } catch {
     }
   }
   if (process.platform !== "win32") {
     try {
-      statSync10("/usr/local/bin/band");
+      statSync12("/usr/local/bin/band");
       return "/usr/local/bin/band";
     } catch {
     }
@@ -42743,7 +43038,7 @@ var init_skills_install = __esm({
 
 // ../../packages/host-local/src/browser/chromium.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync8, openSync as openSync3, readdirSync as readdirSync7 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync9, openSync as openSync4, readdirSync as readdirSync7 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile2, rm } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import { join as join21 } from "node:path";
@@ -42752,7 +43047,7 @@ function playwrightCandidates() {
     process.env.PLAYWRIGHT_BROWSERS_PATH,
     join21(homedir11(), "Library/Caches/ms-playwright"),
     join21(homedir11(), ".cache/ms-playwright")
-  ].filter((root) => !!root && existsSync8(root));
+  ].filter((root) => !!root && existsSync9(root));
   const found = [];
   for (const root of roots) {
     const dirs = readdirSync7(root).filter((d) => /^chromium-\d+$/.test(d)).sort().reverse();
@@ -42782,7 +43077,7 @@ function playwrightCandidates() {
 }
 function findChromium() {
   const fromEnv = process.env.BAND_CHROMIUM_BIN;
-  if (fromEnv) return existsSync8(fromEnv) ? fromEnv : void 0;
+  if (fromEnv) return existsSync9(fromEnv) ? fromEnv : void 0;
   const candidates = [
     "/usr/bin/chromium",
     "/usr/bin/chromium-browser",
@@ -42792,10 +43087,10 @@ function findChromium() {
     "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     ...playwrightCandidates()
   ];
-  return candidates.find((c) => existsSync8(c));
+  return candidates.find((c) => existsSync9(c));
 }
 async function readDevToolsPort(profileDir, proc, logPath, timeoutMs) {
-  const file2 = join21(profileDir, "DevToolsActivePort");
+  const file3 = join21(profileDir, "DevToolsActivePort");
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (proc.exitCode !== null || proc.signalCode !== null) {
@@ -42805,7 +43100,7 @@ async function readDevToolsPort(profileDir, proc, logPath, timeoutMs) {
       throw new Error("Chromium hit a fatal error at startup");
     }
     try {
-      const [port, path2] = (await readFile2(file2, "utf8")).split("\n");
+      const [port, path2] = (await readFile2(file3, "utf8")).split("\n");
       if (port && path2) return { port: Number(port), path: path2.trim() };
     } catch {
     }
@@ -42955,13 +43250,13 @@ var init_chromium = __esm({
           if (attempt > 1) {
             await Promise.all(SINGLETON_FILES.map((f2) => rm(join21(profileDir, f2), { force: true })));
           }
-          const logFd = openSync3(logPath, "w", 384);
+          const logFd = openSync4(logPath, "w", 384);
           const proc = spawn2(bin, args, {
             stdio: ["ignore", "ignore", logFd],
             detached: true,
             env: { ...env, HOME: home }
           });
-          closeSync3(logFd);
+          closeSync4(logFd);
           const exited = new Promise((resolve15) => {
             proc.once("exit", () => resolve15());
             proc.once("error", () => resolve15());
@@ -43380,7 +43675,7 @@ var init_git_client = __esm({
 
 // ../../packages/host-local/src/lsp/lsp-manager.ts
 import { spawn as spawn3 } from "node:child_process";
-import { dirname as dirname6, join as join24, resolve as resolve5 } from "node:path";
+import { dirname as dirname7, join as join24, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function toServerId(worktreeId4, lang) {
   return `${worktreeId4}:${lang}`;
@@ -43505,7 +43800,7 @@ var init_lsp_manager = __esm({
     "use strict";
     init_src();
     init_path();
-    __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+    __dirname2 = dirname7(fileURLToPath2(import.meta.url));
     log11 = createLogger("lsp");
     LANG_SERVER_CONFIG = {
       typescript: { command: "typescript-language-server", args: ["--stdio"] }
@@ -47803,27 +48098,27 @@ function parseEnvironment(text3) {
   if (parsed.success) return { ok: true, environment: parsed.data };
   return { ok: false, issues: zodIssues(parsed.error) };
 }
-function repoRelative(file2) {
-  if (posix.isAbsolute(file2) || /^[A-Za-z]:[\\/]/.test(file2)) return null;
-  const normal = posix.normalize(file2.replaceAll("\\", "/"));
+function repoRelative(file3) {
+  if (posix.isAbsolute(file3) || /^[A-Za-z]:[\\/]/.test(file3)) return null;
+  const normal = posix.normalize(file3.replaceAll("\\", "/"));
   if (normal === ".." || normal.startsWith("../")) return null;
   return normal;
 }
 async function checkReferences(environment, exists3) {
   const issues = [];
   for (const key2 of ["devcontainer", "dockerfile"]) {
-    const file2 = environment.build?.[key2];
-    if (file2 === void 0) continue;
-    const relative2 = repoRelative(file2);
+    const file3 = environment.build?.[key2];
+    if (file3 === void 0) continue;
+    const relative2 = repoRelative(file3);
     if (relative2 === null) {
       issues.push({
         path: `build.${key2}`,
-        message: `"${file2}" must be a path inside the repository`
+        message: `"${file3}" must be a path inside the repository`
       });
     } else if (!await exists3(relative2)) {
       issues.push({
         path: `build.${key2}`,
-        message: `file "${file2}" does not exist in the repository`
+        message: `file "${file3}" does not exist in the repository`
       });
     }
   }
@@ -47912,9 +48207,9 @@ function keyInputs(environment) {
   const inputs = [{ path: ENVIRONMENT_FILE, required: true }];
   const build = environment.build;
   for (const key2 of ["devcontainer", "dockerfile"]) {
-    const file2 = build?.[key2];
-    if (file2 === void 0) continue;
-    const relative2 = repoRelative(file2);
+    const file3 = build?.[key2];
+    if (file3 === void 0) continue;
+    const relative2 = repoRelative(file3);
     if (relative2 === null) continue;
     inputs.push({ path: relative2, required: true });
     const dir = posix2.dirname(relative2);
@@ -48463,10 +48758,10 @@ var init_remote_url = __esm({
 // ../../packages/host-local/src/repos/host-repos.ts
 import { execFile as execFile10 } from "node:child_process";
 import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { mkdir as mkdir3, readdir as readdir4, readFile as readFile4, realpath as realpath2, rename as rename2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname7, join as join27, sep as sep3 } from "node:path";
+import { dirname as dirname8, join as join27, sep as sep3 } from "node:path";
 function defaultReposDir() {
   return process.env.BAND_REPOS_DIR?.trim() || join27(homedir13(), "band", "repos");
 }
@@ -48517,10 +48812,10 @@ async function browseFolder(path2) {
     let isDir = d.isDirectory();
     if (d.isSymbolicLink()) isDir = await isDirectory(full);
     if (!isDir) continue;
-    entries.push({ name: d.name, path: full, isGit: existsSync9(join27(full, ".git")) });
+    entries.push({ name: d.name, path: full, isGit: existsSync10(join27(full, ".git")) });
   }
   entries.sort((a, b2) => a.name.localeCompare(b2.name));
-  const parent = dirname7(target);
+  const parent = dirname8(target);
   return {
     path: target,
     parent: parent === target ? null : parent,
@@ -48556,13 +48851,13 @@ var init_host_repos = __esm({
         return this.cache;
       }
       save(mappings) {
-        const file2 = this.options.mappingsFile();
+        const file3 = this.options.mappingsFile();
         this.writing = this.writing.then(async () => {
-          await mkdir3(dirname7(file2), { recursive: true, mode: 448 });
-          const tmp = `${file2}.${randomBytes2(4).toString("hex")}.tmp`;
+          await mkdir3(dirname8(file3), { recursive: true, mode: 448 });
+          const tmp = `${file3}.${randomBytes2(4).toString("hex")}.tmp`;
           await writeFile2(tmp, `${JSON.stringify(mappings, null, 2)}
 `, { mode: 384 });
-          await rename2(tmp, file2);
+          await rename2(tmp, file3);
         });
         return this.writing;
       }
@@ -48619,12 +48914,12 @@ var init_host_repos = __esm({
       async doEnsure(key2, url2, owner, name4) {
         const mappings = await this.load();
         const mapped = mappings[key2];
-        if (mapped && existsSync9(mapped.path) && await isDirectory(mapped.path)) {
+        if (mapped && existsSync10(mapped.path) && await isDirectory(mapped.path)) {
           return { path: mapped.path, cloned: false };
         }
         const base = join27(this.options.reposDir(), owner, name4);
         let dest = base;
-        if (existsSync9(dest)) {
+        if (existsSync10(dest)) {
           const origin = await git(["remote", "get-url", "origin"], dest);
           const there = origin ? parseRemoteUrl(origin)?.key : void 0;
           if (there === key2) {
@@ -48634,7 +48929,7 @@ var init_host_repos = __esm({
           const empty = (await readdir4(dest).catch(() => ["x"])).length === 0;
           if (!empty) dest = `${base}-${createHash3("sha256").update(key2).digest("hex").slice(0, 6)}`;
         }
-        await mkdir3(dirname7(dest), { recursive: true });
+        await mkdir3(dirname8(dest), { recursive: true });
         await clone2(url2, dest);
         const canonical = await realpath2(dest);
         await this.map(url2, canonical);
@@ -48696,9 +48991,9 @@ function createIterator(options) {
       if (!rawFile || typeof lineNumber !== "number" || rawContent === void 0) {
         continue;
       }
-      const file2 = rawFile.startsWith("./") ? rawFile.slice(2) : rawFile;
+      const file3 = rawFile.startsWith("./") ? rawFile.slice(2) : rawFile;
       const content = rawContent.endsWith("\n") ? rawContent.slice(0, -1) : rawContent;
-      matches2.push({ file: file2, line: lineNumber, content });
+      matches2.push({ file: file3, line: lineNumber, content });
     }
     signal();
   });
@@ -48804,15 +49099,15 @@ async function loadRepoConfig(host, worktreePath, repoPath) {
 }
 async function loadEnvironment(host, worktreePath, repoPath) {
   for (const base of [worktreePath, repoPath]) {
-    const file2 = join28(base, ENVIRONMENT_FILE);
-    const text3 = await readConfig(host, file2);
+    const file3 = join28(base, ENVIRONMENT_FILE);
+    const text3 = await readConfig(host, file3);
     if (text3 === null) continue;
     const exists3 = (relative2) => host.fs.stat(join28(base, relative2)).then(
       () => true,
       () => false
     );
     const result = await validateEnvironment(text3, exists3);
-    return result.ok ? { source: file2, environment: result.environment, issues: [] } : { source: file2, environment: null, issues: result.issues };
+    return result.ok ? { source: file3, environment: result.environment, issues: [] } : { source: file3, environment: null, issues: result.issues };
   }
   return { source: null, environment: null, issues: [] };
 }
@@ -48949,7 +49244,7 @@ var init_script_run = __esm({
 });
 
 // ../../packages/host-local/src/setup/worktree-files.ts
-import { dirname as dirname8, isAbsolute, join as join30, relative, resolve as resolve6, sep as sep4 } from "node:path";
+import { dirname as dirname9, isAbsolute, join as join30, relative, resolve as resolve6, sep as sep4 } from "node:path";
 async function copyWorktreeFiles(host, repoPath, worktreePath) {
   const byAbs = /* @__PURE__ */ new Map();
   const missingFromConfig = [];
@@ -48992,7 +49287,7 @@ async function copyWorktreeFiles(host, repoPath, worktreePath) {
         );
         continue;
       }
-      await host.fs.mkdir(dirname8(dest), { recursive: true });
+      await host.fs.mkdir(dirname9(dest), { recursive: true });
       await host.fs.copy(absSource, dest);
       log14.debug({ source, file: rel }, "copied worktree file");
       copied.push(rel);
@@ -49329,7 +49624,8 @@ var init_local_host = __esm({
         usageReader: async (agent) => getUsageReader(agent.agentType, { command: agent.command }),
         installSkills: (options) => installSkills(options),
         hooksStatus: () => checkHooks(),
-        installHooks: () => installHooks()
+        installHooks: () => installHooks(),
+        removeHooks: () => removeHooks()
       };
       get pty() {
         return this.options.terminalBackend();
@@ -49505,11 +49801,11 @@ var init_src5 = __esm({
 });
 
 // src/server/infra/db/queries/repos.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { join as join32 } from "node:path";
 function reconcileKindForRepo(repo) {
-  if (!repo.path || !existsSync10(repo.path)) return false;
-  const detectedKind = existsSync10(join32(repo.path, ".git")) ? "git" : "plain";
+  if (!repo.path || !existsSync11(repo.path)) return false;
+  const detectedKind = existsSync11(join32(repo.path, ".git")) ? "git" : "plain";
   if (detectedKind === repo.kind) return false;
   repo.kind = detectedKind;
   if (detectedKind === "plain") {
@@ -49852,12 +50148,18 @@ var init_repos = __esm({
        * Records where a worktree was started from, or clears it with `null`. Focused UPDATE, because
        * `saveAll` keeps the stored origin and never writes the one in its snapshot.
        */
-      setOrigin(repoName, name4, origin) {
+      setOrigin(repoName, name4, origin, hostId2) {
         getDb().update(worktrees).set({
           originWorktreeId: origin?.worktreeId ?? null,
           originChatId: origin?.chatId ?? null,
           originTerminalId: origin?.terminalId ?? null
-        }).where(and(eq(worktrees.repoName, repoName), eq(worktrees.name, name4))).run();
+        }).where(
+          and(
+            eq(worktrees.repoName, repoName),
+            eq(worktrees.name, name4),
+            ...hostId2 === void 0 ? [] : [eq(worktrees.hostId, hostId2)]
+          )
+        ).run();
       }
       /**
        * Path and kind of one repo, by primary key. For per-request lookups
@@ -50053,16 +50355,17 @@ var init_worktree_statuses = __esm({
         db.delete(worktreeStatuses).where(eq(worktreeStatuses.worktreeId, worktreeId4)).run();
       }
       /**
-       * Reset every "working" / "needs_attention" row back to "waiting" and
+       * Reset every row that is not "done" or "failed" back to "idle" and
        * return the count of affected rows. Used at server startup to clean
        * up stale state from the previous run.
        */
-      resetActiveToWaiting(now) {
+      resetActiveToIdle(now) {
         const db = getDb();
-        const result = db.update(worktreeStatuses).set({ agentStatus: "waiting", updatedAt: now }).where(
+        const result = db.update(worktreeStatuses).set({ agentStatus: "idle", updatedAt: now }).where(
           or(
             eq(worktreeStatuses.agentStatus, "working"),
-            eq(worktreeStatuses.agentStatus, "needs_attention")
+            eq(worktreeStatuses.agentStatus, "monitoring"),
+            eq(worktreeStatuses.agentStatus, "question")
           )
         ).run();
         return Number(result.changes);
@@ -50108,22 +50411,22 @@ var init_worktree_statuses = __esm({
         const db = getDb();
         db.delete(worktreeStatusSources).where(eq(worktreeStatusSources.worktreeId, worktreeId4)).run();
       }
-      /** Delete every source. Used at server startup: no agent state survives it. */
-      removeAll() {
-        getDb().delete(worktreeStatusSources).run();
-      }
       /**
-       * Set the worktree's `needs_attention` sources to `waiting`, except the
-       * ones in `keep`.
+       * Delete every source that is not `done` or `failed`. Used at server
+       * startup: no running agent survives it, but a finished one stays.
        */
-      acknowledge(worktreeId4, keep, now) {
-        const db = getDb();
-        const conditions = [
-          eq(worktreeStatusSources.worktreeId, worktreeId4),
-          eq(worktreeStatusSources.status, "needs_attention")
-        ];
-        if (keep.length > 0) conditions.push(notInArray(worktreeStatusSources.sourceId, keep));
-        db.update(worktreeStatusSources).set({ status: "waiting", updatedAt: now }).where(and(...conditions)).run();
+      removeActive() {
+        getDb().delete(worktreeStatusSources).where(notInArray(worktreeStatusSources.status, ["done", "failed"])).run();
+      }
+      /** Set the worktree's `done` and `failed` sources to `idle`. Returns how many changed. */
+      acknowledge(worktreeId4, now) {
+        const result = getDb().update(worktreeStatusSources).set({ status: "idle", updatedAt: now }).where(
+          and(
+            eq(worktreeStatusSources.worktreeId, worktreeId4),
+            inArray(worktreeStatusSources.status, ["done", "failed"])
+          )
+        ).run();
+        return Number(result.changes);
       }
     };
   }
@@ -50183,8 +50486,8 @@ var init_isolation = __esm({
 });
 
 // src/server/services/_utils/runner-config.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join33, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join33, resolve as resolve7 } from "node:path";
 function parseRunners(raw) {
   if (raw === void 0 || raw === null) return { runners: [], errors: [] };
   if (!Array.isArray(raw)) return { runners: [], errors: ["runners must be a list"] };
@@ -50210,8 +50513,8 @@ function bundledRunnersDir() {
   let dir = import.meta.dirname;
   for (let i = 0; i < 10; i++) {
     const candidate = join33(dir, "runners");
-    if (existsSync11(join33(candidate, "local", "spawn.sh"))) return candidate;
-    const parent = dirname9(dir);
+    if (existsSync12(join33(candidate, "local", "spawn.sh"))) return candidate;
+    const parent = dirname10(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -50691,16 +50994,20 @@ function upsertWorktreeStatus(worktreeId4, agent) {
     tabStatuses: listTabStatuses(worktreeId4)
   };
 }
-function resolveWorktreeIdByCwd(cwd) {
+function resolveWorktreeIdByCwd(cwd, hostId2) {
   const state2 = loadState();
+  let other = null;
   for (const proj of state2.repos) {
     for (const wt of proj.worktrees) {
-      if (cwd === wt.path || cwd.startsWith(`${wt.path}/`)) {
-        return toWorktreeId(proj.name, wt.name, wt.hostId);
-      }
+      const wtHost = wt.hostId ?? LOCAL_HOST_ID3;
+      if (hostId2 !== void 0 && wtHost !== hostId2) continue;
+      if (cwd !== wt.path && !cwd.startsWith(`${wt.path}/`)) continue;
+      const id = toWorktreeId(proj.name, wt.name, wt.hostId);
+      if (wtHost === LOCAL_HOST_ID3) return id;
+      other ??= id;
     }
   }
-  return null;
+  return other;
 }
 function chatStatusSource(chatId) {
   return `${CHAT_SOURCE_PREFIX}${chatId}`;
@@ -50718,20 +51025,21 @@ function deriveWorktreeStatus(worktreeId4) {
       best = status;
     }
   }
-  return best ?? "waiting";
+  return best ?? "idle";
 }
 function toTabStatuses(sources) {
   const staleBefore = Date.now() - STALE_HOOK_WORKING_MS;
   const byTab = /* @__PURE__ */ new Map();
   for (const source of sources) {
     const { status } = source;
-    if (status !== "working" && status !== "needs_attention") continue;
+    if (status === "idle" || !(status in STATUS_PRIORITY)) continue;
     if (isStaleSource(source, staleBefore)) continue;
+    const tabStatus = status;
     let tab;
     if (source.sourceId.startsWith(CHAT_SOURCE_PREFIX)) {
-      tab = { chatId: source.sourceId.slice(CHAT_SOURCE_PREFIX.length), status };
+      tab = { chatId: source.sourceId.slice(CHAT_SOURCE_PREFIX.length), status: tabStatus };
     } else if (source.terminalId) {
-      tab = { terminalId: source.terminalId, status };
+      tab = { terminalId: source.terminalId, status: tabStatus };
     } else {
       continue;
     }
@@ -50765,10 +51073,10 @@ function removeWorktreeSource(worktreeId4, sourceId) {
   if (!statusSourceQueries.remove(worktreeId4, sourceId)) return null;
   return rederiveWorktreeStatus(worktreeId4);
 }
-function acknowledgeWorktreeAttention(worktreeId4, pendingChatIds) {
+function acknowledgeWorktreeAttention(worktreeId4) {
   const existing = getWorktreeStatus(worktreeId4);
-  if (existing?.agent?.status !== "needs_attention") return existing;
-  statusSourceQueries.acknowledge(worktreeId4, pendingChatIds.map(chatStatusSource), Date.now());
+  if (!existing) return null;
+  if (statusSourceQueries.acknowledge(worktreeId4, Date.now()) === 0) return existing;
   return upsertWorktreeStatus(worktreeId4, { status: deriveWorktreeStatus(worktreeId4) });
 }
 function startStatusSourceCleanup() {
@@ -50786,17 +51094,33 @@ function startStatusSourceCleanup() {
     for (const status of changed) emit({ kind: "update", status });
   });
 }
+function subagentHold(worktreeId4, sourceId) {
+  const key2 = `${worktreeId4}\0${sourceId}`;
+  let hold = subagentHolds.get(key2);
+  if (!hold) {
+    hold = { running: /* @__PURE__ */ new Set(), deferred: null };
+    subagentHolds.set(key2, hold);
+  }
+  return hold;
+}
+function dropSubagentHold(worktreeId4, sourceId) {
+  subagentHolds.delete(`${worktreeId4}\0${sourceId}`);
+}
 async function applyHookNotification(notification) {
   const { payload } = notification;
   if (notification.dispatch === "chat") return null;
-  const worktreeId4 = resolveWorktreeIdByCwd(notification.cwd);
+  const worktreeId4 = resolveWorktreeIdByCwd(notification.cwd, notification.hostId ?? LOCAL_HOST_ID3);
   if (!worktreeId4) return null;
   const agentType = notification.agent || detectHookAgentType(payload) || settingsService.getAgentDefinition(getWorktreeStatus(worktreeId4)?.agent?.codingAgentId).type;
   const sourceId = `hook:${hookSessionId(payload) ?? agentType}`;
   if (isHookSessionEnd(agentType, payload)) {
+    dropSubagentHold(worktreeId4, sourceId);
     return removeWorktreeSource(worktreeId4, sourceId);
   }
-  const status = await mapHookPayloadToStatus(agentType, payload);
+  let status = await mapHookPayloadToStatus(agentType, payload);
+  if (agentType === "claude-code") {
+    status = foldSubagents(subagentHold(worktreeId4, sourceId), payload, status);
+  }
   return setWorktreeSourceStatus(worktreeId4, sourceId, {
     status,
     lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -50804,8 +51128,9 @@ async function applyHookNotification(notification) {
   });
 }
 function resetAgentStatuses() {
-  statusSourceQueries.removeAll();
-  return worktreeStatusQueries.resetActiveToWaiting(Date.now());
+  subagentHolds.clear();
+  statusSourceQueries.removeActive();
+  return worktreeStatusQueries.resetActiveToIdle(Date.now());
 }
 function resolveWorktreeIdentity(worktreeId4) {
   return worktreeQueriesForIdentity.findIdentity(worktreeId4);
@@ -50814,7 +51139,7 @@ function deleteWorktreeStatus(worktreeId4) {
   worktreeStatusQueries.remove(worktreeId4);
   statusSourceQueries.removeForWorktree(worktreeId4);
 }
-var worktreeStatusQueries, statusSourceQueries, worktreeQueriesForIdentity, repoQueries, STALE_HOOK_WORKING_MS, STATUS_PRIORITY, CHAT_SOURCE_PREFIX, MANUAL_STATUS_SOURCE;
+var worktreeStatusQueries, statusSourceQueries, worktreeQueriesForIdentity, repoQueries, STALE_HOOK_WORKING_MS, LOCAL_HOST_ID3, STATUS_PRIORITY, CHAT_SOURCE_PREFIX, MANUAL_STATUS_SOURCE, subagentHolds;
 var init_state = __esm({
   "src/server/services/state.ts"() {
     "use strict";
@@ -50831,9 +51156,18 @@ var init_state = __esm({
     worktreeQueriesForIdentity = new WorktreeQueries();
     repoQueries = new RepoQueries();
     STALE_HOOK_WORKING_MS = 15 * 6e4;
-    STATUS_PRIORITY = { needs_attention: 3, working: 2, waiting: 1 };
+    LOCAL_HOST_ID3 = "local";
+    STATUS_PRIORITY = {
+      question: 6,
+      failed: 5,
+      working: 4,
+      monitoring: 3,
+      done: 2,
+      idle: 1
+    };
     CHAT_SOURCE_PREFIX = "chat:";
     MANUAL_STATUS_SOURCE = "manual";
+    subagentHolds = /* @__PURE__ */ new Map();
   }
 });
 
@@ -51733,8 +52067,8 @@ var init_map_limited = __esm({
 
 // src/server/infra/subscriptions/github.ts
 import { createHmac, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname10, join as join36 } from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname11, join as join36 } from "node:path";
 function secretPath() {
   return join36(bandHome(), "github-webhook-secret");
 }
@@ -51752,7 +52086,7 @@ function ensureWebhookSecret() {
   const existing = readWebhookSecret();
   if (existing) return existing;
   const path2 = secretPath();
-  if (!existsSync12(dirname10(path2))) mkdirSync6(dirname10(path2), { recursive: true });
+  if (!existsSync13(dirname11(path2))) mkdirSync7(dirname11(path2), { recursive: true });
   const secret = randomBytes3(32).toString("hex");
   writeFileSync5(path2, `${secret}
 `, { mode: 384 });
@@ -52485,7 +52819,7 @@ var init_oauth_client = __esm({
 
 // src/server/services/_utils/vault-crypto.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes5 } from "node:crypto";
-import { chmodSync as chmodSync3, existsSync as existsSync13, readFileSync as readFileSync9, renameSync as renameSync5, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync14, readFileSync as readFileSync9, renameSync as renameSync7, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join37 } from "node:path";
 function vaultKeyFile() {
   return join37(bandHome(), "vault.key");
@@ -52507,21 +52841,21 @@ function generateKey() {
 function loadKey() {
   const fromEnv = process.env.BAND_VAULT_KEY?.trim();
   if (fromEnv) return parseKey(fromEnv);
-  const file2 = vaultKeyFile();
-  if (existsSync13(file2)) return parseKey(readFileSync9(file2, "utf8"));
+  const file3 = vaultKeyFile();
+  if (existsSync14(file3)) return parseKey(readFileSync9(file3, "utf8"));
   const key2 = generateKey();
-  writeFileSync6(file2, `${key2.toString("base64")}
+  writeFileSync6(file3, `${key2.toString("base64")}
 `, { mode: 384, flag: "wx" });
-  chmodSync3(file2, 384);
+  chmodSync3(file3, 384);
   return key2;
 }
 function stageKeyFile(key2) {
-  const file2 = vaultKeyFile();
-  const temp = `${file2}.${process.pid}.next`;
+  const file3 = vaultKeyFile();
+  const temp = `${file3}.${process.pid}.next`;
   writeFileSync6(temp, `${key2.toString("base64")}
 `, { mode: 384 });
   chmodSync3(temp, 384);
-  return { commit: () => renameSync5(temp, file2), discard: () => rmSync2(temp, { force: true }) };
+  return { commit: () => renameSync7(temp, file3), discard: () => rmSync3(temp, { force: true }) };
 }
 function encrypt(key2, aad, plaintext) {
   const nonce = randomBytes5(NONCE_BYTES);
@@ -53736,9 +54070,15 @@ var init_mime_types = __esm({
       ".txt": "text/plain",
       ".md": "text/markdown",
       ".csv": "text/csv",
-      ".html": "text/html",
-      ".css": "text/css",
-      ".js": "application/javascript",
+      ".html": "text/html; charset=utf-8",
+      ".htm": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "text/javascript; charset=utf-8",
+      ".mjs": "text/javascript; charset=utf-8",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
       ".ts": "application/typescript",
       ".xml": "application/xml",
       ".yaml": "application/x-yaml",
@@ -53765,6 +54105,132 @@ var init_turn_events = __esm({
   }
 });
 
+// src/server/services/chat-status-service.ts
+function quietMs() {
+  const override = Number(process.env.BAND_AGENT_QUIET_MS);
+  return Number.isFinite(override) && override > 0 ? override : QUIET_MS;
+}
+function setChatStatus(worktreeId4, chatId, status) {
+  if (status === "monitoring") monitoringChats.add(chatId);
+  else monitoringChats.delete(chatId);
+  const updated = setWorktreeSourceStatus(worktreeId4, chatStatusSource(chatId), { status });
+  emit({ kind: "update", status: updated });
+}
+function restingStatus(chatId) {
+  if (agentSessionService.hasPendingRequest(chatId)) return "question";
+  if (agentSessionService.nextWorkDeadline(chatId) !== null) return "monitoring";
+  return "done";
+}
+function beginBandTurn(worktreeId4, chatId) {
+  endAutonomous(chatId);
+  clearMonitorTimer(chatId);
+  setChatStatus(worktreeId4, chatId, "working");
+}
+function endBandTurn(worktreeId4, chatId, result) {
+  const status = result === "done" ? restingStatus(chatId) : result;
+  setChatStatus(worktreeId4, chatId, status);
+  if (status === "monitoring") watchMonitoring(worktreeId4, chatId);
+}
+function endAutonomous(chatId) {
+  const timer = autonomous.get(chatId);
+  if (timer) clearTimeout(timer);
+  autonomous.delete(chatId);
+}
+function clearMonitorTimer(chatId) {
+  const timer = monitorTimers.get(chatId);
+  if (timer) clearTimeout(timer);
+  monitorTimers.delete(chatId);
+}
+function watchMonitoring(worktreeId4, chatId) {
+  clearMonitorTimer(chatId);
+  const deadline = agentSessionService.nextWorkDeadline(chatId);
+  if (deadline === null) return;
+  const timer = setTimeout(
+    () => {
+      monitorTimers.delete(chatId);
+      if (runningTurn(chatId) || autonomous.has(chatId)) return;
+      reconsiderMonitoring(worktreeId4, chatId);
+    },
+    Math.min(Math.max(deadline - Date.now(), 0) + 100, MAX_TIMER_MS)
+  );
+  timer.unref?.();
+  monitorTimers.set(chatId, timer);
+}
+function reconsiderMonitoring(worktreeId4, chatId) {
+  if (!chatService.get(chatId) || !monitoringChats.has(chatId)) return;
+  const status = restingStatus(chatId);
+  if (status === "monitoring") {
+    watchMonitoring(worktreeId4, chatId);
+    return;
+  }
+  setChatStatus(worktreeId4, chatId, status);
+}
+function settleAutonomous(worktreeId4, chatId) {
+  autonomous.delete(chatId);
+  if (!chatService.get(chatId) || runningTurn(chatId)) return;
+  const status = restingStatus(chatId);
+  setChatStatus(worktreeId4, chatId, status);
+  if (status === "monitoring") watchMonitoring(worktreeId4, chatId);
+}
+function armQuietTimer(worktreeId4, chatId) {
+  const previous = autonomous.get(chatId);
+  if (previous) clearTimeout(previous);
+  const timer = setTimeout(() => settleAutonomous(worktreeId4, chatId), quietMs());
+  timer.unref?.();
+  autonomous.set(chatId, timer);
+}
+function observeAgentStatus(hasRunningTurn) {
+  if (observing) return;
+  observing = true;
+  runningTurn = hasRunningTurn;
+  agentSessionService.observePending((chatId, worktreeId4) => {
+    const waiting = agentSessionService.hasPendingRequest(chatId);
+    if (runningTurn(chatId)) {
+      setChatStatus(worktreeId4, chatId, waiting ? "question" : "working");
+      return;
+    }
+    if (waiting) {
+      const timer = autonomous.get(chatId);
+      if (timer) clearTimeout(timer);
+      autonomous.set(chatId, null);
+      setChatStatus(worktreeId4, chatId, "question");
+    } else if (autonomous.has(chatId)) {
+      setChatStatus(worktreeId4, chatId, "working");
+      armQuietTimer(worktreeId4, chatId);
+    }
+  });
+  agentSessionService.observeActivity((chatId, worktreeId4, kind) => {
+    if (runningTurn(chatId) || !chatService.get(chatId)) return;
+    if (kind === "update") {
+      if (agentSessionService.hasPendingRequest(chatId)) return;
+      const wasWorking = autonomous.has(chatId);
+      armQuietTimer(worktreeId4, chatId);
+      clearMonitorTimer(chatId);
+      if (!wasWorking) setChatStatus(worktreeId4, chatId, "working");
+      return;
+    }
+    if (autonomous.has(chatId)) return;
+    reconsiderMonitoring(worktreeId4, chatId);
+  });
+}
+var QUIET_MS, MAX_TIMER_MS, autonomous, monitorTimers, monitoringChats, runningTurn, observing;
+var init_chat_status_service = __esm({
+  "src/server/services/chat-status-service.ts"() {
+    "use strict";
+    init_agent_session_service();
+    init_chat_service();
+    init_state();
+    init_watcher_service();
+    QUIET_MS = 1e4;
+    MAX_TIMER_MS = 2 ** 31 - 1;
+    autonomous = /* @__PURE__ */ new Map();
+    monitorTimers = /* @__PURE__ */ new Map();
+    monitoringChats = /* @__PURE__ */ new Set();
+    runningTurn = () => false;
+    observing = false;
+  }
+});
+
 // ../../packages/host-local/src/git/git-refusals.ts
 async function pullRefusal(err, cwd, execGit2) {
   const stderr = errorText(err);
@@ -54212,7 +54678,7 @@ var init_worktree_checkpoints = __esm({
 });
 
 // src/server/services/_utils/checkpoint-store.ts
-import { rmSync as rmSync3 } from "node:fs";
+import { rmSync as rmSync4 } from "node:fs";
 import { join as join38 } from "node:path";
 function worktreeCheckpointDir(worktreeId4) {
   return join38(bandHome(), "checkpoints", worktreeId4);
@@ -54222,7 +54688,7 @@ function checkpointDir(worktreeId4, checkpointId2) {
 }
 function forgetCheckpoints(worktreeId4) {
   queries2.deleteForWorktree(worktreeId4);
-  rmSync3(worktreeCheckpointDir(worktreeId4), { recursive: true, force: true });
+  rmSync4(worktreeCheckpointDir(worktreeId4), { recursive: true, force: true });
 }
 var queries2;
 var init_checkpoint_store = __esm({
@@ -54342,13 +54808,13 @@ var init_remote_worktrees = __esm({
 // ../../packages/shared/src/repo-hosts.ts
 function isHostAllowed(allowed2, hostId2) {
   if (!allowed2) return true;
-  return allowed2.includes(hostId2 || LOCAL_HOST_ID3);
+  return allowed2.includes(hostId2 || LOCAL_HOST_ID4);
 }
 function effectivePrimaryHost(primaryHostId, allowed2, hostsWithDefaultCheckout) {
   if (primaryHostId && isHostAllowed(allowed2, primaryHostId)) return primaryHostId;
   const candidates = hostsWithDefaultCheckout.filter((id) => isHostAllowed(allowed2, id));
   if (candidates.length === 0) return null;
-  if (candidates.includes(LOCAL_HOST_ID3)) return LOCAL_HOST_ID3;
+  if (candidates.includes(LOCAL_HOST_ID4)) return LOCAL_HOST_ID4;
   return [...candidates].sort()[0] ?? null;
 }
 function onlyAvailableOnMessage(repo, hostNames) {
@@ -54358,10 +54824,10 @@ function checkpointsEnabledFor(stored, allowed2) {
   if (stored != null) return stored;
   return !allowed2;
 }
-var LOCAL_HOST_ID3;
+var LOCAL_HOST_ID4;
 var init_repo_hosts = __esm({
   "../../packages/shared/src/repo-hosts.ts"() {
-    LOCAL_HOST_ID3 = "local";
+    LOCAL_HOST_ID4 = "local";
   }
 });
 
@@ -56246,6 +56712,7 @@ var init_rpc = __esm({
       "scripts.copyFiles": 2 * 6e4,
       "agentEnv.installSkills": 2 * 6e4,
       "agentEnv.installHooks": 6e4,
+      "agentEnv.removeHooks": 6e4,
       exec: 10 * 6e4
     };
     RemoteRpc = class {
@@ -56519,7 +56986,8 @@ var init_remote_host = __esm({
         // The worker takes no `home` override. It is for tests of the local install.
         installSkills: () => this.rpc.call("agentEnv.installSkills"),
         hooksStatus: () => this.rpc.call("agentEnv.hooksStatus"),
-        installHooks: () => this.rpc.call("agentEnv.installHooks")
+        installHooks: () => this.rpc.call("agentEnv.installHooks"),
+        removeHooks: () => this.rpc.call("agentEnv.removeHooks")
       };
       // ---- fs -----------------------------------------------------------------
       async writeFile(path2, data, options) {
@@ -56931,7 +57399,7 @@ function stringRecord(value) {
 function stringList2(value) {
   return Array.isArray(value) ? value.filter((v2) => typeof v2 === "string") : [];
 }
-var log20, repoQueries4, LOCAL_HOST_ID4, DEFAULT_TIMEOUT_MS, DEFAULT_LEASE_MS, MAX_LEASE_MS, SWEEP_MS, leaseFilterInput, HostRequestError, PlacementService, placementService;
+var log20, repoQueries4, LOCAL_HOST_ID5, DEFAULT_TIMEOUT_MS, DEFAULT_LEASE_MS, MAX_LEASE_MS, SWEEP_MS, leaseFilterInput, HostRequestError, PlacementService, placementService;
 var init_placement_service = __esm({
   "src/server/services/placement-service.ts"() {
     "use strict";
@@ -56955,7 +57423,7 @@ var init_placement_service = __esm({
     init_worktree_service();
     log20 = createLogger("placement");
     repoQueries4 = new RepoQueries();
-    LOCAL_HOST_ID4 = "local";
+    LOCAL_HOST_ID5 = "local";
     DEFAULT_TIMEOUT_MS = 10 * 6e4;
     DEFAULT_LEASE_MS = 6e4;
     MAX_LEASE_MS = 15 * 6e4;
@@ -57003,7 +57471,7 @@ var init_placement_service = __esm({
         for (const row of tokenService.listHosts(1e3)) {
           if (row.status !== "online" || !row.usable) continue;
           if (row.info?.mode === "ephemeral") continue;
-          const info = row.id === LOCAL_HOST_ID4 ? await hostRegistry.local.info().catch(() => null) : null;
+          const info = row.id === LOCAL_HOST_ID5 ? await hostRegistry.local.info().catch(() => null) : null;
           const stored = row.info ?? {};
           const versions = stringRecord(info?.versions ?? stored.versions);
           const tools = stringRecord(info?.tools ?? stored.tools);
@@ -57035,7 +57503,7 @@ var init_placement_service = __esm({
         const fits = (await this.candidates()).filter(
           (c) => !isExclusiveHost(c.labels) && (onlyHosts === void 0 || onlyHosts.includes(c.id)) && // A worker must report the agent installed and logged in. The hub's own machine is
           // described live elsewhere, so it is not held to a report here.
-          (agent === void 0 || c.id === LOCAL_HOST_ID4 || c.agents.includes(agent)) && matches(c, placement)
+          (agent === void 0 || c.id === LOCAL_HOST_ID5 || c.agents.includes(agent)) && matches(c, placement)
         );
         if (fits.length === 0) return null;
         const load = this.queries.worktreeCounts();
@@ -57452,8 +57920,8 @@ var init_environment_builds = __esm({
       get(id) {
         return getDb().select().from(environmentBuilds).where(eq(environmentBuilds.id, id)).get();
       }
-      setLog(id, log77) {
-        getDb().update(environmentBuilds).set({ log: log77 }).where(eq(environmentBuilds.id, id)).run();
+      setLog(id, log78) {
+        getDb().update(environmentBuilds).set({ log: log78 }).where(eq(environmentBuilds.id, id)).run();
       }
       finish(id, result) {
         getDb().update(environmentBuilds).set({
@@ -57821,48 +58289,48 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
       }
       // ---- running ---------------------------------------------------------------
       async run(row, plan) {
-        const log77 = new BuildLog(row.id, (id, text3) => this.queries.setLog(id, text3));
+        const log78 = new BuildLog(row.id, (id, text3) => this.queries.setLog(id, text3));
         let tmp = null;
         const container = `band-env-${row.id.slice(0, 12)}`;
-        let failure = null;
+        let failure2 = null;
         try {
-          log77.add(`Building ${plan.tag} for ${plan.repo} at ${plan.ref} (${plan.commit.slice(0, 12)})`);
-          log77.flush();
+          log78.add(`Building ${plan.tag} for ${plan.repo} at ${plan.ref} (${plan.commit.slice(0, 12)})`);
+          log78.flush();
           tmp = await plan.host.fs.mkdtemp("band-env-");
-          await this.exportCheckout(plan, tmp, log77);
-          const toolchain = await this.buildToolchain(plan, tmp, log77);
-          const layered = await this.addWorkerLayer(plan, tmp, toolchain, log77);
-          await this.install(plan, tmp, layered, container, log77);
-          if (plan.registry) await this.push(plan, log77);
-          log77.add(`Done: ${plan.tag}`);
+          await this.exportCheckout(plan, tmp, log78);
+          const toolchain = await this.buildToolchain(plan, tmp, log78);
+          const layered = await this.addWorkerLayer(plan, tmp, toolchain, log78);
+          await this.install(plan, tmp, layered, container, log78);
+          if (plan.registry) await this.push(plan, log78);
+          log78.add(`Done: ${plan.tag}`);
         } catch (err) {
-          failure = err.message;
-          log77.add(`FAILED: ${failure}`);
+          failure2 = err.message;
+          log78.add(`FAILED: ${failure2}`);
         }
-        await this.exec(plan.host, "docker", ["rm", "--force", container], log77, { quiet: true }).catch(
+        await this.exec(plan.host, "docker", ["rm", "--force", container], log78, { quiet: true }).catch(
           () => void 0
         );
         await this.exec(
           plan.host,
           "docker",
           ["rmi", toolchainTag(plan.repo, plan.key), layeredTag(plan.repo, plan.key)],
-          log77,
+          log78,
           { quiet: true }
         ).catch(() => void 0);
         if (tmp) await plan.host.fs.rm(tmp, { recursive: true, force: true }).catch(() => void 0);
         try {
-          if (failure === null) {
+          if (failure2 === null) {
             this.queries.finish(row.id, {
               status: "ready",
               image: plan.tag,
-              log: log77.toString(),
+              log: log78.toString(),
               at: Date.now()
             });
           } else {
             this.queries.finish(row.id, {
               status: "failed",
-              error: failure.slice(0, 2e3),
-              log: log77.toString(),
+              error: failure2.slice(0, 2e3),
+              log: log78.toString(),
               at: Date.now()
             });
           }
@@ -57871,9 +58339,9 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
         }
       }
       /** Runs a command on the builder host, adding it and its output to the log. */
-      async exec(host, tool, args, log77, options = {}) {
+      async exec(host, tool, args, log78, options = {}) {
         const bin = tool === "docker" ? this.dockerBin(host) : tool === "devcontainer" ? this.devcontainerBin(host) : "git";
-        if (!options.quiet) log77.add(`$ ${tool} ${args.join(" ")}`);
+        if (!options.quiet) log78.add(`$ ${tool} ${args.join(" ")}`);
         try {
           const out = await host.exec(bin, args, {
             cwd: options.cwd,
@@ -57881,35 +58349,35 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
             timeoutMs: envNumber("BAND_ENVIRONMENT_BUILD_TIMEOUT_MS", DEFAULT_STEP_TIMEOUT_MS)
           });
           if (!options.quiet) {
-            if (out.stdout.trim()) log77.add(out.stdout.trimEnd());
-            if (out.stderr.trim()) log77.add(out.stderr.trimEnd());
-            log77.flush();
+            if (out.stdout.trim()) log78.add(out.stdout.trimEnd());
+            if (out.stderr.trim()) log78.add(out.stderr.trimEnd());
+            log78.flush();
           }
           return out.stdout;
         } catch (err) {
           if (!options.quiet) {
-            log77.add(err.message);
-            log77.flush();
+            log78.add(err.message);
+            log78.flush();
           }
           throw new Error(`${tool} ${args[0] ?? ""} failed: ${firstLine(err.message)}`);
         }
       }
       /** Writes the default branch's files, with no `.git`, to `<tmp>/src`. */
-      async exportCheckout(plan, tmp, log77) {
+      async exportCheckout(plan, tmp, log78) {
         const src = posix4.join(tmp, "src");
         await plan.host.fs.mkdir(src);
         const index2 = posix4.join(tmp, "index");
-        await this.exec(plan.host, "git", ["read-tree", plan.ref], log77, {
+        await this.exec(plan.host, "git", ["read-tree", plan.ref], log78, {
           cwd: plan.repoPath,
           env: { GIT_INDEX_FILE: index2 }
         });
-        await this.exec(plan.host, "git", ["checkout-index", "--all", `--prefix=${src}/`], log77, {
+        await this.exec(plan.host, "git", ["checkout-index", "--all", `--prefix=${src}/`], log78, {
           cwd: plan.repoPath,
           env: { GIT_INDEX_FILE: index2 }
         });
       }
       /** Layer 2: returns the tag of an image holding the repo's toolchain. */
-      async buildToolchain(plan, tmp, log77) {
+      async buildToolchain(plan, tmp, log78) {
         const build = plan.environment.build;
         const src = posix4.join(tmp, "src");
         const tag = toolchainTag(plan.repo, plan.key);
@@ -57918,7 +58386,7 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
             plan.host,
             "docker",
             dockerBuildArgs({ checkout: src, dockerfile: build.dockerfile, tag }),
-            log77
+            log78
           );
           return tag;
         }
@@ -57928,7 +58396,7 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
               plan.host,
               "devcontainer",
               devcontainerBuildArgs({ checkout: src, config: build.devcontainer, tag }),
-              log77
+              log78
             );
           } catch (err) {
             throw new Error(
@@ -57938,11 +58406,11 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
           return tag;
         }
         const image = build?.image;
-        await this.exec(plan.host, "docker", ["pull", image], log77);
+        await this.exec(plan.host, "docker", ["pull", image], log78);
         return image;
       }
       /** Layer 1 on top of layer 2: copies the worker from the worker base image. */
-      async addWorkerLayer(plan, tmp, toolchain, log77) {
+      async addWorkerLayer(plan, tmp, toolchain, log78) {
         const dir = posix4.join(tmp, "layer");
         await plan.host.fs.mkdir(dir);
         await plan.host.fs.writeFile(
@@ -57954,38 +58422,38 @@ ${this.text.slice(-MAX_LOG_BYTES)}`;
         });
         await plan.host.fs.mkdir(posix4.join(dir, "root", "work"), { recursive: true });
         const tag = layeredTag(plan.repo, plan.key);
-        await this.exec(plan.host, "docker", ["build", "--tag", tag, dir], log77);
+        await this.exec(plan.host, "docker", ["build", "--tag", tag, dir], log78);
         return tag;
       }
       /** Runs `install` at the default branch inside the image and commits the result as the final tag. */
-      async install(plan, tmp, layered, container, log77) {
+      async install(plan, tmp, layered, container, log78) {
         const install = plan.environment.install;
         if (install === void 0) {
-          await this.exec(plan.host, "docker", ["tag", layered, plan.tag], log77);
+          await this.exec(plan.host, "docker", ["tag", layered, plan.tag], log78);
           return;
         }
         await this.exec(
           plan.host,
           "docker",
           installCreateArgs({ name: container, image: layered, install }),
-          log77
+          log78
         );
         await this.exec(
           plan.host,
           "docker",
           ["cp", `${posix4.join(tmp, "src")}/.`, `${container}:${IMAGE_WORKDIR}`],
-          log77
+          log78
         );
-        await this.exec(plan.host, "docker", ["start", "--attach", container], log77);
+        await this.exec(plan.host, "docker", ["start", "--attach", container], log78);
         await this.exec(
           plan.host,
           "docker",
           commitArgs({ container, tag: plan.tag, key: plan.key, commit: plan.commit }),
-          log77
+          log78
         );
       }
-      async push(plan, log77) {
-        await this.exec(plan.host, "docker", ["push", plan.tag], log77);
+      async push(plan, log78) {
+        await this.exec(plan.host, "docker", ["push", plan.tag], log78);
       }
       // ---- auto trigger ----------------------------------------------------------
       /**
@@ -58204,8 +58672,8 @@ var init_git_credential_service = __esm({
 // src/server/services/runner-service.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomBytes as randomBytes10 } from "node:crypto";
-import { appendFileSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync11 } from "node:fs";
-import { dirname as dirname11, join as join39 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync8, readFileSync as readFileSync10, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
+import { dirname as dirname12, join as join39 } from "node:path";
 function snapshotSweepMs() {
   const raw = Number(process.env.BAND_SNAPSHOT_SWEEP_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : SNAPSHOT_SWEEP_MS;
@@ -58294,9 +58762,9 @@ var init_runner_service = __esm({
       "SHELL"
     ];
     RunLog = class {
-      constructor(file2) {
-        this.file = file2;
-        mkdirSync7(dirname11(file2), { recursive: true, mode: 448 });
+      constructor(file3) {
+        this.file = file3;
+        mkdirSync8(dirname12(file3), { recursive: true, mode: 448 });
       }
       lines = [];
       bytes = 0;
@@ -58721,7 +59189,7 @@ ${tail}` : head;
           () => false
         );
         if (exists3) return;
-        await host.git.exec(["clone", "--quiet", "--", url2, dest], dirname11(dest));
+        await host.git.exec(["clone", "--quiet", "--", url2, dest], dirname12(dest));
       }
       /** Records the machine of an attempt. An older machine of the same worker id is gone by now, so it is retired. */
       recordMachine(runner, row, workerId) {
@@ -58796,7 +59264,7 @@ ${tail}` : head;
         } else if (!runner.destroy) {
           outcome = { state: "lost", error: `runner "${runner.id}" has no destroy hook` };
         } else {
-          let failure = null;
+          let failure2 = null;
           try {
             const code = await this.runDestroy(
               runner,
@@ -58805,17 +59273,17 @@ ${tail}` : head;
               machine.handle,
               runLog
             );
-            if (code !== 0) failure = `destroy exited with code ${code}`;
+            if (code !== 0) failure2 = `destroy exited with code ${code}`;
           } catch (err) {
-            failure = `destroy failed: ${err instanceof Error ? err.message : err}`;
+            failure2 = `destroy failed: ${err instanceof Error ? err.message : err}`;
           }
-          if (failure === null) {
+          if (failure2 === null) {
             outcome = { state: "destroyed", destroyedAt: Date.now(), error: reason };
           } else {
             const attempts = machine.destroyAttempts + 1;
-            outcome = attempts >= DESTROY_ATTEMPTS ? { state: "lost", destroyAttempts: attempts, error: failure } : {
+            outcome = attempts >= DESTROY_ATTEMPTS ? { state: "lost", destroyAttempts: attempts, error: failure2 } : {
               destroyAttempts: attempts,
-              error: `${failure} (try ${attempts} of ${DESTROY_ATTEMPTS})`
+              error: `${failure2} (try ${attempts} of ${DESTROY_ATTEMPTS})`
             };
           }
         }
@@ -58829,12 +59297,12 @@ ${tail}` : head;
       /** Runs `destroy` for a machine the hub has no record of, named only by the handle `status` printed. */
       async destroyHandle(runner, handle, reason) {
         if (!runner.destroy) return false;
-        const file2 = join39(bandHome(), "runners", "logs", "reaper.log");
+        const file3 = join39(bandHome(), "runners", "logs", "reaper.log");
         try {
-          if (statSync11(file2).size > LOG_FILE_LIMIT) rmSync4(file2, { force: true });
+          if (statSync13(file3).size > LOG_FILE_LIMIT) rmSync5(file3, { force: true });
         } catch {
         }
-        const runLog = new RunLog(file2);
+        const runLog = new RunLog(file3);
         runLog.write("hub", `destroying machine ${handle} of runner ${runner.id}: ${reason}`);
         try {
           const code = await this.runDestroy(runner, null, null, handle, runLog);
@@ -59078,7 +59546,7 @@ ${tail}` : head;
       runHook(opts) {
         const { runner, name: name4, path: path2, env, timeoutMs, runLog, watch, onStdout, onStderr } = opts;
         const cwd = join39(bandHome(), "runners", runner.id);
-        mkdirSync7(cwd, { recursive: true, mode: 448 });
+        mkdirSync8(cwd, { recursive: true, mode: 448 });
         return new Promise((resolve15, reject) => {
           let child;
           try {
@@ -59136,7 +59604,7 @@ ${tail}` : head;
 });
 
 // src/server/services/ephemeral-lifecycle-service.ts
-import { rmSync as rmSync5 } from "node:fs";
+import { rmSync as rmSync6 } from "node:fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join40, posix as posix5 } from "node:path";
 function idleTimeoutMs() {
@@ -59146,7 +59614,7 @@ function idleTimeoutMs() {
 function sleepDir(worktreeId4) {
   return join40(bandHome(), "sleep", worktreeId4);
 }
-var log23, LOCAL_HOST_ID5, WAKE_POLL_MS, WAKE_GRACE_MS, EXIT_GRACE_MS, SleepError, errorText2, EphemeralLifecycleService, ephemeralLifecycleService;
+var log23, LOCAL_HOST_ID6, WAKE_POLL_MS, WAKE_GRACE_MS, EXIT_GRACE_MS, SleepError, errorText2, EphemeralLifecycleService, ephemeralLifecycleService;
 var init_ephemeral_lifecycle_service = __esm({
   "src/server/services/ephemeral-lifecycle-service.ts"() {
     "use strict";
@@ -59168,7 +59636,7 @@ var init_ephemeral_lifecycle_service = __esm({
     init_state();
     init_task_service();
     log23 = createLogger("ephemeral-lifecycle");
-    LOCAL_HOST_ID5 = "local";
+    LOCAL_HOST_ID6 = "local";
     WAKE_POLL_MS = 500;
     WAKE_GRACE_MS = 5 * 6e4;
     EXIT_GRACE_MS = 6e4;
@@ -59499,7 +59967,7 @@ var init_ephemeral_lifecycle_service = __esm({
       }
       forget(row) {
         this.sleeps.delete(row.worktreeId);
-        rmSync5(sleepDir(row.worktreeId), { recursive: true, force: true });
+        rmSync6(sleepDir(row.worktreeId), { recursive: true, force: true });
       }
       // ---- wake ---------------------------------------------------------------
       /**
@@ -59511,7 +59979,7 @@ var init_ephemeral_lifecycle_service = __esm({
       async ensureAwake(worktreeId4) {
         for (let i = 0; i < 3; i++) {
           const hostId2 = this.worktrees.findHostId(worktreeId4);
-          if (!hostId2 || hostId2 === LOCAL_HOST_ID5) return;
+          if (!hostId2 || hostId2 === LOCAL_HOST_ID6) return;
           const draining = this.draining.get(hostId2);
           if (draining) {
             await draining;
@@ -59680,10 +60148,10 @@ var init_ephemeral_lifecycle_service = __esm({
         }
         const stage = posix5.join(wipDir, "sessions", row.worktreeId);
         await host.fs.rm(stage, { recursive: true, force: true });
-        for (const file2 of files) {
-          const target = posix5.join(stage, file2.root, file2.rel);
+        for (const file3 of files) {
+          const target = posix5.join(stage, file3.root, file3.rel);
           await host.fs.mkdir(posix5.dirname(target), { recursive: true });
-          await host.fs.writeFile(target, Buffer.from(file2.data, "base64"));
+          await host.fs.writeFile(target, Buffer.from(file3.data, "base64"));
         }
         await rpc.call(METHOD_LIFECYCLE_IMPORT_SESSIONS, { dir: stage });
       }
@@ -60843,6 +61311,8 @@ var init_client_state_keys = __esm({
       exact("band.repos-list.collapsed-pinned", [jsonPart("all")]),
       exact("band.repos-list.label-filter", [rawPart("all")]),
       exact("band.repos-list.label-last-worktree", [jsonPart("all")]),
+      // The hooks version whose install banner the user dismissed.
+      exact("band:agent-hooks-banner-dismissed", [rawPart("all")]),
       perWorktree(CENTER_TABS_PREFIX, [jsonPart("all")]),
       perWorktreeLeaf("band:term-split:", [jsonPart("all")]),
       perWorktree("band:diff-compare-branch:", [rawPart("all")]),
@@ -61069,11 +61539,11 @@ var init_cronjobs = __esm({
        * incomplete state (some jobs missing) — the legacy `cronjob-store.ts`
        * had the same gap; the migration is the appropriate moment to fix it.
        */
-      saveFile(key2, file2) {
+      saveFile(key2, file3) {
         const db = getDb();
         db.transaction((tx) => {
           tx.delete(cronjobs).where(eq(cronjobs.fileKey, key2)).run();
-          for (const job of file2.jobs) {
+          for (const job of file3.jobs) {
             tx.insert(cronjobs).values({
               id: job.id,
               fileKey: key2,
@@ -61265,14 +61735,14 @@ var init_cronjob_service = __esm({
       list(filter) {
         if (filter?.repo) {
           const { repo } = filter;
-          const file2 = this.queries.loadFile(repo);
-          return { jobs: file2.jobs.map((j) => ({ ...j, fileKey: repo })) };
+          const file3 = this.queries.loadFile(repo);
+          return { jobs: file3.jobs.map((j) => ({ ...j, fileKey: repo })) };
         }
         if (filter?.worktreeId) {
           const { worktreeId: worktreeId4 } = filter;
-          const file2 = this.queries.loadFile(worktreeId4);
+          const file3 = this.queries.loadFile(worktreeId4);
           return {
-            jobs: file2.jobs.map((j) => ({ ...j, fileKey: worktreeId4 }))
+            jobs: file3.jobs.map((j) => ({ ...j, fileKey: worktreeId4 }))
           };
         }
         return { jobs: this.queries.listAll() };
@@ -61300,7 +61770,7 @@ var init_cronjob_service = __esm({
         if (input.scope === "worktree" && !input.worktreeId) {
           throw new CronjobWorktreeMissingError();
         }
-        const file2 = this.queries.loadFile(input.key);
+        const file3 = this.queries.loadFile(input.key);
         const job = {
           id: generateCronjobId(),
           name: input.name,
@@ -61314,8 +61784,8 @@ var init_cronjob_service = __esm({
           enabled: input.enabled,
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        file2.jobs.push(job);
-        this.queries.saveFile(input.key, file2);
+        file3.jobs.push(job);
+        this.queries.saveFile(input.key, file3);
         this.reloadSchedules();
         return { job };
       }
@@ -61330,14 +61800,14 @@ var init_cronjob_service = __esm({
         if (input.cronExpression !== void 0) {
           this.assertValidCron(input.cronExpression);
         }
-        const file2 = this.queries.loadFile(input.key);
-        const job = file2.jobs.find((j) => j.id === input.id);
+        const file3 = this.queries.loadFile(input.key);
+        const job = file3.jobs.find((j) => j.id === input.id);
         if (!job) throw new CronjobNotFoundError();
         if (input.name !== void 0) job.name = input.name;
         if (input.prompt !== void 0) job.prompt = input.prompt;
         if (input.cronExpression !== void 0) job.cronExpression = input.cronExpression;
         if (input.enabled !== void 0) job.enabled = input.enabled;
-        this.queries.saveFile(input.key, file2);
+        this.queries.saveFile(input.key, file3);
         this.reloadSchedules();
         return { job };
       }
@@ -61347,11 +61817,11 @@ var init_cronjob_service = __esm({
        * Throws `CronjobNotFoundError` if the job is already gone.
        */
       delete(key2, id) {
-        const file2 = this.queries.loadFile(key2);
-        const index2 = file2.jobs.findIndex((j) => j.id === id);
+        const file3 = this.queries.loadFile(key2);
+        const index2 = file3.jobs.findIndex((j) => j.id === id);
         if (index2 === -1) throw new CronjobNotFoundError();
-        const [removed] = file2.jobs.splice(index2, 1);
-        this.queries.saveFile(key2, file2);
+        const [removed] = file3.jobs.splice(index2, 1);
+        this.queries.saveFile(key2, file3);
         if (removed?.lastTerminalId) {
           const terminalId = removed.lastTerminalId;
           void terminalService.kill(terminalId).catch((err) => {
@@ -61469,8 +61939,8 @@ var init_cronjob_service = __esm({
        */
       stopJobsForKey(key2) {
         const state2 = schedulerState();
-        const file2 = this.queries.loadFile(key2);
-        for (const job of file2.jobs) {
+        const file3 = this.queries.loadFile(key2);
+        for (const job of file3.jobs) {
           const cron = state2.jobs.get(job.id);
           if (cron) {
             cron.stop();
@@ -61621,8 +62091,8 @@ exit`;
       // Internals
       // -------------------------------------------------------------------------
       findJob(key2, id) {
-        const file2 = this.queries.loadFile(key2);
-        return file2.jobs.find((j) => j.id === id);
+        const file3 = this.queries.loadFile(key2);
+        return file3.jobs.find((j) => j.id === id);
       }
       assertValidCron(expression) {
         try {
@@ -61744,28 +62214,28 @@ exit`;
 // src/server/services/local-host-policy.ts
 function resolveWorktreeHostId(requested) {
   if (!isLocalHostEnabled()) {
-    if (requested === LOCAL_HOST_ID6) throw new LocalHostDisabledError();
+    if (requested === LOCAL_HOST_ID7) throw new LocalHostDisabledError();
     if (requested) return requested;
     const configured = process.env.BAND_DEFAULT_HOST?.trim();
     if (configured) {
-      if (configured === LOCAL_HOST_ID6) throw new LocalHostDisabledError();
+      if (configured === LOCAL_HOST_ID7) throw new LocalHostDisabledError();
       return configured;
     }
-    const online = tokenService.listHosts().filter((h) => h.id !== LOCAL_HOST_ID6 && h.status === "online");
+    const online = tokenService.listHosts().filter((h) => h.id !== LOCAL_HOST_ID7 && h.status === "online");
     if (online.length === 1) return online[0].id;
     throw new NoDefaultHostError(
       online.length === 0 ? "No worker is online." : "More than one worker is online."
     );
   }
-  return requested ?? LOCAL_HOST_ID6;
+  return requested ?? LOCAL_HOST_ID7;
 }
-var LOCAL_HOST_ID6, LocalHostDisabledError, NoDefaultHostError;
+var LOCAL_HOST_ID7, LocalHostDisabledError, NoDefaultHostError;
 var init_local_host_policy = __esm({
   "src/server/services/local-host-policy.ts"() {
     "use strict";
     init_local_host_enabled();
     init_token_service();
-    LOCAL_HOST_ID6 = "local";
+    LOCAL_HOST_ID7 = "local";
     LocalHostDisabledError = class extends Error {
       constructor() {
         super(
@@ -61964,7 +62434,7 @@ async function reconcileOneRepo(repo) {
       repo.worktrees.filter((wt) => !isRemote(wt)).map((wt) => [wt.path, wt])
     );
     diskWorktrees = gitWorktrees.filter(
-      (wt) => !wt.isBare && !remotePaths.has(wt.path) && (!removingWorktrees.has(wt.path) || existingByPath.has(wt.path) && !removedWorktrees.has(wt.path))
+      (wt) => !wt.isBare && (!remotePaths.has(wt.path) || existingByPath.has(wt.path)) && (!removingWorktrees.has(wt.path) || existingByPath.has(wt.path) && !removedWorktrees.has(wt.path))
     ).map((wt) => {
       const existing = existingByPath.get(wt.path);
       return {
@@ -62225,6 +62695,7 @@ var init_worktree_script_service = __esm({
 // src/server/services/worktree-service.ts
 var worktree_service_exports = {};
 __export(worktree_service_exports, {
+  InvalidOriginError: () => InvalidOriginError,
   PlainRepoError: () => PlainRepoError,
   RepoNotFoundError: () => RepoNotFoundError,
   WorktreeNotFoundError: () => WorktreeNotFoundError,
@@ -62236,11 +62707,12 @@ __export(worktree_service_exports, {
   worktreeRemoveInput: () => worktreeRemoveInput,
   worktreeRunScriptInput: () => worktreeRunScriptInput,
   worktreeService: () => worktreeService,
+  worktreeSetOriginInput: () => worktreeSetOriginInput,
   worktreeSetPinnedInput: () => worktreeSetPinnedInput,
   worktreeVia: () => worktreeVia
 });
 import { randomUUID as randomUUID10 } from "node:crypto";
-import { unlinkSync as unlinkSync4 } from "node:fs";
+import { unlinkSync as unlinkSync5 } from "node:fs";
 import { join as join41, posix as posix6 } from "node:path";
 function findWorktreeRow(worktrees2, name4, hostId2) {
   const named = worktrees2.filter((wt) => wt.name === name4);
@@ -62282,7 +62754,7 @@ function expandHome(given, home, hostId2) {
   }
   return path2;
 }
-var TEARDOWN_TIMEOUT_MS, log33, worktreeVia, worktreeCreateInput, worktreeRemoveInput, worktreeSetPinnedInput, worktreeGitInput, worktreeRunScriptInput, RepoNotFoundError, PlainRepoError, WorktreeService, worktreeService;
+var TEARDOWN_TIMEOUT_MS, log33, worktreeVia, worktreeCreateInput, worktreeRemoveInput, worktreeSetPinnedInput, worktreeSetOriginInput, worktreeGitInput, worktreeRunScriptInput, RepoNotFoundError, InvalidOriginError, PlainRepoError, WorktreeService, worktreeService;
 var init_worktree_service = __esm({
   "src/server/services/worktree-service.ts"() {
     "use strict";
@@ -62383,6 +62855,14 @@ var init_worktree_service = __esm({
       hostId: external_exports2.string().optional(),
       pinned: external_exports2.boolean()
     });
+    worktreeSetOriginInput = external_exports2.object({
+      repo: external_exports2.string(),
+      // Worktree identity (immutable `name`), not the live git branch.
+      name: external_exports2.string(),
+      hostId: external_exports2.string().optional(),
+      // The parent worktree's id, or null to remove the parent.
+      origin: external_exports2.string().min(1).nullable()
+    });
     worktreeGitInput = external_exports2.object({
       repo: external_exports2.string(),
       // Worktree identity (immutable `name`), not the live git branch.
@@ -62399,6 +62879,12 @@ var init_worktree_service = __esm({
         this.name = "RepoNotFoundError";
       }
     };
+    InvalidOriginError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "InvalidOriginError";
+      }
+    };
     PlainRepoError = class extends Error {
       constructor(message) {
         super(message);
@@ -62913,7 +63399,7 @@ var init_worktree_service = __esm({
         saveState(state2);
         removal.commit();
         try {
-          unlinkSync4(join41(bandHome(), "workspace-prompts", `${worktreeId4}.json`));
+          unlinkSync5(join41(bandHome(), "workspace-prompts", `${worktreeId4}.json`));
         } catch {
         }
         deleteWorktreeStatus(worktreeId4);
@@ -63075,6 +63561,52 @@ var init_worktree_service = __esm({
         saveState(state2);
         return { ok: true };
       }
+      /**
+       * Sets a worktree's parent (its origin) by hand, or removes it with `null`. A manual parent
+       * carries no chat or terminal. Rejects the worktree itself and any descendant of it, since
+       * either would make a cycle.
+       */
+      setOrigin(input) {
+        const state2 = loadState();
+        const repo = state2.repos.find((p2) => p2.name === input.repo);
+        if (!repo) throw new RepoNotFoundError(input.repo);
+        const target = findWorktreeRow(repo.worktrees, input.name, input.hostId);
+        if (!target) throw new WorktreeNotFoundError(input.name);
+        const targetHostId = target.hostId ?? "local";
+        const worktreeId4 = toWorktreeId(repo.name, target.name, target.hostId);
+        if (input.origin !== null) {
+          const origins = /* @__PURE__ */ new Map();
+          for (const r of state2.repos) {
+            for (const wt of r.worktrees) {
+              origins.set(toWorktreeId(r.name, wt.name, wt.hostId), wt.origin?.worktreeId);
+            }
+          }
+          if (!origins.has(input.origin)) {
+            throw new InvalidOriginError(`Unknown origin worktree: ${input.origin}`);
+          }
+          if (input.origin === worktreeId4) {
+            throw new InvalidOriginError("A worktree cannot be its own parent.");
+          }
+          const seen = /* @__PURE__ */ new Set();
+          for (let id = input.origin; id && !seen.has(id); ) {
+            if (id === worktreeId4) {
+              throw new InvalidOriginError(
+                "That worktree is a descendant of this one, so it cannot be its parent."
+              );
+            }
+            seen.add(id);
+            id = origins.get(id);
+          }
+        }
+        this.repoQueries.setOrigin(
+          repo.name,
+          target.name,
+          input.origin === null ? null : { worktreeId: input.origin },
+          targetHostId
+        );
+        emit({ kind: "worktree-origin-changed", worktreeId: worktreeId4 });
+        return { ok: true };
+      }
       pruning = /* @__PURE__ */ new Set();
       /**
        * Removes the records of worktrees whose folder is gone from their host (`missing` after a scan),
@@ -63375,8 +63907,8 @@ var init_worktree_service = __esm({
           throw new Error(`Script "${input.scriptType}" not found`);
         }
         try {
-          const { file: file2, args } = scriptInvocation(scriptPath);
-          await host.exec(file2, args, { cwd: input.path });
+          const { file: file3, args } = scriptInvocation(scriptPath);
+          await host.exec(file3, args, { cwd: input.path });
         } catch (err) {
           throw new Error(err instanceof Error ? err.message : String(err));
         }
@@ -63388,15 +63920,6 @@ var init_worktree_service = __esm({
 });
 
 // src/server/services/task-service.ts
-function observePending() {
-  if (observingPending) return;
-  observingPending = true;
-  agentSessionService.observePending((chatId, worktreeId4) => {
-    if (tasks2.get(chatId)?.status !== "running") return;
-    const waiting = agentSessionService.hasPendingRequest(chatId);
-    setScopeStatus(worktreeId4, chatId, waiting ? "needs_attention" : "working");
-  });
-}
 function persistTask(task) {
   const worktree = worktreeService.resolve(task.worktreeId);
   try {
@@ -63429,19 +63952,19 @@ function fileUri(path2) {
 async function promptBlocks(task, firstTurn, sharedDir) {
   const caps = agentSessionService.promptCapabilities(task.chatId);
   const blocks = [{ type: "text", text: task.prompt }];
-  for (const file2 of task.attachments) {
-    const name4 = file2.filename ?? file2.path.split("/").pop() ?? file2.path;
-    if (caps.image && file2.mediaType.startsWith("image/")) {
+  for (const file3 of task.attachments) {
+    const name4 = file3.filename ?? file3.path.split("/").pop() ?? file3.path;
+    if (caps.image && file3.mediaType.startsWith("image/")) {
       try {
         const host = hostRegistry.hostFor(task.worktreeId);
-        const data = Buffer.from(await host.fs.readFile(file2.path)).toString("base64");
-        blocks.push({ type: "image", mimeType: file2.mediaType, data, uri: fileUri(file2.path) });
+        const data = Buffer.from(await host.fs.readFile(file3.path)).toString("base64");
+        blocks.push({ type: "image", mimeType: file3.mediaType, data, uri: fileUri(file3.path) });
         continue;
       } catch (err) {
-        log34.warn({ path: file2.path, err }, "could not read image attachment; linking it instead");
+        log34.warn({ path: file3.path, err }, "could not read image attachment; linking it instead");
       }
     }
-    blocks.push({ type: "resource_link", uri: fileUri(file2.path), name: name4, mimeType: file2.mediaType });
+    blocks.push({ type: "resource_link", uri: fileUri(file3.path), name: name4, mimeType: file3.mediaType });
   }
   if (firstTurn) {
     blocks.push({
@@ -63486,10 +64009,6 @@ function turnUsage(chatId, res, previousCost) {
   });
   return { ...usage, model, costUsd: (previousCost ?? 0) + cost };
 }
-function setScopeStatus(scope3, chatId, status) {
-  const updated = setWorktreeSourceStatus(scope3, chatStatusSource(chatId), { status });
-  emit({ kind: "update", status: updated });
-}
 function submitTask(options) {
   const { worktreeId: worktreeId4, chatId, prompt, sessionId, mode, model, codingAgentId } = options;
   if (worktreeService.resolve(worktreeId4) === null) {
@@ -63499,7 +64018,7 @@ function submitTask(options) {
   if (existing?.status === "running") {
     throw new TaskConflictError(chatId);
   }
-  observePending();
+  observeAgentStatus(hasRunningTask);
   const task = {
     id: generateTaskId(),
     worktreeId: worktreeId4,
@@ -63543,7 +64062,7 @@ function submitOrQueueTask(options) {
 async function runTask(task) {
   const { chatId } = task;
   chatService.updateStatus(chatId, "running");
-  setScopeStatus(task.worktreeId, chatId, "working");
+  beginBandTurn(task.worktreeId, chatId);
   const chat = chatService.get(chatId);
   if (task.codingAgentId && chat && task.codingAgentId !== chat.agent) {
     agentSessionService.stop(chatId);
@@ -63643,7 +64162,7 @@ async function runTask(task) {
       durationMs: Date.now() - task.startedAt,
       usage: turnUsage(chatId, res, previousCost)
     });
-    finishTask(task, res.stopReason === "cancelled" ? "cancelled" : "completed");
+    finishTask(task, res.stopReason === "cancelled" ? "cancelled" : "completed", res.stopReason);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     agentSessionService.record(chatId, {
@@ -63667,7 +64186,7 @@ async function applyTurnChoice(chatId, category, value) {
     log34.warn({ chatId, category, value, err }, "could not apply the task's setting");
   }
 }
-function finishTask(task, outcome) {
+function finishTask(task, outcome, stopReason) {
   if (task.status !== "running") return;
   const status = outcome === "completed" ? "completed" : "failed";
   task.status = status;
@@ -63678,7 +64197,8 @@ function finishTask(task, outcome) {
   if (status === "completed" && drainQueue(task.worktreeId, task.chatId)) return;
   chatService.updateStatus(task.chatId, status === "completed" ? "idle" : "error");
   const stopped = outcome === "cancelled" || task.cancelRequested === true;
-  setScopeStatus(task.worktreeId, task.chatId, stopped ? "waiting" : "needs_attention");
+  const failed = outcome === "failed" || stopReason !== void 0 && FAILED_STOP_REASONS.has(stopReason);
+  endBandTurn(task.worktreeId, task.chatId, stopped ? "idle" : failed ? "failed" : "done");
 }
 function drainQueue(worktreeId4, chatId) {
   const queued = peekQueuedMessage(chatId);
@@ -63721,7 +64241,7 @@ function cancelTask(taskId) {
   const record3 = taskQueries.markFailed(taskId);
   if (record3) {
     if (record3.chatId) {
-      setScopeStatus(record3.worktreeId, record3.chatId, "waiting");
+      setChatStatus(record3.worktreeId, record3.chatId, "idle");
     }
     log34.info({ taskId, worktreeId: record3.worktreeId }, "orphaned task cancelled");
     return { cancelled: true, worktreeId: record3.worktreeId };
@@ -63735,7 +64255,7 @@ function getTask(chatId) {
   const task = tasks2.get(chatId);
   return task ? toTaskInfo(task) : null;
 }
-var log34, taskQueries, TASKS_KEY, g4, tasks2, observingPending, TaskConflictError, TaskService, taskService;
+var log34, taskQueries, TASKS_KEY, g4, tasks2, TaskConflictError, FAILED_STOP_REASONS, TaskService, taskService;
 var init_task_service = __esm({
   "src/server/services/task-service.ts"() {
     "use strict";
@@ -63750,8 +64270,8 @@ var init_task_service = __esm({
     init_turn_events();
     init_agent_session_service();
     init_chat_service();
+    init_chat_status_service();
     init_state();
-    init_watcher_service();
     init_worktree_service();
     log34 = createLogger("task-service");
     taskQueries = new TaskQueries();
@@ -63759,13 +64279,13 @@ var init_task_service = __esm({
     g4 = globalThis;
     if (!g4[TASKS_KEY]) g4[TASKS_KEY] = /* @__PURE__ */ new Map();
     tasks2 = g4[TASKS_KEY];
-    observingPending = false;
     TaskConflictError = class extends Error {
       constructor(chatId) {
         super(`Task already running for chat ${chatId}`);
         this.name = "TaskConflictError";
       }
     };
+    FAILED_STOP_REASONS = /* @__PURE__ */ new Set(["refusal", "max_tokens", "max_turn_requests"]);
     TaskService = class {
       constructor(queries3 = taskQueries) {
         this.queries = queries3;
@@ -63785,13 +64305,10 @@ var init_task_service = __esm({
       getTask(chatId) {
         return getTask(chatId);
       }
-      /** Clears the worktree's attention status, except for chats whose agent
-       *  still waits on the user (a permission or elicitation request). */
+      /** Sets the worktree's finished chats (`done`, `failed`) back to `idle`. A
+       *  chat whose agent still waits on the user keeps its `question`. */
       acknowledgeAttention(worktreeId4) {
-        return acknowledgeWorktreeAttention(
-          worktreeId4,
-          agentSessionService.chatsWithPendingRequest(worktreeId4)
-        );
+        return acknowledgeWorktreeAttention(worktreeId4);
       }
       listTaskRecords(filters) {
         return this.queries.list(filters);
@@ -65365,9 +65882,88 @@ function parseReview(data, branch, defaultBranch) {
     updatedAt: pr.updatedAt,
     reviewDecision: reviewDecision(pr.reviewDecision),
     mergeState: mergeState(pr.mergeStateStatus),
-    checks: report(head?.oid ?? null, checks)
+    checks: report(head?.oid ?? null, checks),
+    reviewers: parseReviewers(pr),
+    discussion: parseDiscussion(pr)
   };
 }
+function parseReviewers(pr) {
+  const byLogin = /* @__PURE__ */ new Map();
+  const order = [...pr.reviews?.nodes ?? []].sort(
+    (a, b2) => (a.submittedAt ?? "").localeCompare(b2.submittedAt ?? "")
+  );
+  for (const review of order) {
+    const state2 = REVIEWER_STATES[review.state];
+    if (!state2 || !review.author) continue;
+    const existing = byLogin.get(review.author.login);
+    if (existing && state2 === "commented" && existing.state !== "commented") continue;
+    byLogin.set(review.author.login, {
+      ...actorOf(review.author),
+      state: state2,
+      submittedAt: review.submittedAt
+    });
+  }
+  for (const request of pr.reviewRequests?.nodes ?? []) {
+    const who = request.requestedReviewer;
+    if (!who) continue;
+    const actor = who.__typename === "Team" ? { login: who.slug, avatarUrl: null } : actorOf({ login: who.login, avatarUrl: who.avatarUrl });
+    const key2 = who.__typename === "Team" ? `team:${actor.login}` : actor.login;
+    const previous = byLogin.get(key2);
+    byLogin.set(key2, {
+      ...actor,
+      state: "pending",
+      submittedAt: previous?.submittedAt ?? null,
+      ...request.asCodeOwner ? { required: true } : {}
+    });
+  }
+  return [...byLogin.values()];
+}
+function fromCommentNode(node) {
+  return {
+    id: node.id,
+    author: actorOf(node.author),
+    body: node.body,
+    createdAt: node.createdAt,
+    url: webUrl(node.url)
+  };
+}
+function parseDiscussion(pr) {
+  const items = [];
+  for (const node of pr.comments?.nodes ?? []) {
+    items.push({ ...fromCommentNode(node), kind: "comment" });
+  }
+  for (const review of pr.reviews?.nodes ?? []) {
+    const state2 = REVIEWER_STATES[review.state];
+    if (!state2 || !review.body.trim() || !review.submittedAt) continue;
+    items.push({
+      id: review.id,
+      kind: "review",
+      reviewState: state2,
+      author: actorOf(review.author),
+      body: review.body,
+      createdAt: review.submittedAt,
+      url: webUrl(review.url)
+    });
+  }
+  items.sort((a, b2) => a.createdAt.localeCompare(b2.createdAt));
+  const threads = [];
+  for (const node of pr.reviewThreads?.nodes ?? []) {
+    const comments = node.comments.nodes.map(fromCommentNode);
+    if (comments.length === 0) continue;
+    threads.push({
+      id: node.id,
+      path: node.path,
+      line: node.line ?? node.originalLine,
+      isResolved: node.isResolved,
+      isOutdated: node.isOutdated,
+      comments,
+      ...node.comments.totalCount > comments.length ? { truncated: true } : {}
+    });
+  }
+  threads.sort((a, b2) => a.comments[0].createdAt.localeCompare(b2.comments[0].createdAt));
+  const truncated = (pr.comments?.totalCount ?? 0) > (pr.comments?.nodes.length ?? 0) || (pr.reviews?.totalCount ?? 0) > (pr.reviews?.nodes.length ?? 0) || (pr.reviewThreads?.totalCount ?? 0) > (pr.reviewThreads?.nodes.length ?? 0);
+  return { items, threads, ...truncated ? { truncated: true } : {} };
+}
 function parseBranchChecks(data) {
   const target = data.repository?.ref?.target;
   const latest = /* @__PURE__ */ new Map();
@@ -65484,10 +66080,16 @@ function reviewDecision(value) {
 function mergeState(value) {
   return value && MERGE_STATES[value] || "unknown";
 }
-var CHECK_RUN_FIELDS, REVIEW_QUERY, LIST_ORDER, AGGREGATE_PRIORITY, MERGE_STATES;
+var MAX_COMMENTS, MAX_REVIEWS, MAX_THREADS, MAX_THREAD_COMMENTS, MAX_REVIEW_REQUESTS, ACTOR, CHECK_RUN_FIELDS, REVIEW_QUERY, REVIEWER_STATES, actorOf, LIST_ORDER, AGGREGATE_PRIORITY, MERGE_STATES;
 var init_checks_query = __esm({
   "../../plugins/github/src/server/checks-query.ts"() {
     "use strict";
+    MAX_COMMENTS = 50;
+    MAX_REVIEWS = 50;
+    MAX_THREADS = 50;
+    MAX_THREAD_COMMENTS = 20;
+    MAX_REVIEW_REQUESTS = 30;
+    ACTOR = "login avatarUrl";
     CHECK_RUN_FIELDS = `
   databaseId
   name
@@ -65512,6 +66114,41 @@ var init_checks_query = __esm({
         updatedAt
         mergeStateStatus
         reviewDecision
+        reviewRequests(first: ${MAX_REVIEW_REQUESTS}) {
+          nodes {
+            asCodeOwner
+            requestedReviewer {
+              __typename
+              ... on User { ${ACTOR} }
+              ... on Bot { ${ACTOR} }
+              ... on Mannequin { ${ACTOR} }
+              ... on Team { slug }
+            }
+          }
+        }
+        reviews(last: ${MAX_REVIEWS}) {
+          totalCount
+          nodes { id state body submittedAt url author { ${ACTOR} } }
+        }
+        comments(last: ${MAX_COMMENTS}) {
+          totalCount
+          nodes { id body createdAt url author { ${ACTOR} } }
+        }
+        reviewThreads(first: ${MAX_THREADS}) {
+          totalCount
+          nodes {
+            id
+            isResolved
+            isOutdated
+            path
+            line
+            originalLine
+            comments(first: ${MAX_THREAD_COMMENTS}) {
+              totalCount
+              nodes { id body createdAt url author { ${ACTOR} } }
+            }
+          }
+        }
         commits(last: 1) {
           nodes {
             commit {
@@ -65549,6 +66186,16 @@ var init_checks_query = __esm({
     }
   }
 }`;
+    REVIEWER_STATES = {
+      APPROVED: "approved",
+      CHANGES_REQUESTED: "changes_requested",
+      COMMENTED: "commented",
+      DISMISSED: "dismissed"
+    };
+    actorOf = (author) => ({
+      login: author?.login ?? "ghost",
+      avatarUrl: webUrl(author?.avatarUrl ?? null)
+    });
     LIST_ORDER = {
       failure: 0,
       running: 1,
@@ -68049,11 +68696,14 @@ function stopRuntime(rt) {
 }
 function idleTimeoutMs2() {
   const override = Number(process.env.BAND_AGENT_IDLE_TIMEOUT_MS);
-  return Number.isFinite(override) && override > 0 ? override : IDLE_TIMEOUT_MS;
+  return Number.isFinite(override) && override > 0 ? override : null;
 }
-function scheduleIdle(rt, delayMs = idleTimeoutMs2()) {
+function scheduleIdle(rt, delayMs) {
   if (rt.idleTimer) clearTimeout(rt.idleTimer);
-  const delay2 = Math.min(delayMs, MAX_TIMER_MS);
+  rt.idleTimer = null;
+  const timeout = idleTimeoutMs2();
+  if (timeout === null) return;
+  const delay2 = Math.min(delayMs ?? timeout, MAX_TIMER_MS2);
   rt.idleTimer = setTimeout(() => {
     rt.idleTimer = null;
     if (rt.inTurn || rt.pending.size > 0 || rt.attaching) return;
@@ -68068,7 +68718,7 @@ function scheduleIdle(rt, delayMs = idleTimeoutMs2()) {
         },
         "idle agent has pending work; not stopping it"
       );
-      scheduleIdle(rt, until - now + idleTimeoutMs2());
+      scheduleIdle(rt, until - now + timeout);
       return;
     }
     log46.info({ chatId: rt.chatId }, "stopping idle agent");
@@ -68208,6 +68858,9 @@ function routeUpdate(rt, notification) {
   if (!rt.attaching) {
     rt.work.observeUpdate(update, rt.inTurn);
     agentActive(rt);
+    if (!rt.inTurn && rt.routing === "log" && AGENT_WORK_UPDATES.has(update.sessionUpdate)) {
+      activityObserver?.(rt.chatId, rt.worktreeId, "update");
+    }
   }
   if (rt.routing === "drop") return;
   if (update.sessionUpdate === "user_message_chunk") {
@@ -68283,6 +68936,7 @@ function handlersFor(rt, generation) {
       if (n.sessionId !== rt.sessionId || rt.attaching) return;
       rt.work.observeAsyncTask(n.update);
       agentActive(rt);
+      activityObserver?.(rt.chatId, rt.worktreeId, "work");
     },
     onPermission: (req, signal) => requestPermission(rt, req, signal),
     onElicitation: (req, signal) => requestElicitation(rt, req, signal),
@@ -68582,14 +69236,14 @@ function sessionCost(sessionId) {
   const row = events.latest(sessionId, revision, { kind: "turn-ended" });
   return row?.event.type === "turn-ended" ? row.event.usage?.costUsd ?? null : null;
 }
-var log46, IDLE_TIMEOUT_MS, CANCEL_GRACE_MS, MAX_TIMER_MS, PROBE_SETTLE_MS, events, settings, RUNTIMES_KEY, LISTENERS_KEY2, CATALOG_KEY, DEFAULTS_CHANGED_KEY, g6, runtimes, listeners2, catalog, defaultsChangedAt, transientId, pendingObserver, ChatNotFoundError, AgentSessionService, agentSessionService;
+var log46, CANCEL_GRACE_MS, MAX_TIMER_MS2, PROBE_SETTLE_MS, events, settings, RUNTIMES_KEY, LISTENERS_KEY2, CATALOG_KEY, DEFAULTS_CHANGED_KEY, g6, runtimes, listeners2, catalog, defaultsChangedAt, transientId, pendingObserver, AGENT_WORK_UPDATES, activityObserver, ChatNotFoundError, AgentSessionService, agentSessionService;
 var init_agent_session_service = __esm({
   "src/server/services/agent-session-service.ts"() {
     "use strict";
     init_src2();
     init_src();
     init_acp_agent_process();
-    init_chat_events();
+    init_chat_events2();
     init_settings();
     init_registry();
     init_agent_pending_work();
@@ -68600,9 +69254,8 @@ var init_agent_session_service = __esm({
     init_mcp_proxy_service();
     init_worktree_service();
     log46 = createLogger("agent-sessions");
-    IDLE_TIMEOUT_MS = 15 * 6e4;
     CANCEL_GRACE_MS = 15e3;
-    MAX_TIMER_MS = 2 ** 31 - 1;
+    MAX_TIMER_MS2 = 2 ** 31 - 1;
     PROBE_SETTLE_MS = 1500;
     events = new ChatEventQueries();
     settings = new SettingsQueries();
@@ -68621,6 +69274,15 @@ var init_agent_session_service = __esm({
     defaultsChangedAt = g6[DEFAULTS_CHANGED_KEY];
     transientId = -1e9;
     pendingObserver = null;
+    AGENT_WORK_UPDATES = /* @__PURE__ */ new Set([
+      "user_message_chunk",
+      "agent_message_chunk",
+      "agent_thought_chunk",
+      "tool_call",
+      "tool_call_update",
+      "plan"
+    ]);
+    activityObserver = null;
     ChatNotFoundError = class extends Error {
       constructor(chatId) {
         super(`Chat not found: ${chatId}`);
@@ -68647,6 +69309,16 @@ var init_agent_session_service = __esm({
       observePending(observer) {
         pendingObserver = observer;
       }
+      /** Called when the agent acts outside a turn Band started: an update from
+       *  a turn of its own, or a background task starting or ending. */
+      observeActivity(observer) {
+        activityObserver = observer;
+      }
+      /** The soonest time one of the chat's pending-work holds lapses, or null with none. */
+      nextWorkDeadline(chatId) {
+        const holds = runtimes.get(chatId)?.work.outstanding() ?? [];
+        return holds.length > 0 ? Math.min(...holds.map((h) => h.until)) : null;
+      }
       /**
        * Makes sure the chat's agent process runs and is attached to the chat's
        * session, starting a new session when the chat has none. For `view`,
@@ -73424,11 +74096,11 @@ var require_core = __commonJS({
     Ajv2.ValidationError = validation_error_1.default;
     Ajv2.MissingRefError = ref_error_1.default;
     exports.default = Ajv2;
-    function checkOptions(checkOpts, options, msg, log77 = "error") {
+    function checkOptions(checkOpts, options, msg, log78 = "error") {
       for (const key2 in checkOpts) {
         const opt = key2;
         if (opt in options)
-          this.logger[log77](`${msg}: option ${key2}. ${checkOpts[opt]}`);
+          this.logger[log78](`${msg}: option ${key2}. ${checkOpts[opt]}`);
       }
     }
     function getSchEnv(keyRef) {
@@ -75914,10 +76586,10 @@ init_agent_spawn();
 import {
   appendFileSync as appendFileSync2,
   createReadStream as createReadStream5,
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync10,
   readFileSync as readFileSync12,
-  statSync as statSync13
+  statSync as statSync15
 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
 import { basename as basename7, join as join55, resolve as resolve14, sep as sep10 } from "node:path";
@@ -75928,7 +76600,7 @@ import { parseArgs } from "node:util";
 init_src();
 init_daemon_backend();
 init_in_process_backend();
-import { existsSync as existsSync4, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync5, statSync as statSync5 } from "node:fs";
 import { join as join7 } from "node:path";
 var log4 = createLogger("terminal-backend");
 function createTerminalBackend(serverRoot, bandHome2) {
@@ -75937,7 +76609,7 @@ function createTerminalBackend(serverRoot, bandHome2) {
   const entry = [
     join7(serverRoot, "terminal-daemon.mjs"),
     join7(serverRoot, "terminal-daemon.ts")
-  ].find((candidate) => existsSync4(candidate));
+  ].find((candidate) => existsSync5(candidate));
   if (!entry) {
     log4.error(
       { serverRoot },
@@ -75945,7 +76617,7 @@ function createTerminalBackend(serverRoot, bandHome2) {
     );
     return new InProcessTerminalBackend();
   }
-  const { size, mtimeMs } = statSync4(entry);
+  const { size, mtimeMs } = statSync5(entry);
   return new DaemonTerminalBackend({
     entry,
     runDir: join7(bandHome2, "run"),
@@ -78243,14 +78915,14 @@ import { join as join9, normalize, resolve as resolve2, sep as sep2 } from "node
 
 // ../../node_modules/.pnpm/totalist@3.0.1/node_modules/totalist/sync/index.mjs
 import { join as join8, resolve } from "path";
-import { readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync6 } from "fs";
 function totalist(dir, callback, pre = "") {
   dir = resolve(".", dir);
   let arr = readdirSync5(dir);
   let i = 0, abs, stats;
   for (; i < arr.length; i++) {
     abs = join8(dir, arr[i]);
-    stats = statSync5(abs);
+    stats = statSync6(abs);
     stats.isDirectory() ? totalist(abs, callback, join8(pre, arr[i])) : callback(join8(pre, arr[i]), abs, stats);
   }
 }
@@ -78774,7 +79446,7 @@ function viaLocal(dir, isEtag, uri, extns) {
 function is404(req, res) {
   return res.statusCode = 404, res.end();
 }
-function send(req, res, file2, stats, headers) {
+function send(req, res, file3, stats, headers) {
   let code = 200, tmp, opts = {};
   headers = { ...headers };
   for (let key2 in headers) {
@@ -78802,7 +79474,7 @@ function send(req, res, file2, stats, headers) {
     headers["Accept-Ranges"] = "bytes";
   }
   res.writeHead(code, headers);
-  fs.createReadStream(file2, opts).pipe(res);
+  fs.createReadStream(file3, opts).pipe(res);
 }
 var ENCODING = {
   ".br": "br",
@@ -79071,11 +79743,7 @@ function createCorsMiddleware(getAllowedOrigins) {
 
 // src/api/chat-events.ts
 init_src();
-
-// ../../packages/shared/src/chat-events.ts
-var HISTORY_PAGE_SIZE = 20;
-
-// src/api/chat-events.ts
+init_chat_events();
 init_queued_message_store();
 
 // src/server/services/_utils/sse-writer.ts
@@ -79290,6 +79958,7 @@ async function handleChatEvents(req, res, chatId) {
 }
 
 // src/api/chat-history.ts
+init_chat_events();
 init_agent_session_service();
 init_chat_service();
 var MAX_CHAT_ID_LENGTH = 200;
@@ -79524,7 +80193,7 @@ init_map_limited();
 init_remote_worktrees();
 init_repo_host_policy();
 init_ephemeral_lifecycle_service();
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { basename as basename2, join as join44, posix as posix7, resolve as resolve9 } from "node:path";
 
 // src/server/services/repo-avatar-service.ts
@@ -79916,7 +80585,7 @@ var RepoService = class {
       }
     }
     const resolvedPath = resolve9(path2);
-    const kind = existsSync14(join44(resolvedPath, ".git")) ? "git" : "plain";
+    const kind = existsSync15(join44(resolvedPath, ".git")) ? "git" : "plain";
     let defaultBranch = "main";
     let worktrees2 = [];
     if (kind === "git") {
@@ -80253,15 +80922,15 @@ var RepoService = class {
       ...isLocalHostEnabled() ? ["local"] : [],
       ...tokenService.listHosts().filter((h) => h.id !== "local" && h.status === "online").map((h) => h.id)
     ];
-    let failure = "no host is available to ask";
+    let failure2 = "no host is available to ask";
     for (const hostId2 of hostIds2) {
       try {
         const { stdout } = await hostRegistry.hostById(hostId2).exec("git", ["ls-remote", "--symref", "--", url2, "HEAD"], { timeoutMs: 6e4 });
         const match = stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m);
         if (match) return match[1];
-        failure = "the remote did not report a default branch";
+        failure2 = "the remote did not report a default branch";
       } catch (err) {
-        failure = err instanceof Error ? err.message : String(err);
+        failure2 = err instanceof Error ? err.message : String(err);
       }
     }
     if (asked?.host) {
@@ -80271,7 +80940,7 @@ var RepoService = class {
       if (viaApi) return viaApi;
     }
     throw new RepoInputError(
-      `Could not read the default branch of ${asked?.url ?? url2} (${failure}). Pass the branch.`
+      `Could not read the default branch of ${asked?.url ?? url2} (${failure2}). Pass the branch.`
     );
   }
   /**
@@ -80294,7 +80963,7 @@ var RepoService = class {
         message: `Repo "${name4}" is already a git repo`
       });
     }
-    if (!existsSync14(repo.path)) {
+    if (!existsSync15(repo.path)) {
       throw new TRPCError({
         code: "NOT_FOUND",
         message: `Repo path "${repo.path}" no longer exists. Remove the repo and re-add it.`
@@ -80511,7 +81180,7 @@ var DEFAULT_MAX_BYTES = 200 * 1024 * 1024;
 var DEFAULT_QUIET_MS = 3 * 6e4;
 var DEFAULT_POLL_MS2 = 6e4;
 var MAX_VIEW_BYTES = 1024 * 1024;
-var LOCAL_HOST_ID7 = "local";
+var LOCAL_HOST_ID8 = "local";
 var errorText3 = (err) => err instanceof Error ? err.message : String(err);
 function envNumber2(name4, fallback) {
   const raw = Number(process.env[name4]);
@@ -80519,7 +81188,7 @@ function envNumber2(name4, fallback) {
 }
 var checkpointKeep = () => Math.floor(envNumber2("BAND_CHECKPOINT_KEEP", DEFAULT_KEEP));
 var checkpointMaxBytes = () => envNumber2("BAND_CHECKPOINT_MAX_BYTES", DEFAULT_MAX_BYTES);
-var quietMs = () => envNumber2("BAND_CHECKPOINT_QUIET_MS", DEFAULT_QUIET_MS);
+var quietMs2 = () => envNumber2("BAND_CHECKPOINT_QUIET_MS", DEFAULT_QUIET_MS);
 var pollMs = () => envNumber2("BAND_CHECKPOINT_POLL_MS", DEFAULT_POLL_MS2);
 function toView2(row) {
   return {
@@ -80536,11 +81205,11 @@ function toView2(row) {
     sessions: row.sessionIds.length
   };
 }
-function isSafeSessionFile(file2) {
-  if (!/^[A-Za-z0-9_-]+$/.test(file2.root)) return false;
-  if (typeof file2.rel !== "string" || file2.rel === "" || file2.rel.includes("\0")) return false;
-  if (posix8.isAbsolute(file2.rel)) return false;
-  const clean = posix8.normalize(file2.rel);
+function isSafeSessionFile(file3) {
+  if (!/^[A-Za-z0-9_-]+$/.test(file3.root)) return false;
+  if (typeof file3.rel !== "string" || file3.rel === "" || file3.rel.includes("\0")) return false;
+  if (posix8.isAbsolute(file3.rel)) return false;
+  const clean = posix8.normalize(file3.rel);
   return clean !== ".." && !clean.startsWith("../") && clean !== ".";
 }
 function sessionsHashOf(files) {
@@ -80629,8 +81298,8 @@ var CheckpointService = class {
   ineligible(worktreeId4) {
     const found = worktreeService.resolve(worktreeId4);
     if (!found) return "unknown worktree";
-    const hostId2 = found.worktree.hostId ?? LOCAL_HOST_ID7;
-    if (hostId2 === LOCAL_HOST_ID7) return "the worktree is on the hub's own machine";
+    const hostId2 = found.worktree.hostId ?? LOCAL_HOST_ID8;
+    if (hostId2 === LOCAL_HOST_ID8) return "the worktree is on the hub's own machine";
     if (found.repo.kind !== "git") return "not a git repo";
     if (found.worktree.supersededBy) return "superseded";
     if (this.busy.has(worktreeId4)) return "busy";
@@ -80673,7 +81342,7 @@ var CheckpointService = class {
     const out = [];
     for (const repo of loadState().repos) {
       for (const wt of repo.worktrees) {
-        if ((wt.hostId ?? LOCAL_HOST_ID7) === hostId2) {
+        if ((wt.hostId ?? LOCAL_HOST_ID8) === hostId2) {
           out.push({
             repo: repo.name,
             name: wt.name,
@@ -80687,8 +81356,8 @@ var CheckpointService = class {
   async doTake(worktreeId4, trigger, opts) {
     const found = worktreeService.resolve(worktreeId4);
     if (!found) throw new CheckpointError("invalid", `Unknown worktree "${worktreeId4}"`);
-    const hostId2 = found.worktree.hostId ?? LOCAL_HOST_ID7;
-    if (hostId2 === LOCAL_HOST_ID7) {
+    const hostId2 = found.worktree.hostId ?? LOCAL_HOST_ID8;
+    if (hostId2 === LOCAL_HOST_ID8) {
       throw new CheckpointError(
         "invalid",
         "Checkpoints are for worktrees on a worker, not on the hub's own machine."
@@ -80875,7 +81544,7 @@ var CheckpointService = class {
           if (this.ineligible(worktreeId4)) continue;
           live.add(worktreeId4);
           try {
-            await this.sweepOne(worktreeId4, wt.hostId ?? LOCAL_HOST_ID7, wt.path);
+            await this.sweepOne(worktreeId4, wt.hostId ?? LOCAL_HOST_ID8, wt.path);
           } catch (err) {
             log49.debug({ worktreeId: worktreeId4, err: errorText3(err) }, "checkpoint sweep skipped a worktree");
           }
@@ -80899,7 +81568,7 @@ var CheckpointService = class {
       this.watches.set(worktreeId4, { signature, changedAt: now, checkpointed: watch.checkpointed });
       return;
     }
-    if (watch.checkpointed === signature || now - watch.changedAt < quietMs()) return;
+    if (watch.checkpointed === signature || now - watch.changedAt < quietMs2()) return;
     await this.take(worktreeId4, "quiet");
   }
   /**
@@ -81074,11 +81743,11 @@ ${diff}`).digest("hex");
     const found = worktreeService.resolve(worktreeId4);
     if (!found) throw new CheckpointError("invalid", `Unknown worktree "${worktreeId4}"`);
     const { repo, worktree } = found;
-    const fromHostId = worktree.hostId ?? LOCAL_HOST_ID7;
+    const fromHostId = worktree.hostId ?? LOCAL_HOST_ID8;
     if (fromHostId === toHostId) {
       throw new CheckpointError("invalid", `${worktreeId4} is already on ${toHostId}.`);
     }
-    if (toHostId === LOCAL_HOST_ID7) {
+    if (toHostId === LOCAL_HOST_ID8) {
       throw new CheckpointError(
         "invalid",
         "A worktree can be restored on a worker, not on the hub's own machine."
@@ -81111,7 +81780,7 @@ ${diff}`).digest("hex");
       }
     }
     if (repo.worktrees.some(
-      (w2) => w2.name === worktree.name && (w2.hostId ?? LOCAL_HOST_ID7) === toHostId
+      (w2) => w2.name === worktree.name && (w2.hostId ?? LOCAL_HOST_ID8) === toHostId
     )) {
       throw new CheckpointError(
         "conflict",
@@ -81250,11 +81919,11 @@ ${diff}`).digest("hex");
     }
     const stage = posix8.join(wipDir, "sessions", `${row.id}`);
     await host.fs.rm(stage, { recursive: true, force: true });
-    for (const file2 of files) {
-      if (!isSafeSessionFile(file2)) continue;
-      const target = posix8.join(stage, file2.root, file2.rel);
+    for (const file3 of files) {
+      if (!isSafeSessionFile(file3)) continue;
+      const target = posix8.join(stage, file3.root, file3.rel);
       await host.fs.mkdir(posix8.dirname(target), { recursive: true });
-      await host.fs.writeFile(target, Buffer.from(file2.data, "base64"));
+      await host.fs.writeFile(target, Buffer.from(file3.data, "base64"));
     }
     await rpc.call(METHOD_LIFECYCLE_IMPORT_SESSIONS, { dir: stage });
   }
@@ -81266,8 +81935,8 @@ ${diff}`).digest("hex");
     const { worktreeId: worktreeId4 } = input;
     const found = worktreeService.resolve(worktreeId4);
     if (!found) throw new CheckpointError("invalid", `Unknown worktree "${worktreeId4}"`);
-    const fromHostId = found.worktree.hostId ?? LOCAL_HOST_ID7;
-    if (fromHostId === LOCAL_HOST_ID7) {
+    const fromHostId = found.worktree.hostId ?? LOCAL_HOST_ID8;
+    if (fromHostId === LOCAL_HOST_ID8) {
       throw new CheckpointError("invalid", "Only worktrees on a worker can be moved.");
     }
     if (!this.sessions.get(fromHostId)?.attached) {
@@ -81335,7 +82004,7 @@ ${diff}`).digest("hex");
     for (const repo of loadState().repos) {
       const clone3 = hostRegistry.repoPathOn(repo.name, hostId2, "");
       for (const wt of repo.worktrees) {
-        if ((wt.hostId ?? LOCAL_HOST_ID7) !== hostId2 || wt.supersededBy) continue;
+        if ((wt.hostId ?? LOCAL_HOST_ID8) !== hostId2 || wt.supersededBy) continue;
         if (clone3 && wt.path === clone3) continue;
         out.push({
           repo: repo.name,
@@ -81682,7 +82351,7 @@ init_token_service();
 init_worktree_script_service();
 init_worktree_service();
 var log51 = createLogger("follow");
-var LOCAL_HOST_ID8 = "local";
+var LOCAL_HOST_ID9 = "local";
 var errorText4 = (err) => err instanceof Error ? err.message : String(err);
 function autoContinueMaxAgeMs() {
   const raw = Number(process.env.BAND_AUTO_CONTINUE_MAX_AGE_MS);
@@ -81697,7 +82366,7 @@ var FollowService = class {
   locate(worktreeId4) {
     const found = worktreeService.resolve(worktreeId4);
     if (!found) return null;
-    return { ...found, hostId: found.worktree.hostId ?? LOCAL_HOST_ID8 };
+    return { ...found, hostId: found.worktree.hostId ?? LOCAL_HOST_ID9 };
   }
   /**
    * Whether the worktree is on a worker that is offline and is not asleep. A sleeping worktree
@@ -81706,7 +82375,7 @@ var FollowService = class {
   isOffline(worktreeId4) {
     const at = this.locate(worktreeId4);
     if (!at) return false;
-    if (at.hostId === LOCAL_HOST_ID8) return false;
+    if (at.hostId === LOCAL_HOST_ID9) return false;
     if (at.worktree.supersededBy) return false;
     if (checkpointService.isHostOnline(at.hostId)) return false;
     if (ephemeralLifecycleService.stateOf(worktreeId4)) return false;
@@ -81761,7 +82430,7 @@ var FollowService = class {
       blocked: { reason, message },
       question: message
     });
-    if (hostId2 === LOCAL_HOST_ID8) {
+    if (hostId2 === LOCAL_HOST_ID9) {
       return blocked("not-offline", "This worktree is on the hub's own machine, which is up.");
     }
     if (worktree.supersededBy) {
@@ -81793,12 +82462,12 @@ var FollowService = class {
     const needed = this.neededAgents(worktreeId4, opts);
     const clones = new Set(
       [...this.repos.allHostPaths().get(repo.name)?.keys() ?? []].filter(
-        (id) => id !== LOCAL_HOST_ID8
+        (id) => id !== LOCAL_HOST_ID9
       )
     );
     const load = await this.loadByHost();
     const candidates = tokenService.listHosts(1e3).filter(
-      (h) => h.id !== LOCAL_HOST_ID8 && h.id !== hostId2 && h.status === "online" && checkpointService.isHostOnline(h.id) && !checkpointService.isHostEphemeral(h.id) && isHostAllowed(allowed2, h.id)
+      (h) => h.id !== LOCAL_HOST_ID9 && h.id !== hostId2 && h.status === "online" && checkpointService.isHostOnline(h.id) && !checkpointService.isHostEphemeral(h.id) && isHostAllowed(allowed2, h.id)
     );
     if (candidates.length === 0) {
       return {
@@ -81867,7 +82536,7 @@ var FollowService = class {
     for (const repo of this.repos.loadAll()) {
       for (const wt of repo.worktrees) {
         if (wt.supersededBy) continue;
-        const id = wt.hostId ?? LOCAL_HOST_ID8;
+        const id = wt.hostId ?? LOCAL_HOST_ID9;
         out.set(id, (out.get(id) ?? 0) + 1);
       }
     }
@@ -81883,7 +82552,7 @@ var FollowService = class {
   async gate(worktreeId4, opts = {}) {
     const stale = this.locate(worktreeId4);
     const next = stale?.worktree.supersededBy ? this.locate(stale.worktree.supersededBy) : null;
-    if (stale && next && stale.hostId !== LOCAL_HOST_ID8 && !checkpointService.isHostOnline(stale.hostId)) {
+    if (stale && next && stale.hostId !== LOCAL_HOST_ID9 && !checkpointService.isHostOnline(stale.hostId)) {
       return { worktreeId: idOf(next) };
     }
     if (!this.isOffline(worktreeId4)) return { worktreeId: worktreeId4 };
@@ -82017,7 +82686,7 @@ var FollowService = class {
   async onHostReturned(hostId2) {
     for (const repo of this.repos.loadAll()) {
       for (const wt of repo.worktrees) {
-        if ((wt.hostId ?? LOCAL_HOST_ID8) !== hostId2 || !wt.supersededBy) continue;
+        if ((wt.hostId ?? LOCAL_HOST_ID9) !== hostId2 || !wt.supersededBy) continue;
         const oldId = toWorktreeId(repo.name, wt.name, wt.hostId);
         if (wt.divergence?.state === "resolved") continue;
         try {
@@ -90379,17 +91048,17 @@ import { execFile as execFile13 } from "node:child_process";
 import {
   accessSync as accessSync3,
   constants as constants3,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   lstatSync as lstatSync4,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readFileSync as readFileSync11,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   symlinkSync,
-  unlinkSync as unlinkSync5,
+  unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync7
 } from "node:fs";
 import { homedir as homedir15, platform as platform2 } from "node:os";
-import { basename as basename3, dirname as dirname12, join as join46 } from "node:path";
+import { basename as basename3, dirname as dirname13, join as join46 } from "node:path";
 function windowsBinDir() {
   const localAppData = process.env.LOCALAPPDATA || join46(homedir15(), "AppData", "Local");
   return join46(localAppData, "band", "bin");
@@ -90408,7 +91077,7 @@ function checkCliWindows() {
   if (!match) return "ConflictingBinary";
   const target = match[1];
   if (basename3(target).toLowerCase() !== "band.exe") return "ConflictingBinary";
-  return existsSync15(target) ? "Installed" : "NotInstalled";
+  return existsSync16(target) ? "Installed" : "NotInstalled";
 }
 async function checkCli() {
   if (platform2() === "win32") {
@@ -90421,7 +91090,7 @@ async function checkCli() {
     }
     let target;
     try {
-      target = realpathSync4(SYMLINK_PATH);
+      target = realpathSync5(SYMLINK_PATH);
     } catch {
       return "NotInstalled";
     }
@@ -90500,7 +91169,7 @@ async function addBinDirToUserPath(binDir) {
 }
 async function installCliWindows(binaryPath) {
   const binDir = windowsBinDir();
-  mkdirSync8(binDir, { recursive: true });
+  mkdirSync9(binDir, { recursive: true });
   const shim = `@echo off\r
 "${binaryPath}" %*\r
 `;
@@ -90516,11 +91185,11 @@ async function installCli(_opts = {}) {
     await installCliWindows(binaryPath);
     return;
   }
-  const dir = dirname12(SYMLINK_PATH);
+  const dir = dirname13(SYMLINK_PATH);
   if (isDirWritable(dir)) {
     try {
       lstatSync4(SYMLINK_PATH);
-      unlinkSync5(SYMLINK_PATH);
+      unlinkSync6(SYMLINK_PATH);
     } catch (err) {
       const code = err.code;
       if (code !== "ENOENT") throw err;
@@ -90774,7 +91443,7 @@ function subscribeToFileChanges(worktreeId4, listener) {
 // src/server/services/formatter.ts
 init_src();
 init_registry();
-import { basename as basename4, dirname as dirname13, isAbsolute as isAbsolute4, join as join47, resolve as resolvePath3 } from "node:path";
+import { basename as basename4, dirname as dirname14, isAbsolute as isAbsolute4, join as join47, resolve as resolvePath3 } from "node:path";
 import prettier from "prettier";
 var log56 = createLogger("formatter");
 var FormatterError = class extends Error {
@@ -90853,7 +91522,7 @@ async function formatFile(worktreePath, filePath, content, options = {}) {
 var JSON_CONFIGS = [".prettierrc", ".prettierrc.json"];
 async function resolveConfigOnHost(fs3, absFile, worktreePath) {
   const root = resolvePath3(worktreePath);
-  let dir = dirname13(absFile);
+  let dir = dirname14(absFile);
   for (; ; ) {
     for (const name4 of JSON_CONFIGS) {
       const parsed = await readJson2(fs3, join47(dir, name4));
@@ -90863,8 +91532,8 @@ async function resolveConfigOnHost(fs3, absFile, worktreePath) {
     if (pkg && typeof pkg.prettier === "object" && pkg.prettier !== null) {
       return withoutPlugins(pkg.prettier);
     }
-    if (dir === root || dirname13(dir) === dir) return null;
-    dir = dirname13(dir);
+    if (dir === root || dirname14(dir) === dir) return null;
+    dir = dirname14(dir);
   }
 }
 function withoutPlugins(config2) {
@@ -90897,7 +91566,7 @@ async function isInsideWorktree(fs3, absFile, worktreePath) {
     realFile = await fs3.realpath(absFile);
   } catch {
     try {
-      realFile = join47(await fs3.realpath(dirname13(absFile)), basename4(absFile));
+      realFile = join47(await fs3.realpath(dirname14(absFile)), basename4(absFile));
     } catch {
       realFile = absFile;
     }
@@ -91160,7 +91829,7 @@ init_environment_build_service();
 init_src4();
 init_dist();
 init_registry();
-import { basename as basename5, dirname as dirname14, isAbsolute as isAbsolute6 } from "node:path";
+import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute6 } from "node:path";
 init_token_service();
 var EnvironmentService = class {
   /** The environment of a repo's main checkout, and which hosts meet its `requires`. */
@@ -91178,8 +91847,8 @@ var EnvironmentService = class {
     if (!isAbsolute6(path2)) {
       throw new TRPCError({ code: "BAD_REQUEST", message: "path must be absolute" });
     }
-    const isFile2 = basename5(path2) === "environment.json" && basename5(dirname14(path2)) === ".band";
-    return this.read(isFile2 ? dirname14(dirname14(path2)) : path2);
+    const isFile2 = basename5(path2) === "environment.json" && basename5(dirname15(path2)) === ".band";
+    return this.read(isFile2 ? dirname15(dirname15(path2)) : path2);
   }
   read(dir) {
     return hostRegistry.local.scripts.environment({ repoPath: dir, worktreePath: dir });
@@ -91571,26 +92240,83 @@ var historyRouter = t.router({
   })
 });
 
+// src/server/api/hooks/router.ts
+init_zod();
+
 // src/server/services/hooks-service.ts
 init_registry();
-function checkHooks2() {
-  return hostRegistry.local.agentEnv.hooksStatus();
+init_token_service();
+var LOCAL_HOST_ID10 = "local";
+function hostOf2(hostId2) {
+  return hostRegistry.hostById(hostId2);
+}
+function checkHooks2(hostId2 = LOCAL_HOST_ID10) {
+  return hostOf2(hostId2).agentEnv.hooksStatus();
 }
-function installHooks2() {
-  return hostRegistry.local.agentEnv.installHooks();
+function installHooks2(hostId2 = LOCAL_HOST_ID10) {
+  return hostOf2(hostId2).agentEnv.installHooks();
+}
+function removeHooks2(hostId2 = LOCAL_HOST_ID10) {
+  return hostOf2(hostId2).agentEnv.removeHooks();
+}
+async function claudeCodeOn(hostId2, agents) {
+  if (hostId2 !== LOCAL_HOST_ID10) return agents.includes("claude-code");
+  try {
+    return typeof await hostOf2(hostId2).acp.resolveLaunch({ type: "claude-code" }) !== "string";
+  } catch {
+    return false;
+  }
+}
+async function listHostHooks() {
+  const hosts2 = tokenService.listHosts().filter((h) => h.id !== LOCAL_HOST_ID10 || h.usable);
+  return Promise.all(
+    hosts2.map(async (h) => {
+      const online = h.id === LOCAL_HOST_ID10 || h.status === "online";
+      const view4 = {
+        hostId: h.id,
+        name: h.name,
+        online,
+        hasClaudeCode: await claudeCodeOn(h.id, h.agents),
+        status: null
+      };
+      if (!online) return view4;
+      try {
+        view4.status = await checkHooks2(h.id);
+      } catch (err) {
+        view4.error = err instanceof Error ? err.message : String(err);
+      }
+      return view4;
+    })
+  );
 }
 
 // src/server/api/hooks/router.ts
+var hostInput = external_exports2.object({ hostId: external_exports2.string().optional() }).default({});
+function failure(err) {
+  return new Error(err instanceof Error ? err.message : String(err));
+}
 var hooksRouter = t.router({
-  check: publicProcedure.query(async () => {
-    return await checkHooks2();
+  /** The hub's own host. */
+  check: adminProcedure.input(hostInput).query(async ({ input }) => {
+    return await checkHooks2(input.hostId);
   }),
-  install: publicProcedure.mutation(async () => {
+  /** Every host with its hooks status. */
+  hosts: adminProcedure.query(async () => ({ hosts: await listHostHooks() })),
+  install: adminProcedure.input(hostInput).mutation(async ({ input }) => {
     try {
-      await installHooks2();
+      await installHooks2(input.hostId);
       return { ok: true };
     } catch (err) {
-      throw new Error(err instanceof Error ? err.message : String(err));
+      throw failure(err);
+    }
+  }),
+  /** Removes Band's entries and leaves every other hook and setting. */
+  remove: adminProcedure.input(hostInput).mutation(async ({ input }) => {
+    try {
+      await removeHooks2(input.hostId);
+      return { ok: true };
+    } catch (err) {
+      throw failure(err);
     }
   })
 });
@@ -91724,6 +92450,17 @@ var RELAY_PROCEDURES = /* @__PURE__ */ new Set([
   "statuses.notify",
   "statuses.clearNeedsAttention",
   "repos.list",
+  "repos.add",
+  "repos.addFromWorker",
+  "repos.addByUrl",
+  "repos.inspectFolder",
+  "repos.resolveRemote",
+  "repos.gitInit",
+  "repos.promoteToGit",
+  "repos.update",
+  "repos.updateLabel",
+  "repos.reorder",
+  "repos.remove",
   "hosts.list",
   "hosts.forAgents",
   "cronjobs.list",
@@ -91736,7 +92473,13 @@ var RELAY_PROCEDURES = /* @__PURE__ */ new Set([
   "worktrees.create",
   "worktrees.remove"
 ]);
-var UNBATCHABLE = /* @__PURE__ */ new Set(["repos.list", "hosts.list", "worktrees.create", "worktrees.remove"]);
+var UNBATCHABLE = /* @__PURE__ */ new Set([
+  "repos.list",
+  "hosts.list",
+  "worktrees.create",
+  "worktrees.remove",
+  "statuses.notify"
+]);
 function pinHost(input, workerId, keep) {
   const base = input !== null && typeof input === "object" ? input : {};
   return keep && typeof base.hostId === "string" ? base : { ...base, hostId: workerId };
@@ -91749,7 +92492,7 @@ function pinWorktreeHost(request, workerId) {
   } catch {
     return request;
   }
-  const isTrpc = call === "/trpc/worktrees.create" || call === "/trpc/worktrees.remove";
+  const isTrpc = call === "/trpc/worktrees.create" || call === "/trpc/worktrees.remove" || call === "/trpc/statuses.notify";
   const isMcp = call === "/mcp";
   if (!isTrpc && !isMcp) return request;
   const parsed = parseJson(bodyText(request.body));
@@ -91903,7 +92646,7 @@ function checkNamed(input, workerId, lookups) {
     if (worktree === null || lookups.hostOfWorktree(worktree) !== workerId) return outside;
   }
   for (const cwd of named.cwds) {
-    const worktree = lookups.worktreeOfCwd(path.resolve(cwd));
+    const worktree = lookups.worktreeOfCwd(path.resolve(cwd), workerId);
     if (worktree === null || lookups.hostOfWorktree(worktree) !== workerId) return outside;
   }
   for (const id of named.terminals) {
@@ -91929,8 +92672,40 @@ function checkChosenId(procedure, input, lookups) {
   }
   return { ok: true };
 }
+var REPO_BY_NAME_PROCEDURES = /* @__PURE__ */ new Set([
+  "repos.update",
+  "repos.updateLabel",
+  "repos.remove",
+  "repos.promoteToGit"
+]);
+function checkRepoCall(procedure, input, workerId, lookups) {
+  const record3 = input ?? {};
+  if (REPO_BY_NAME_PROCEDURES.has(procedure)) {
+    if (typeof record3.name !== "string") return deny(400, `${procedure} needs a repo name`);
+    const refusal = lookups.repoHostRefusal(record3.name, workerId);
+    return refusal === null ? { ok: true } : deny(403, `${procedure}: ${refusal}`);
+  }
+  if (procedure === "repos.addFromWorker") {
+    const { hostId: hostId2, name: name4, allowedHostIds } = record3;
+    if (typeof hostId2 !== "string") return deny(400, `${procedure} needs a hostId`);
+    if (Array.isArray(allowedHostIds) && !allowedHostIds.includes(hostId2)) {
+      return deny(
+        403,
+        `${procedure}: The repo would be limited to hosts that exclude ${hostId2}, where the folder is`
+      );
+    }
+    if (typeof name4 === "string") {
+      const refusal = lookups.repoHostRefusal(name4, workerId);
+      if (refusal !== null) return deny(403, `${procedure}: ${refusal}`);
+    }
+  }
+  return { ok: true };
+}
 function checkCall(procedure, input, workerId, lookups) {
   if (!RELAY_PROCEDURES.has(procedure)) return deny(403, `${procedure} is not available to agents`);
+  if (procedure.startsWith("repos.") && procedure !== "repos.list") {
+    return checkRepoCall(procedure, input, workerId, lookups);
+  }
   let named = input;
   if (CRONJOB_KEY_PROCEDURES.has(procedure)) {
     const { key: key2, ...rest } = input ?? {};
@@ -94768,7 +95543,7 @@ init_src();
 init_zod();
 init_registry();
 init_queued_message_store();
-import { realpathSync as realpathSync5 } from "node:fs";
+import { realpathSync as realpathSync6 } from "node:fs";
 import { join as join49, resolve as resolve11, sep as sep7 } from "node:path";
 init_chat_service();
 init_state();
@@ -94786,8 +95561,8 @@ function isPathWithinUploadDir(p2) {
     return false;
   }
   try {
-    const canonicalUploadDir = realpathSync5(uploadDir);
-    const canonicalPath2 = realpathSync5(p2);
+    const canonicalUploadDir = realpathSync6(uploadDir);
+    const canonicalPath2 = realpathSync6(p2);
     return canonicalPath2 === canonicalUploadDir || canonicalPath2.startsWith(canonicalUploadDir + sep7);
   } catch {
     return true;
@@ -94800,38 +95575,38 @@ async function resolveQueuedFiles(chatId, worktreeId4, files) {
   const needsSave = [];
   const needsSaveIdx = [];
   for (let i = 0; i < files.length; i++) {
-    const file2 = files[i];
-    const derivedPath = file2.path ?? await uploadPathFromUrl(worktreeId4, file2.url) ?? void 0;
+    const file3 = files[i];
+    const derivedPath = file3.path ?? await uploadPathFromUrl(worktreeId4, file3.url) ?? void 0;
     if (derivedPath) {
       const inside = remote ? await isWithinUploads(worktreeId4, derivedPath) : isPathWithinUploadDir(derivedPath);
       if (!inside) {
         log57.warn(
-          { chatId, path: derivedPath, filename: file2.filename },
+          { chatId, path: derivedPath, filename: file3.filename },
           "queue: dropping file with path outside uploads directory"
         );
         continue;
       }
       resolved.push({
-        mediaType: file2.mediaType,
-        url: file2.url,
+        mediaType: file3.mediaType,
+        url: file3.url,
         path: derivedPath,
-        ...file2.filename !== void 0 && { filename: file2.filename }
+        ...file3.filename !== void 0 && { filename: file3.filename }
       });
       continue;
     }
-    if (file2.url.startsWith("data:")) {
-      needsSave.push(file2);
+    if (file3.url.startsWith("data:")) {
+      needsSave.push(file3);
       needsSaveIdx.push(resolved.length);
       resolved.push({
-        mediaType: file2.mediaType,
-        url: file2.url,
+        mediaType: file3.mediaType,
+        url: file3.url,
         path: "",
-        filename: file2.filename
+        filename: file3.filename
       });
       continue;
     }
     log57.warn(
-      { chatId, url: file2.url, filename: file2.filename },
+      { chatId, url: file3.url, filename: file3.filename },
       "queue: dropping file with no path and non-data URL \u2014 cannot recover disk path"
     );
   }
@@ -95153,7 +95928,7 @@ var UsageScannerService = class {
   async scanPair(ws, a) {
     let reader;
     try {
-      reader = await this.getUsageReader(a);
+      reader = await this.getUsageReader(a, ws.hostId);
     } catch (err) {
       log58.debug({ err, agentId: a.agentId }, "failed to resolve usage reader for scan");
       return 0;
@@ -95184,6 +95959,7 @@ var UsageScannerService = class {
           { err, sessionId: s2.sessionId, agentType: a.agentType },
           "getSessionUsage failed"
         );
+        if (err instanceof Error && err.name === "HostOfflineError") break;
         maxObserved = Math.max(maxObserved, s2.lastModified);
         continue;
       }
@@ -95239,7 +96015,8 @@ function defaultListWorktrees() {
       out.push({
         worktreeId: toWorktreeId(repo.name, worktree.name, worktree.hostId),
         repo: repo.name,
-        worktreePath: worktree.path
+        worktreePath: worktree.path,
+        hostId: worktree.hostId
       });
     }
   }
@@ -95254,8 +96031,9 @@ function defaultListAgents() {
     command: def.command
   }));
 }
-function defaultGetUsageReader(agent) {
-  return hostRegistry.local.agentEnv.usageReader(agent);
+function defaultGetUsageReader(agent, hostId2) {
+  const host = hostId2 ? hostRegistry.hostById(hostId2) : hostRegistry.local;
+  return host.agentEnv.usageReader(agent);
 }
 function defaultIsPollingEnabled() {
   try {
@@ -96220,7 +96998,6 @@ var settingsRouter = t.router({
 init_zod();
 init_branch_status_poller();
 init_state();
-init_task_service();
 init_watcher_service();
 var statusesRouter = t.router({
   get: publicProcedure.input(external_exports2.object({ worktreeId: external_exports2.string() })).query(({ input }) => {
@@ -96249,12 +97026,12 @@ var statusesRouter = t.router({
     refreshed: await branchStatusPoller.refreshWorktree(input.worktreeId)
   })),
   clearNeedsAttention: publicProcedure.input(external_exports2.object({ worktreeId: external_exports2.string() })).mutation(({ input }) => {
-    const status = taskService.acknowledgeAttention(input.worktreeId);
+    const status = acknowledgeWorktreeAttention(input.worktreeId);
     if (status) emit({ kind: "update", status });
     return { ok: true };
   }),
-  resolve: publicProcedure.input(external_exports2.object({ cwd: external_exports2.string() })).query(({ input }) => {
-    return { worktreeId: resolveWorktreeIdByCwd(input.cwd) };
+  resolve: publicProcedure.input(external_exports2.object({ cwd: external_exports2.string(), hostId: external_exports2.string().optional() })).query(({ input }) => {
+    return { worktreeId: resolveWorktreeIdByCwd(input.cwd, input.hostId) };
   }),
   /**
    * Agent-agnostic entry point for coding-agent lifecycle notifications
@@ -96275,7 +97052,8 @@ var statusesRouter = t.router({
       payload: external_exports2.record(external_exports2.string(), external_exports2.unknown()),
       agent: external_exports2.string().max(64).optional(),
       dispatch: external_exports2.string().max(64).optional(),
-      terminalId: external_exports2.string().max(256).optional()
+      terminalId: external_exports2.string().max(256).optional(),
+      hostId: external_exports2.string().max(256).optional()
     })
   ).mutation(async ({ input }) => {
     const status = await applyHookNotification(input);
@@ -96472,6 +97250,91 @@ var subscriptionsRouter = t.router({
 init_src();
 init_dist();
 init_zod();
+
+// package.json
+var package_default = {
+  name: "@band-app/server",
+  version: "0.48.1",
+  type: "module",
+  types: "src/index.ts",
+  exports: {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  },
+  bin: {
+    "band-server": "./bin/band-server.mjs"
+  },
+  files: [
+    "dist/client",
+    "dist/start-server.mjs",
+    "dist/terminal-daemon.mjs",
+    "dist/openapi.json",
+    "dist/migrations",
+    "bin"
+  ],
+  engines: {
+    node: ">=22.5.0"
+  },
+  os: [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  scripts: {
+    dev: "NODE_ENV=development tsx watch --exclude '../web/**' start-server.ts",
+    build: "./scripts/build-server.sh",
+    start: "node dist/start-server.mjs",
+    prepack: "node scripts/copy-ui.mjs",
+    postpack: "node scripts/copy-ui.mjs --clean",
+    pretest: "pnpm --filter @band-app/web build && pnpm build",
+    test: "NODE_OPTIONS='--no-warnings=ExperimentalWarning' vitest run",
+    postinstall: `node -e "process.platform!=='win32'&&require('child_process').execSync('chmod +x node_modules/node-pty/prebuilds/*/spawn-helper 2>/dev/null || true',{stdio:'ignore'})"`
+  },
+  dependencies: {
+    "@agentclientprotocol/claude-agent-acp": "0.81.2",
+    "@agentclientprotocol/codex-acp": "1.13.1",
+    "@agentclientprotocol/sdk": "1.5.0",
+    "@vscode/ripgrep": "^1.18.0",
+    fzf: "0.5.2",
+    "node-pty": "^1.1.0",
+    prettier: "^3.8.3",
+    "typescript-language-server": "^5.1.3"
+  },
+  devDependencies: {
+    "@band-app/coding-agent": "workspace:^",
+    "@band-app/environment": "workspace:^",
+    "@band-app/host-api": "workspace:^",
+    "@band-app/host-local": "workspace:^",
+    "@band-app/host-remote": "workspace:^",
+    "@band-app/link": "workspace:^",
+    "@band-app/logger": "workspace:^",
+    "@band-app/plugin-api": "workspace:^",
+    "@band-app/plugin-github": "workspace:^",
+    "@band-app/shared": "workspace:^",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@trpc/client": "^11.12.0",
+    "@trpc/openapi": "11.16.0-alpha",
+    "@trpc/server": "^11.12.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^22.19.13",
+    "@types/ws": "^8.18.0",
+    "@xterm/headless": "6.1.0-beta.302",
+    croner: "^10.0.1",
+    "drizzle-kit": "1.0.0-rc.1",
+    "drizzle-orm": "1.0.0-rc.1",
+    esbuild: "^0.25.0",
+    express: "^5.2.1",
+    sirv: "^3.0.0",
+    tsx: "^4.21.0",
+    typescript: "^5.7.0",
+    vite: "^7.0.0",
+    vitest: "^4.0.18",
+    ws: "^8.18.0",
+    zod: "^3.25.67"
+  }
+};
+
+// src/server/api/system/router.ts
 init_branch_status_poller();
 init_state();
 init_tunnel_service();
@@ -96488,6 +97351,7 @@ var systemRouter = t.router({
     log62.debug({ tunnel }, "services.health: tunnel status");
     const result = {
       webserver: true,
+      version: package_default.version,
       tunnel: tunnel.running,
       tunnel_url: tunnel.url
     };
@@ -97043,6 +97907,45 @@ var vaultRouter = t.router({
 init_dist();
 init_zod();
 
+// src/server/services/_utils/worktree-preview-link.ts
+init_state();
+import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual8 } from "node:crypto";
+import { posix as posix10 } from "node:path";
+var WORKTREE_PREVIEW_PREFIX = "/api/worktree-preview/";
+var PREVIEW_TTL_MS = 60 * 60 * 1e3;
+function signingKey() {
+  const token = resolveAdminToken(process.env.BAND_ADMIN_TOKEN).token;
+  return createHmac2("sha256", token).update("worktree-preview-v1").digest();
+}
+function sign(worktreeId4, dir, expiresAt) {
+  return createHmac2("sha256", signingKey()).update(`${worktreeId4}
+${dir}
+${expiresAt}`).digest("hex");
+}
+function worktreePreviewUrl(worktreeId4, path2, now = Date.now()) {
+  const expiresAt = now + PREVIEW_TTL_MS;
+  const dir = posix10.dirname(path2.replace(/^\/+/, ""));
+  const encodedDir = Buffer.from(dir, "utf8").toString("base64url");
+  const encodedPath = path2.split("/").map(encodeURIComponent).join("/");
+  const grant = `${expiresAt}.${encodedDir}.${sign(worktreeId4, dir, expiresAt)}`;
+  return `${WORKTREE_PREVIEW_PREFIX}${encodeURIComponent(worktreeId4)}/${grant}/${encodedPath}`;
+}
+function verifyWorktreePreviewGrant(worktreeId4, grant, filePath, now = Date.now()) {
+  if (filePath.includes("\0")) return false;
+  const [expiry, encodedDir, signature, ...extra] = grant.split(".");
+  const expiresAt = Number(expiry);
+  if (extra.length > 0 || encodedDir === void 0 || !signature || !Number.isSafeInteger(expiresAt) || expiresAt < now) {
+    return false;
+  }
+  const dir = Buffer.from(encodedDir, "base64url").toString("utf8");
+  const expected = Buffer.from(sign(worktreeId4, dir, expiresAt), "hex");
+  const given = Buffer.from(signature, "hex");
+  if (given.length !== expected.length || !timingSafeEqual8(given, expected)) return false;
+  const target = posix10.normalize(filePath.replace(/^\/+/, ""));
+  if (target === ".." || target.startsWith("../")) return false;
+  return dir === "." || target === dir || target.startsWith(`${dir}/`);
+}
+
 // src/server/services/diff-service.ts
 init_src2();
 init_src();
@@ -97158,9 +98061,9 @@ function assertWorktreeRelative(cwd, filePath) {
   }
   return target;
 }
-async function readUntrackedFileLines(host, cwd, file2) {
+async function readUntrackedFileLines(host, cwd, file3) {
   try {
-    const content = new TextDecoder().decode(await host.fs.readFile(join50(cwd, file2)));
+    const content = new TextDecoder().decode(await host.fs.readFile(join50(cwd, file3)));
     const lines = content.split("\n");
     if (lines.length > 0 && lines[lines.length - 1] === "") {
       lines.pop();
@@ -97450,17 +98353,17 @@ var DiffService = class {
     const fileStatuses = parseFileStatuses(nameStatusOutput);
     const untrackedFiles = untrackedOutput.trim().split("\n").filter(Boolean);
     const untrackedLines = await Promise.all(
-      untrackedFiles.map((file2) => readUntrackedFileLines(worktree.host, cwd, file2))
+      untrackedFiles.map((file3) => readUntrackedFileLines(worktree.host, cwd, file3))
     );
     for (let i = 0; i < untrackedFiles.length; i++) {
-      const file2 = untrackedFiles[i];
+      const file3 = untrackedFiles[i];
       const lines = untrackedLines[i];
       if (lines === null) continue;
-      diff += `diff --git a/${file2} b/${file2}
+      diff += `diff --git a/${file3} b/${file3}
 `;
       diff += "new file mode 100644\n";
       diff += "--- /dev/null\n";
-      diff += `+++ b/${file2}
+      diff += `+++ b/${file3}
 `;
       diff += `@@ -0,0 +1,${lines.length} @@
 `;
@@ -97468,7 +98371,7 @@ var DiffService = class {
       diff += "\n";
       stats.filesChanged++;
       stats.insertions += lines.length;
-      fileStatuses[file2] = "U";
+      fileStatuses[file3] = "U";
     }
     return {
       diff,
@@ -97696,7 +98599,7 @@ var diffService = new DiffService();
 init_errors6();
 init_ephemeral_lifecycle_service();
 init_worktree_service();
-import { dirname as dirname15, extname as extname3, join as join51, resolve as resolve13, sep as sep9 } from "node:path";
+import { dirname as dirname16, extname as extname3, join as join51, resolve as resolve13, sep as sep9 } from "node:path";
 var MAX_FILE_SIZE2 = 1024 * 1024;
 var LANG_MAP2 = {
   ".js": "javascript",
@@ -97837,7 +98740,7 @@ var FilesService = class {
     if (await exists2(fs3, target)) {
       throw new Error("A file or directory already exists at this path");
     }
-    await assertParentDirectory(fs3, dirname15(target), "Parent");
+    await assertParentDirectory(fs3, dirname16(target), "Parent");
     await fs3.writeFile(target, content, { exclusive: true });
     return { ok: true };
   }
@@ -97847,7 +98750,7 @@ var FilesService = class {
     if (await exists2(fs3, target)) {
       throw new Error("A file or directory already exists at this path");
     }
-    await assertParentDirectory(fs3, dirname15(target), "Parent");
+    await assertParentDirectory(fs3, dirname16(target), "Parent");
     await fs3.mkdir(target);
     return { ok: true };
   }
@@ -97889,7 +98792,7 @@ var FilesService = class {
     if (await exists2(fs3, toTarget)) {
       throw new Error("A file or directory already exists at the destination");
     }
-    await assertParentDirectory(fs3, dirname15(toTarget), "Destination parent");
+    await assertParentDirectory(fs3, dirname16(toTarget), "Destination parent");
     await fs3.rename(fromTarget, toTarget);
     return {
       ok: true,
@@ -97922,7 +98825,7 @@ var FilesService = class {
     if (await exists2(fs3, toTarget)) {
       throw new Error("A file or directory already exists at the destination");
     }
-    await assertParentDirectory(fs3, dirname15(toTarget), "Destination parent");
+    await assertParentDirectory(fs3, dirname16(toTarget), "Destination parent");
     await fs3.copy(fromTarget, toTarget, { recursive: true, exclusive: true });
     return {
       ok: true,
@@ -99408,6 +100311,13 @@ var worktreeRouter = t.router({
       toPath: external_exports2.string().min(1)
     })
   ).mutation(({ input }) => filesService.copyPath(input.worktreeId, input.fromPath, input.toPath)),
+  /** A signed, expiring URL for one worktree file, for a browser tab that cannot send the auth header. */
+  previewUrl: publicProcedure.input(external_exports2.object({ worktreeId: external_exports2.string(), path: external_exports2.string().min(1) })).query(({ input }) => {
+    if (!worktreeService.resolve(input.worktreeId)) {
+      throw new TRPCError({ code: "NOT_FOUND", message: "Worktree not found" });
+    }
+    return { url: worktreePreviewUrl(input.worktreeId, input.path) };
+  }),
   searchFiles: publicProcedure.input(
     external_exports2.object({
       worktreeId: external_exports2.string(),
@@ -99491,6 +100401,13 @@ var worktreesRouter = t.router({
       throwAsTrpcError3(err);
     }
   }),
+  setOrigin: publicProcedure.input(worktreeSetOriginInput).mutation(({ input }) => {
+    try {
+      return worktreeService.setOrigin(input);
+    } catch (err) {
+      throwAsTrpcError3(err);
+    }
+  }),
   gitPull: publicProcedure.input(worktreeGitInput).mutation(async ({ input }) => {
     try {
       return await worktreeService.gitPull(input);
@@ -99514,7 +100431,7 @@ var worktreesRouter = t.router({
   })
 });
 function throwAsTrpcError3(err) {
-  if (err instanceof PlainRepoError) {
+  if (err instanceof PlainRepoError || err instanceof InvalidOriginError) {
     throw new TRPCError({ code: "BAD_REQUEST", message: err.message, cause: err });
   }
   if (err instanceof RepoHostNotAllowedError) {
@@ -99585,12 +100502,15 @@ function discoverProcedures() {
   for (const [path2, procedure] of Object.entries(procRecord)) {
     const type = procedure._def.type;
     if (type === "subscription") continue;
-    if (path2.startsWith("tokens.") || path2.startsWith("vault.") || path2.startsWith("checkpoints.") || path2.startsWith("follow.") || path2.startsWith("mcp.") || path2.startsWith("hosts.") && path2 !== "hosts.forAgents" || path2.startsWith("hostRequests.") || path2.startsWith("runners."))
+    if (path2.startsWith("tokens.") || path2.startsWith("vault.") || path2.startsWith("checkpoints.") || path2.startsWith("follow.") || path2.startsWith("mcp.") || path2.startsWith("hosts.") && path2 !== "hosts.forAgents" || path2.startsWith("hostRequests.") || path2.startsWith("runners.") || // Writes ~/.claude/settings.json on a host; only a person's click may.
+    path2.startsWith("hooks."))
       continue;
+    if (path2 === "worktree.previewUrl") continue;
     if (path2 === "environment.validate") continue;
     if (path2 === "repos.addFromWorker") continue;
     if (path2 === "repos.addByUrl") continue;
     if (path2 === "repos.inspectFolder" || path2 === "repos.resolveRemote") continue;
+    if (path2 === "worktrees.setOrigin") continue;
     if (path2 === "environment.build") continue;
     const toolName2 = `band_${path2.replace(/\./g, "_")}`;
     const inputs = procedure._def.inputs;
@@ -99764,6 +100684,11 @@ function crossHostRefusal(repo, targetHostId, callerHostId) {
   }
   return null;
 }
+function repoHostRefusal(repo, callerHostId) {
+  const allowed2 = allowedHostsOf(repo);
+  if (isHostAllowed(allowed2, callerHostId)) return null;
+  return `${repo} is limited to other hosts (${hostNamesOf(allowed2 ?? []).join(", ")})`;
+}
 
 // src/server/api/mcp-proxy/band-tools.ts
 init_worktree_service();
@@ -100905,7 +101830,7 @@ async function handleOAuthCallback(req, res) {
 }
 
 // src/server/api/web-app-manifest.ts
-import { createReadStream as createReadStream4, statSync as statSync12 } from "node:fs";
+import { createReadStream as createReadStream4, statSync as statSync14 } from "node:fs";
 import { join as join52 } from "node:path";
 var WEB_APP_MANIFEST_PATH = "/manifest.webmanifest";
 var ICON_FILES = ["band-192.png", "band-512.png", "apple-touch-icon.png"];
@@ -100929,7 +101854,7 @@ function handleWebAppManifest(req, res, publicDir) {
 }
 function sendFile(req, res, filePath, headers) {
   try {
-    const { size } = statSync12(filePath);
+    const { size } = statSync14(filePath);
     res.writeHead(200, { ...headers, "Content-Length": size.toString() });
     if (req.method === "HEAD") res.end();
     else
@@ -101677,31 +102602,52 @@ init_src();
 init_registry();
 async function installSkills2(opts = {}) {
   const result = await hostRegistry.local.agentEnv.installSkills({ home: opts.home });
-  const log77 = opts.log;
-  if (log77) {
-    for (const warning of result.warnings) log77.warn(warning);
-    for (const path2 of result.written) log77.info("Installed skill at %s", path2);
+  const log78 = opts.log;
+  if (log78) {
+    for (const warning of result.warnings) log78.warn(warning);
+    for (const path2 of result.written) log78.info("Installed skill at %s", path2);
     for (const path2 of result.updated) {
-      log77.info("Updated skill at %s (content differed \u2014 shipped version reinstalled)", path2);
+      log78.info("Updated skill at %s (content differed \u2014 shipped version reinstalled)", path2);
     }
     for (const conflict of result.conflicts) {
-      log77.warn("Skill symlink conflict \u2014 %s (left as-is; remove it manually to re-link)", conflict);
+      log78.warn("Skill symlink conflict \u2014 %s (left as-is; remove it manually to re-link)", conflict);
     }
   }
   return result;
 }
 
-// src/server/services/setup-service.ts
-init_settings_service();
+// src/server/services/coding-agent-seed.ts
+init_src();
 init_state();
-init_sync_service();
-init_worktree_service();
-var log73 = createLogger("setup");
+var log73 = createLogger("coding-agent-seed");
 var AGENT_CHECKS = [
   { id: "claude-code", type: "claude-code", label: "Claude Code", binary: "claude" },
   { id: "codex", type: "codex", label: "Codex", binary: "codex" },
   { id: "opencode", type: "opencode", label: "OpenCode", binary: "opencode" }
 ];
+function seedCodingAgentsFromTypes(types) {
+  const settings3 = loadSettings();
+  if (Array.isArray(settings3.codingAgents) && settings3.codingAgents.length > 0) return;
+  const seeded = AGENT_CHECKS.filter((c) => types.includes(c.type)).map(
+    ({ id, type, label: label2 }) => ({ id, type, label: label2 })
+  );
+  if (seeded.length === 0) return;
+  settings3.codingAgents = seeded;
+  if (!settings3.defaultCodingAgent) settings3.defaultCodingAgent = seeded[0].id;
+  saveSettings(settings3);
+  log73.info(
+    "Enabled %d coding agent(s) from a worker; default = %s",
+    seeded.length,
+    settings3.defaultCodingAgent
+  );
+}
+
+// src/server/services/setup-service.ts
+init_settings_service();
+init_state();
+init_sync_service();
+init_worktree_service();
+var log74 = createLogger("setup");
 async function runFirstTimeSetup() {
   forgetLocalWorktrees();
   const repoSync = ensureRepoStateInSync().then(() => ensureRepoRemotes());
@@ -101709,12 +102655,11 @@ async function runFirstTimeSetup() {
   const results = await Promise.allSettled([
     repoSync,
     ensureSettingsDefaults(),
-    ensureClaudeHooks(),
     ensureSkillsInstalled()
   ]);
   for (const r of results) {
     if (r.status === "rejected") {
-      log73.warn(
+      log74.warn(
         "Setup step failed: %s",
         r.reason instanceof Error ? r.reason.message : String(r.reason)
       );
@@ -101728,7 +102673,7 @@ async function refreshAgentModelsInBackground() {
     const ok = results.filter((r) => !r.error).length;
     const failed = results.length - ok;
     if (results.length > 0) {
-      log73.info(
+      log74.info(
         "Background model refresh: %d/%d agents updated (%d failed)",
         ok,
         results.length,
@@ -101736,7 +102681,7 @@ async function refreshAgentModelsInBackground() {
       );
     }
   } catch (err) {
-    log73.warn(
+    log74.warn(
       "Background model refresh failed: %s",
       err instanceof Error ? err.message : String(err)
     );
@@ -101751,7 +102696,7 @@ async function ensureRepoRemotes() {
   try {
     await repoService.backfillRemotes();
   } catch (err) {
-    log73.warn(
+    log74.warn(
       "Failed to record repo remotes at boot: %s",
       err instanceof Error ? err.message : String(err)
     );
@@ -101761,7 +102706,7 @@ function forgetLocalWorktrees() {
   try {
     worktreeService.forgetLocalWorktrees();
   } catch (err) {
-    log73.warn(
+    log74.warn(
       "Failed to forget local worktrees at boot: %s",
       err instanceof Error ? err.message : String(err)
     );
@@ -101771,7 +102716,7 @@ async function ensureRepoStateInSync() {
   try {
     await syncService.syncWorktrees();
   } catch (err) {
-    log73.warn(
+    log74.warn(
       "Failed to sync repo state at boot: %s",
       err instanceof Error ? err.message : String(err)
     );
@@ -101782,22 +102727,22 @@ async function ensureCliInstalled() {
   try {
     cliStatus = await checkCli();
   } catch (err) {
-    log73.warn("Could not check CLI status: %s", err instanceof Error ? err.message : String(err));
+    log74.warn("Could not check CLI status: %s", err instanceof Error ? err.message : String(err));
     return;
   }
   if (cliStatus === "Installed") {
     return;
   }
   if (cliStatus !== "NotInstalled") {
-    log73.warn("CLI not auto-installed (status: %s)", cliStatus);
+    log74.warn("CLI not auto-installed (status: %s)", cliStatus);
     return;
   }
-  log73.info("Installing band CLI...");
+  log74.info("Installing band CLI...");
   try {
     await installCli();
-    log73.info("CLI installed to %s", SYMLINK_PATH);
+    log74.info("CLI installed to %s", SYMLINK_PATH);
   } catch (err) {
-    log73.warn("CLI installation failed: %s", err instanceof Error ? err.message : String(err));
+    log74.warn("CLI installation failed: %s", err instanceof Error ? err.message : String(err));
   }
 }
 async function ensureDefaultCodingAgents() {
@@ -101806,17 +102751,17 @@ async function ensureDefaultCodingAgents() {
   if (Array.isArray(existing) && existing.length > 0) {
     return;
   }
-  log73.info("Detecting installed coding agents...");
+  log74.info("Detecting installed coding agents...");
   const detected = [];
   for (const check2 of AGENT_CHECKS) {
     const path2 = await systemService.whichBinary(check2.binary);
     if (path2) {
-      log73.info("Detected coding agent: %s (%s)", check2.id, path2);
+      log74.info("Detected coding agent: %s (%s)", check2.id, path2);
       detected.push({ id: check2.id, type: check2.type, label: check2.label });
     }
   }
   if (detected.length === 0) {
-    log73.info("No coding agent CLIs detected on PATH");
+    log74.info("No coding agent CLIs detected on PATH");
     return;
   }
   const current3 = loadSettings();
@@ -101825,7 +102770,7 @@ async function ensureDefaultCodingAgents() {
     current3.defaultCodingAgent = detected[0].id;
   }
   saveSettings(current3);
-  log73.info("Enabled %d coding agent(s); default = %s", detected.length, current3.defaultCodingAgent);
+  log74.info("Enabled %d coding agent(s); default = %s", detected.length, current3.defaultCodingAgent);
 }
 function ensureNotificationDefaults() {
   const settings3 = loadSettings();
@@ -101837,7 +102782,7 @@ function ensureNotificationDefaults() {
     ...settings3,
     notifications: { ...notifications, soundOnNeedsAttention: true }
   });
-  log73.info("Set default notifications.soundOnNeedsAttention = true");
+  log74.info("Set default notifications.soundOnNeedsAttention = true");
 }
 function migrateAgentDefaultMode() {
   const settings3 = loadSettings();
@@ -101845,30 +102790,15 @@ function migrateAgentDefaultMode() {
   const mode = agentModeFromVia(settings3.cli?.defaultVia);
   if (!mode) return;
   saveSettings({ ...settings3, agents: { ...settings3.agents, defaultMode: mode } });
-  log73.info("Migrated cli.defaultVia to agents.defaultMode = %s", mode);
-}
-async function ensureClaudeHooks() {
-  try {
-    const status = await checkHooks2();
-    if (status.installed) {
-      return;
-    }
-    await installHooks2();
-    log73.info("Installed Claude Code hooks");
-  } catch (err) {
-    log73.warn(
-      "Failed to install Claude Code hooks: %s",
-      err instanceof Error ? err.message : String(err)
-    );
-  }
+  log74.info("Migrated cli.defaultVia to agents.defaultMode = %s", mode);
 }
 async function ensureSkillsInstalled() {
   try {
-    const result = await installSkills2({ log: log73 });
+    const result = await installSkills2({ log: log74 });
     const wrote = result.written.length + result.updated.length;
     const linkChange = result.linked.length;
     if (wrote > 0 || linkChange > 0 || result.conflicts.length > 0) {
-      log73.info(
+      log74.info(
         "Synced CLI skills (shared: %d written, %d updated, %d unchanged; symlinks: %d created, %d already-linked, %d conflicts, %d skipped)",
         result.written.length,
         result.updated.length,
@@ -101880,7 +102810,7 @@ async function ensureSkillsInstalled() {
       );
     }
   } catch (err) {
-    log73.warn("Failed to sync CLI skills: %s", err instanceof Error ? err.message : String(err));
+    log74.warn("Failed to sync CLI skills: %s", err instanceof Error ? err.message : String(err));
   }
 }
 var SetupService = class {
@@ -101919,7 +102849,7 @@ init_src();
 import { createHash as createHash12 } from "node:crypto";
 import { readFile as readFile9 } from "node:fs/promises";
 import { join as join54 } from "node:path";
-var log74 = createLogger("worker-cli");
+var log75 = createLogger("worker-cli");
 var RPC_INVALID_PARAMS2 = -32602;
 var PLATFORM_NAME = /^[a-z0-9_]{1,16}$/;
 function candidatesFor(platform3, arch) {
@@ -101955,7 +102885,7 @@ var WorkerCliService = class {
     }
     const sha2562 = createHash12("sha256").update(data).digest("hex");
     if (have === sha2562) return { available: true, sha256: sha2562, size: data.length };
-    log74.info(
+    log75.info(
       `sending the band CLI (${platform3}-${arch}, ${data.length} bytes) to ${session.workerId}`
     );
     const ch = session.openChannel("cli.body", { platform: platform3, arch });
@@ -101997,7 +102927,7 @@ init_chat_service();
 init_state();
 init_subscription_service();
 init_terminal_service();
-var log75 = createLogger("worker-relay");
+var log76 = createLogger("worker-relay");
 var REPLY_HEADERS2 = ["content-type", "cache-control", "mcp-session-id"];
 var FORWARDED_HEADERS = [
   "content-type",
@@ -102013,11 +102943,12 @@ var defaultLookups = {
     const chat = chatService.get(id);
     return chat?.worktreeId ?? null;
   },
-  worktreeOfCwd: (cwd) => resolveWorktreeIdByCwd(cwd),
+  worktreeOfCwd: (cwd, hostId2) => resolveWorktreeIdByCwd(cwd, hostId2),
   hostOfTerminal: (id) => terminalService.hostIdOf(id),
   worktreeOfBrowser: (id) => browserService.get(id)?.worktreeId ?? null,
   worktreeOfSubscription: (id) => subscriptionService.list().find((s2) => s2.id === id)?.worktreeId ?? null,
-  crossHostRefusal
+  crossHostRefusal,
+  repoHostRefusal
 };
 var WorkerRelayService = class {
   constructor(lookups = defaultLookups) {
@@ -102036,7 +102967,7 @@ var WorkerRelayService = class {
     let request = parseRequest(params);
     const verdict = checkRelayRequest(request, session.workerId, this.lookups);
     if (!verdict.ok) {
-      log75.warn(
+      log76.warn(
         `refused ${request.method} ${request.path.split("?")[0]} from ${session.workerId}: ${verdict.reason}`
       );
       return this.answer(session, verdict.status, refusalBody(request, verdict));
@@ -102071,7 +103002,7 @@ var WorkerRelayService = class {
         redirect: "manual"
       });
     } catch (err) {
-      log75.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
+      log76.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
       return this.answer(session, 502, { error: "The hub could not answer" });
     }
     const replyHeaders = {};
@@ -102089,7 +103020,7 @@ var WorkerRelayService = class {
         const filtered = filterReposReply(await upstream.json(), session.workerId);
         return this.answer(session, upstream.status, filtered);
       } catch (err) {
-        log75.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
+        log76.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
         return this.answer(session, 502, { error: "The hub could not answer" });
       }
     }
@@ -102097,7 +103028,7 @@ var WorkerRelayService = class {
       try {
         return this.answer(session, upstream.status, redactHostsReply(await upstream.json()));
       } catch (err) {
-        log75.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
+        log76.warn(`relay call failed: ${err instanceof Error ? err.message : err}`);
         return this.answer(session, 502, { error: "The hub could not answer" });
       }
     }
@@ -102150,9 +103081,9 @@ var workerRelayService = new WorkerRelayService();
 
 // src/server/services/worker-link-service.ts
 init_worktree_service();
-var log76 = createLogger("worker-link");
+var log77 = createLogger("worker-link");
 var repoQueries5 = new RepoQueries();
-var LOCAL_HOST_ID9 = "local";
+var LOCAL_HOST_ID11 = "local";
 var CAPABILITY_REFRESH_MS = 3 * 6e4;
 var WORKER_CONNECT_PATH = "/api/workers/connect";
 var WORKER_EXCHANGE_PATH = "/api/workers/exchange";
@@ -102195,10 +103126,10 @@ var WorkerLinkService = class {
   /** Makes every known worker resolvable, so a worktree on an offline host still finds its host. */
   start() {
     for (const row of this.queries.listHosts(1e3)) {
-      if (row.id !== LOCAL_HOST_ID9) this.remoteHost(row.id);
+      if (row.id !== LOCAL_HOST_ID11) this.remoteHost(row.id);
     }
     for (const row of this.queries.listHosts(1e3)) {
-      if (row.id !== LOCAL_HOST_ID9 && row.status === "online") {
+      if (row.id !== LOCAL_HOST_ID11 && row.status === "online") {
         this.queries.setHostStatus(row.id, "offline");
       }
     }
@@ -102210,7 +103141,7 @@ var WorkerLinkService = class {
     this.refreshTimer.unref();
     this.unsubscribeRevoke = this.tokens.onRevoked((row) => {
       if (row.kind === "worker_session" && row.hostId) {
-        if (this.server.drop(row.hostId, "token revoked")) log76.info(`cut link of ${row.hostId}`);
+        if (this.server.drop(row.hostId, "token revoked")) log77.info(`cut link of ${row.hostId}`);
       }
     });
   }
@@ -102224,7 +103155,7 @@ var WorkerLinkService = class {
     this.refreshing = true;
     try {
       await Promise.allSettled(
-        this.queries.listHosts(1e3).filter((row) => row.id !== LOCAL_HOST_ID9 && row.status === "online").map((row) => this.refreshReport(row))
+        this.queries.listHosts(1e3).filter((row) => row.id !== LOCAL_HOST_ID11 && row.status === "online").map((row) => this.refreshReport(row))
       );
     } finally {
       this.refreshing = false;
@@ -102240,7 +103171,7 @@ var WorkerLinkService = class {
       this.queries.setHostInfo(row.id, stored);
       if (changed) this.publish(row.id, "online");
     } catch (err) {
-      log76.debug(
+      log77.debug(
         `could not refresh the report of ${row.id}: ${err instanceof Error ? err.message : err}`
       );
     }
@@ -102282,7 +103213,7 @@ var WorkerLinkService = class {
     try {
       info = await this.remoteHost(workerId).info();
     } catch (err) {
-      log76.warn(
+      log77.warn(
         `could not read host info from ${workerId}: ${err instanceof Error ? err.message : err}`
       );
     }
@@ -102299,27 +103230,32 @@ var WorkerLinkService = class {
       mode: hello.mode
     };
     this.queries.markHostOnline(workerId, at, { info: stored, version: hello.buildId });
-    log76.info(`worker ${workerId} is online`);
+    log77.info(`worker ${workerId} is online`);
+    try {
+      seedCodingAgentsFromTypes(hello.agents);
+    } catch (err) {
+      log77.warn(`could not seed coding agents: ${err instanceof Error ? err.message : err}`);
+    }
     this.publish(workerId, "online");
     void ephemeralLifecycleService.onConnected(session);
     void followService.onHostReturned(workerId).catch((err) => {
-      log76.warn(`follow check on ${workerId}: ${err instanceof Error ? err.message : err}`);
+      log77.warn(`follow check on ${workerId}: ${err instanceof Error ? err.message : err}`);
     });
     placementService.onHostOnline(workerId);
     void worktreeService.finishPendingRemovals(workerId).catch((err) => {
-      log76.warn(`pending removals on ${workerId}: ${err instanceof Error ? err.message : err}`);
+      log77.warn(`pending removals on ${workerId}: ${err instanceof Error ? err.message : err}`);
     });
   }
   setStatus(workerId, status, lastSeenAt) {
     try {
       this.queries.setHostStatus(workerId, status, lastSeenAt);
     } catch (err) {
-      log76.warn(
+      log77.warn(
         `could not record ${workerId} as ${status}: ${err instanceof Error ? err.message : err}`
       );
       return;
     }
-    log76.info(`worker ${workerId} is ${status}`);
+    log77.info(`worker ${workerId} is ${status}`);
     this.publish(workerId, status);
   }
   publish(hostId2, hostStatus) {
@@ -102364,7 +103300,7 @@ var WorkerLinkService = class {
       send2(200, out);
     } catch (err) {
       if (!(err instanceof TokenExchangeError)) throw err;
-      log76.warn(`bootstrap exchange refused: ${err.reason}`);
+      log77.warn(`bootstrap exchange refused: ${err.reason}`);
       send2(401, { error: "invalid or expired token" });
     }
   }
@@ -102383,7 +103319,7 @@ function reportKey(report2) {
 init_worktree_service();
 function logCrash(message) {
   try {
-    mkdirSync9(bandHome(), { recursive: true });
+    mkdirSync10(bandHome(), { recursive: true });
     appendFileSync2(join55(bandHome(), "server.log"), message, "utf-8");
   } catch {
   }
@@ -102426,7 +103362,7 @@ function resolveUiDir() {
     resolve14(SERVER_ROOT, "..", "..", "web", "dist", "client"),
     join55(SERVER_ROOT, "client")
   ];
-  return candidates.find((dir) => existsSync16(join55(dir, "_shell.html"))) ?? candidates[1];
+  return candidates.find((dir) => existsSync17(join55(dir, "_shell.html"))) ?? candidates[1];
 }
 var clientDir = resolveUiDir();
 var uiRoot = process.env.BAND_UI_ROOT ? resolve14(process.env.BAND_UI_ROOT) : resolve14(SERVER_ROOT, "..", "web");
@@ -102511,7 +103447,7 @@ function serveStaticFile(res, root, subdir, rawFilename) {
   }
   const filePath = join55(root, subdir, filename);
   try {
-    const fileStat = statSync13(filePath);
+    const fileStat = statSync15(filePath);
     const contentType = mimeTypeFromFilename(filename);
     res.writeHead(200, {
       "Content-Type": contentType,
@@ -102526,26 +103462,26 @@ function serveStaticFile(res, root, subdir, rawFilename) {
 }
 async function serveHostedFile(res, kind, worktreeId4, rawName) {
   if (hostRegistry.hostFor(worktreeId4).id === hostRegistry.local.id) return false;
-  const file2 = await openHostedFile(kind, worktreeId4, rawName);
-  if (!file2) {
+  const file3 = await openHostedFile(kind, worktreeId4, rawName);
+  if (!file3) {
     res.writeHead(404);
     res.end("Not found");
     return true;
   }
   res.writeHead(200, {
     "Content-Type": mimeTypeFromFilename(basename7(decodeURIComponent(rawName))),
-    "Content-Length": file2.size.toString(),
+    "Content-Length": file3.size.toString(),
     "Cache-Control": "private, max-age=86400"
   });
   pipeline(
-    Readable2.from(file2.stream, { objectMode: false, highWaterMark: 64 * 1024 }),
+    Readable2.from(file3.stream, { objectMode: false, highWaterMark: 64 * 1024 }),
     res,
     () => {
     }
   );
   return true;
 }
-async function serveWorktreeFile(res, worktreeId4, rawPath) {
+async function serveWorktreeFile(res, worktreeId4, rawPath, extraHeaders = {}) {
   const worktree = worktreeService.resolve(worktreeId4);
   if (!worktree) {
     res.writeHead(404);
@@ -102561,12 +103497,25 @@ async function serveWorktreeFile(res, worktreeId4, rawPath) {
   }
   try {
     const { fs: fs3 } = worktree.host;
+    const [realRoot, realTarget] = await Promise.all([fs3.realpath(root), fs3.realpath(target)]);
+    if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep10)) {
+      res.writeHead(400);
+      res.end("Bad request");
+      return;
+    }
     const fileStat = await fs3.stat(target, { followSymlinks: true });
     const contentType = mimeTypeFromFilename(basename7(target));
+    const isHtml = contentType.startsWith("text/html");
     res.writeHead(200, {
       "Content-Type": contentType,
       "Content-Length": fileStat.size.toString(),
-      "Cache-Control": "private, no-cache"
+      "Cache-Control": "private, no-cache",
+      // HTML from a repo must not run with the hub's origin.
+      ...isHtml ? {
+        "Content-Security-Policy": "sandbox allow-scripts",
+        "X-Content-Type-Options": "nosniff"
+      } : {},
+      ...extraHeaders
     });
     pipeline(
       Readable2.from(fs3.readStream(target), { objectMode: false, highWaterMark: 64 * 1024 }),
@@ -102579,6 +103528,41 @@ async function serveWorktreeFile(res, worktreeId4, rawPath) {
     res.end("Not found");
   }
 }
+async function handleWorktreePreview(req, res) {
+  const rest = (req.url ?? "").slice(WORKTREE_PREVIEW_PREFIX.length).split("?")[0];
+  const [rawId, grant, ...pathParts] = rest.split("/");
+  let wId;
+  let filePath;
+  try {
+    wId = decodeURIComponent(rawId ?? "");
+    filePath = decodeURIComponent(pathParts.join("/"));
+  } catch {
+    res.writeHead(400);
+    res.end("Bad request");
+    return;
+  }
+  if (!wId || !grant || !filePath) {
+    res.writeHead(400);
+    res.end("Bad request");
+    return;
+  }
+  if (!verifyWorktreePreviewGrant(wId, grant, filePath)) {
+    res.writeHead(403);
+    res.end("Forbidden");
+    return;
+  }
+  await serveWorktreeFile(res, wId, filePath, {
+    // The page runs repo-controlled scripts on the hub's origin. `sandbox`
+    // without `allow-same-origin` gives it an opaque origin, so it cannot use
+    // the hub's cookies, storage or tRPC. Its own assets are plain GETs under
+    // the grant, and the wildcard CORS header lets scripts fetch them.
+    "Content-Security-Policy": "sandbox allow-scripts allow-forms allow-popups allow-modals",
+    "X-Content-Type-Options": "nosniff",
+    "Referrer-Policy": "no-referrer",
+    "Access-Control-Allow-Origin": "*",
+    "Cache-Control": "private, no-store"
+  });
+}
 var MAX_WEBHOOK_BODY_BYTES = 256 * 1024;
 var MAX_GITHUB_HOOK_BODY_BYTES = 2 * 1024 * 1024;
 async function handleGithubWebhook(req, res) {
@@ -102815,9 +103799,13 @@ async function main() {
       await handleSubscriptionWebhook(req, res, subscriptionId);
       return;
     }
+    if (req.method === "GET" && req.url?.startsWith(WORKTREE_PREVIEW_PREFIX)) {
+      await handleWorktreePreview(req, res);
+      return;
+    }
     if (handleAuth(req, res)) return;
     if (req.url?.startsWith("/api/uploads/")) {
-      const rest = req.url.slice("/api/uploads/".length);
+      const rest = req.url.slice("/api/uploads/".length).split("?")[0];
       const slashIdx = rest.indexOf("/");
       if (slashIdx !== -1) {
         let wId;
@@ -102864,7 +103852,7 @@ async function main() {
       return;
     }
     if (req.url?.startsWith("/api/shared/")) {
-      const rest = req.url.slice("/api/shared/".length);
+      const rest = req.url.slice("/api/shared/".length).split("?")[0];
       const slashIdx = rest.indexOf("/");
       if (slashIdx === -1) {
         res.writeHead(400);
@@ -102882,21 +103870,33 @@ async function main() {
       return;
     }
     if (req.url?.startsWith("/api/worktree-file/")) {
-      const rest = req.url.slice("/api/worktree-file/".length);
+      const queryIdx = req.url.indexOf("?");
+      const rest = req.url.slice(
+        "/api/worktree-file/".length,
+        queryIdx === -1 ? void 0 : queryIdx
+      );
       const slashIdx = rest.indexOf("/");
       if (slashIdx === -1) {
         res.writeHead(400);
         res.end("Bad request");
         return;
       }
-      const wId = decodeURIComponent(rest.slice(0, slashIdx));
-      const filePath = rest.slice(slashIdx + 1);
+      let wId;
+      let filePath;
+      try {
+        wId = decodeURIComponent(rest.slice(0, slashIdx));
+        filePath = decodeURIComponent(rest.slice(slashIdx + 1));
+      } catch {
+        res.writeHead(400);
+        res.end("Bad request");
+        return;
+      }
       if (!wId || !filePath) {
         res.writeHead(400);
         res.end("Bad request");
         return;
       }
-      await serveWorktreeFile(res, wId, decodeURIComponent(filePath));
+      await serveWorktreeFile(res, wId, filePath);
       return;
     }
     if (req.url?.startsWith("/api/cdp/tabs")) {
@@ -103087,7 +104087,7 @@ async function main() {
       }
     });
     const shellPath2 = join55(clientDir, "_shell.html");
-    if (!existsSync16(shellPath2)) {
+    if (!existsSync17(shellPath2)) {
       throw new Error(
         `UI build not found at ${clientDir} (no _shell.html). Run \`pnpm build\` or pass --ui-dir <path>.`
       );