@lesscap/baton-cli 0.8.3 → 0.9.4

package/dist/baton.mjs

@@ -14,7 +14,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -2281,7 +2285,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2949,7 +2953,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3230,7 +3234,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open3() {
             duplex._final(callback);
           });
           return;
@@ -3251,7 +3255,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open3() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3318,7 +3322,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3625,7 +3629,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3724,14 +3728,14 @@ function isUppercase(char = "") {
   if (NUMBER_CHAR_RE.test(char)) return;
   return char !== char.toLowerCase();
 }
-function splitByCase(str3, separators) {
+function splitByCase(str4, separators) {
   const splitters = separators ?? STR_SPLITTERS;
   const parts = [];
-  if (!str3 || typeof str3 !== "string") return parts;
+  if (!str4 || typeof str4 !== "string") return parts;
   let buff = "";
   let previousUpper;
   let previousSplitter;
-  for (const char of str3) {
+  for (const char of str4) {
     const isSplitter = splitters.includes(char);
     if (isSplitter === true) {
       parts.push(buff);
@@ -3762,23 +3766,23 @@ function splitByCase(str3, separators) {
   parts.push(buff);
   return parts;
 }
-function upperFirst(str3) {
-  return str3 ? str3[0].toUpperCase() + str3.slice(1) : "";
+function upperFirst(str4) {
+  return str4 ? str4[0].toUpperCase() + str4.slice(1) : "";
 }
-function lowerFirst(str3) {
-  return str3 ? str3[0].toLowerCase() + str3.slice(1) : "";
+function lowerFirst(str4) {
+  return str4 ? str4[0].toLowerCase() + str4.slice(1) : "";
 }
-function pascalCase(str3, opts) {
-  return str3 ? (Array.isArray(str3) ? str3 : splitByCase(str3)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+function pascalCase(str4, opts) {
+  return str4 ? (Array.isArray(str4) ? str4 : splitByCase(str4)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
 }
-function camelCase(str3, opts) {
-  return lowerFirst(pascalCase(str3 || "", opts));
+function camelCase(str4, opts) {
+  return lowerFirst(pascalCase(str4 || "", opts));
 }
-function kebabCase(str3, joiner) {
-  return str3 ? (Array.isArray(str3) ? str3 : splitByCase(str3)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+function kebabCase(str4, joiner) {
+  return str4 ? (Array.isArray(str4) ? str4 : splitByCase(str4)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-function snakeCase(str3) {
-  return kebabCase(str3 || "", "_");
+function snakeCase(str4) {
+  return kebabCase(str4 || "", "_");
 }
 
 // ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
@@ -5370,11 +5374,13 @@ var contentTypeForPath = (path) => src_default.getType(path) ?? "application/oct
 // src/output.ts
 var toJson = (data) => JSON.stringify(data, null, 2);
 var fmtWorkspace = (w) => `${w.id}  ${w.name}`;
+var fmtWorkerTemplate = (t) => `${t.id}  ${t.name}  [${t.available ? "available" : "unavailable"}]  ${t.agentKinds.join(", ")}`;
+var fmtWorkerCreation = (c) => `${c.id}  [${c.status}/${c.step ?? "pending"}]  ${c.name}  ${c.agentKind}${c.workerId === null ? "" : `  W-${c.workerId}`}${c.error ? `  ${c.error}` : ""}`;
 var fmtProject = (p) => `${p.id}  ${p.name}`;
 var fmtRequirement = (r) => `${r.code}  [${r.status}]  ${r.title}`;
 var fmtTask = (t) => `${t.code}  [${t.status}]  ${t.title}`;
 var fmtComment = (c) => `${c.workerId !== void 0 ? `worker#${c.workerId}` : "you"}  ${c.body}`;
-var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.worktreePath ?? "(pending)"}`;
+var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.cwd ?? "(pending)"}`;
 var fmtWorker = (w) => {
   const offline = w.connected === false ? "  [offline]" : "";
   return `W-${w.id}  ${w.name}  ${w.hostname}  ${w.agentKind}${offline}`;
@@ -5486,6 +5492,11 @@ var primeLogin = (baseUrl) => {
   );
 };
 
+// src/client/files.ts
+var filesClient = (baseUrl) => ({
+  report: (result) => request(`${baseUrl}/workers/me/files/results`, { method: "PUT", body: result })
+});
+
 // src/client/loops.ts
 var loopsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5550,7 +5561,7 @@ var servicesClient = (baseUrl) => {
 };
 
 // src/client/retry.ts
-var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
 var withRetry = async (fn, opts = {}) => {
   const tries = Math.max(1, opts.tries ?? 4);
   const baseMs = opts.baseMs ?? 300;
@@ -5665,7 +5676,8 @@ var sessionsClient = (baseUrl) => {
     },
     destroy: async (id) => {
       await request(u(`/sessions/${id}`), { method: "DELETE" });
-    }
+    },
+    notify: (id, text) => request(u(`/sessions/${id}/notify`), { method: "POST", body: { text } })
   };
 };
 
@@ -5685,6 +5697,14 @@ var taskClient = (baseUrl) => {
   };
 };
 
+// src/client/worker-creations.ts
+var workerCreationsClient = (baseUrl) => ({
+  templates: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-templates`, { method: "GET" }),
+  create: (projectId, input) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "POST", body: input }),
+  listByProject: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "GET" }),
+  get: (id) => request(`${baseUrl}/worker-creations/${id}`, { method: "GET" })
+});
+
 // src/client/workers.ts
 var workersClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5725,6 +5745,7 @@ var createClient = (baseUrl, opts) => {
   return clientFromBase(baseUrl);
 };
 var clientFromBase = (baseUrl) => ({
+  workerCreations: workerCreationsClient(baseUrl),
   artifacts: artifactsClient(baseUrl),
   workspaces: workspaceClient(baseUrl),
   projects: projectClient(baseUrl),
@@ -5732,6 +5753,7 @@ var clientFromBase = (baseUrl) => ({
   tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
   services: servicesClient(baseUrl),
+  files: filesClient(baseUrl),
   loops: loopsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
@@ -5783,7 +5805,6 @@ var viewWorker = (cfg) => {
   return {
     server,
     projectId: project2,
-    baseBranch: cfg.baseBranch,
     workerId: worker2.id,
     agentKind: worker2.agentKind ?? "claude-code",
     name: worker2.name,
@@ -5791,29 +5812,40 @@ var viewWorker = (cfg) => {
     apiToken: worker2.apiToken
   };
 };
-var worktreeConfig = (cfg, session2) => ({
+var workerProjectConfig = (cfg) => ({
   server: cfg.server,
   project: cfg.projectId,
-  baseBranch: cfg.baseBranch,
   worker: {
     id: cfg.workerId,
     name: cfg.name,
     agentKind: cfg.agentKind,
     machineId: cfg.machineId,
     apiToken: cfg.apiToken
-  },
-  ...session2 === void 0 ? {} : { session: session2 }
+  }
+});
+var workerEnv = (cfg) => ({
+  ...Object.fromEntries(
+    Object.entries(process.env).filter(
+      (entry) => entry[1] !== void 0
+    )
+  ),
+  BATON_SERVER: cfg.server,
+  BATON_PROJECT_ID: String(cfg.projectId),
+  BATON_WORKER_ID: String(cfg.workerId),
+  BATON_WORKER_TOKEN: cfg.apiToken
 });
 
 // src/config.ts
 var resolveBaseUrl = (urlArg, env = process.env) => {
   if (urlArg) return urlArg;
+  if (env.BATON_SERVER) return env.BATON_SERVER;
   const cfg = loadProjectConfigOrNull(projectConfigPath());
   if (cfg?.server) return cfg.server;
   return env.BATON_URL ?? "http://localhost:3280";
 };
 var resolveBaseUrlOrNull = (urlArg, env = process.env) => {
   if (urlArg) return urlArg;
+  if (env.BATON_SERVER) return env.BATON_SERVER;
   const cfg = loadProjectConfigOrNull(projectConfigPath());
   if (cfg?.server) return cfg.server;
   return env.BATON_URL ?? null;
@@ -5823,7 +5855,7 @@ var resolveBaseUrlOrNull = (urlArg, env = process.env) => {
 var common = {
   url: {
     type: "string",
-    description: "baton server url (--url > .baton.json > BATON_URL > http://localhost:3280)"
+    description: "baton server url (--url > BATON_SERVER > .baton.json > BATON_URL > http://localhost:3280)"
   },
   json: { type: "boolean", description: "output JSON" }
 };
@@ -5846,6 +5878,8 @@ var resolveBearer = () => {
 };
 var resolveProjectId = (args) => {
   if (args.project !== void 0 && args.project !== "") return Number(args.project);
+  if (process.env.BATON_PROJECT_ID !== void 0)
+    return contextId(process.env.BATON_PROJECT_ID, "BATON_PROJECT_ID");
   const cfg = loadProjectConfigOrNull(projectConfigPath());
   if (cfg?.project !== void 0) return cfg.project;
   throw new Error("no project in scope. pass --project <id> or run `baton init` in this directory.");
@@ -5870,6 +5904,18 @@ var parseDuration = (s) => {
   const mult = m[2] === "d" ? 86400 : m[2] === "h" ? 3600 : m[2] === "m" ? 60 : 1;
   return n * mult;
 };
+var contextId = (value, source) => {
+  const id = Number(value);
+  if (!Number.isSafeInteger(id) || id <= 0) throw new Error(`invalid ${source}`);
+  return id;
+};
+var resolveWorkerId = () => {
+  if (process.env.BATON_WORKER_ID !== void 0)
+    return contextId(process.env.BATON_WORKER_ID, "BATON_WORKER_ID");
+  const id = loadProjectConfigOrNull(projectConfigPath())?.worker?.id;
+  if (id === void 0) throw new Error("no worker in scope");
+  return id;
+};
 
 // src/commands/artifact.ts
 var formatArtifact = (artifact2) => `${artifact2.id}  ${artifact2.size} B  ${artifact2.filename}  ${artifact2.url}`;
@@ -6227,11 +6273,11 @@ var EventSource = class extends EventTarget {
         return;
       }
       const decoder = new TextDecoder(), reader = body.getReader();
-      let open = true;
+      let open3 = true;
       do {
         const { done, value } = await reader.read();
-        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
-      } while (open);
+        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open3 = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+      } while (open3);
     }), __privateAdd(this, _onFetchError, (err) => {
       __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
     }), __privateAdd(this, _onEvent, (event) => {
@@ -6686,11 +6732,10 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // ../shared/src/domain/attachment.ts
-var isImageAttachment = (att) => att.contentType.startsWith("image/");
 var labelAttachments = (attachments) => {
   const counters = { image: 0, file: 0 };
   return attachments.map((att) => {
-    const kind = isImageAttachment(att) ? "image" : "file";
+    const kind = att.contentType.startsWith("image/") ? "image" : "file";
     counters[kind] += 1;
     return `${kind}-${counters[kind]}`;
   });
@@ -6699,6 +6744,77 @@ var labelAttachments = (attachments) => {
 // ../shared/src/domain/channel.ts
 var isMessageFor = (msg, name) => !msg.to || msg.to.length === 0 || msg.to.includes(name);
 
+// ../shared/src/domain/file.ts
+var FILE_TEXT_MAX_BYTES = 5 * 1024 * 1024;
+var FILE_DIRECTORY_MAX_ENTRIES = 2e3;
+var FILE_SEARCH_MAX_RESULTS = 500;
+var FILE_SEARCH_DEADLINE_MS = 5e3;
+var FILE_SEARCH_QUERY_MAX_LENGTH = 200;
+var FILE_RAW_MAX_BYTES = 5 * 1024 * 1024;
+var IMAGE_MEDIA_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  svg: "image/svg+xml"
+};
+var RAW_MEDIA_TYPES = {
+  ...IMAGE_MEDIA_TYPES,
+  css: "text/css",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf"
+};
+var mediaTypeIn = (types3) => (path) => {
+  const extension2 = /\.([a-z\d]+)$/i.exec(path)?.[1]?.toLowerCase();
+  return extension2 && types3[extension2] || null;
+};
+var imageMediaType = mediaTypeIn(IMAGE_MEDIA_TYPES);
+var rawMediaType = mediaTypeIn(RAW_MEDIA_TYPES);
+var normalizeFilePath = (value, allowRoot = false) => {
+  if (value === "") return allowRoot ? "" : null;
+  if (value.includes("\0") || value.includes("\\") || value.startsWith("/")) return null;
+  if (/^[A-Za-z]:/.test(value)) return null;
+  return value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..") ? value : null;
+};
+var SENSITIVE_SEGMENTS = /* @__PURE__ */ new Set([".git", ".ssh", ".aws", ".kube", ".gnupg"]);
+var SENSITIVE_NAMES = /* @__PURE__ */ new Set([
+  ".baton.json",
+  ".envrc",
+  ".npmrc",
+  ".netrc",
+  ".pypirc",
+  ".git-credentials",
+  ".pgpass",
+  ".htpasswd",
+  ".credentials.json"
+]);
+var SENSITIVE_EXTENSIONS = [".pem", ".key", ".p12", ".pfx", ".jks", ".keystore"];
+var isSensitiveName = (name) => SENSITIVE_NAMES.has(name) || /^\.env(\..+)?$/.test(name) && !/\.(example|sample|template)$/.test(name) || /^id_(rsa|dsa|ecdsa|ed25519)$/.test(name) || SENSITIVE_EXTENSIONS.some((extension2) => name.endsWith(extension2));
+var isSensitiveFilePath = (path) => {
+  const segments = path.toLowerCase().split("/");
+  return segments.some((segment) => SENSITIVE_SEGMENTS.has(segment)) || isSensitiveName(segments.at(-1) ?? "");
+};
+var EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".pnpm-store",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".venv",
+  "__pycache__",
+  "target"
+]);
+var isExcludedDirectoryName = (name) => EXCLUDED_DIRECTORIES.has(name);
+
 // ../shared/src/domain/service.ts
 var SERVICE_PUBLIC_URL_MAX_LENGTH = 2048;
 var SERVICE_NOTE_MAX_LENGTH = 500;
@@ -6713,6 +6829,12 @@ var isServicePublicUrl = (value) => {
 };
 var isServiceNote = (value) => value.length > 0 && value.length <= SERVICE_NOTE_MAX_LENGTH;
 
+// ../shared/src/domain/session.ts
+var AGENT_KINDS = ["claude-code", "codex", "pi"];
+var isAgentKind = (v) => typeof v === "string" && AGENT_KINDS.includes(v);
+var EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+var isAgentEffort = (v) => typeof v === "string" && EFFORTS.includes(v);
+
 // ../shared/src/domain/session-event.ts
 var agentMessageText = (payload) => {
   if (typeof payload !== "object" || payload === null) return null;
@@ -6726,6 +6848,15 @@ var agentMessageText = (payload) => {
   return trimmed ? { id, text: trimmed } : null;
 };
 
+// ../shared/src/domain/worker-creation.ts
+var WORKER_TEMPLATES = [
+  { id: "mini-glm-codeplan", name: "GLM Code Plan", agentKinds: ["claude-code", "pi"] },
+  { id: "mini-dashscope-codeplan", name: "DashScope Code Plan", agentKinds: ["claude-code", "pi"] },
+  { id: "mini-codex", name: "\u672C\u673A Codex", agentKinds: ["codex"] }
+];
+var workerTemplateAgentKinds = (id) => id === "mini-local" ? AGENT_KINDS : WORKER_TEMPLATES.find((template) => template.id === id)?.agentKinds ?? [];
+var isWorkerTemplateId = (value) => typeof value === "string" && workerTemplateAgentKinds(value).length > 0;
+
 // src/commands/channel/listen.ts
 var PREVIEW = 280;
 var describe = (e) => {
@@ -6776,10 +6907,10 @@ var runListen = async (o) => {
     onError: (e) => emit({ type: "channel.error", error: describe(e) })
   });
   emit({ type: "channel.listening", channel: o.channel, from: o.from, url: o.url });
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     const stop = () => {
       close();
-      resolve3();
+      resolve4();
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
@@ -7034,10 +7165,6 @@ var init = defineCommand({
 });
 
 // src/commands/session/shared.ts
-import { homedir } from "node:os";
-import { join as join3 } from "node:path";
-var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join3(env.XDG_DATA_HOME ?? join3(env.HOME ?? homedir(), ".local/share"), "baton", "worktrees");
-var slug = (s) => s.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
 var resolveSession = async (client, projectId, handle) => {
   const asInt = Number(handle);
   if (Number.isInteger(asInt) && asInt > 0) {
@@ -7190,6 +7317,34 @@ var loop = defineCommand({
   }
 });
 
+// src/commands/notify.ts
+var describe2 = (result) => {
+  if (result.status === "sent") return `notified ${result.devices} device(s)`;
+  if (result.status === "throttled")
+    return `throttled: this session can notify again in ${result.retryAfterSec}s`;
+  return "nobody to notify: no human has messaged this session, or they have not enabled notifications";
+};
+var notify = defineCommand({
+  meta: {
+    name: "notify",
+    description: "Push a phone notification to the person working with this session. Use it only when a human needs to act now: something is wrong, a decision is needed, or the work is blocked. Do not use it for routine progress, and not to announce that a turn finished (that is already pushed). At most one notification per session every 10 minutes; text is cut at 200 characters."
+  },
+  args: {
+    text: { type: "positional", required: true, description: "one short line for the lock screen" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const raw = process.env.BATON_SESSION_ID;
+    if (raw === void 0)
+      throw new Error("baton notify only works inside a baton session (BATON_SESSION_ID is unset)");
+    const sessionId = Number(raw);
+    if (!Number.isSafeInteger(sessionId) || sessionId <= 0)
+      throw new Error("invalid BATON_SESSION_ID");
+    const result = await clientFor(args).sessions.notify(sessionId, args.text);
+    console.log(args.json ? toJson(result) : describe2(result));
+  }
+});
+
 // src/commands/project.ts
 var createProject = (c, input, json) => c.projects.create(input).then((p) => renderOne(p, fmtProject, json));
 var listProjects = (c, workspaceId, json) => c.projects.listByWorkspace(workspaceId).then((ps) => renderList(ps, fmtProject, json));
@@ -7264,10 +7419,519 @@ var project = defineCommand({
   }
 });
 
+// src/provisioner/config.ts
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access, readFile, stat as stat2 } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { promisify } from "node:util";
+var forbiddenEnv = /* @__PURE__ */ new Set([
+  "BATON_PROVISIONER_TOKEN",
+  "BATON_TOKEN",
+  "BATON_WORKER_TOKEN",
+  "BATON_USER",
+  "BATON_PASS",
+  "HOME",
+  "XDG_DATA_HOME"
+]);
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var absolutePath = (value, field) => {
+  if (typeof value !== "string" || !isAbsolute(value) || value.includes("\0"))
+    throw new Error(`${field} must be an absolute path`);
+  return value;
+};
+var environment = (value) => {
+  if (!object(value)) throw new Error("workerEnv must be an object");
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => {
+      if (forbiddenEnv.has(key) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || typeof entry !== "string" || entry.includes("\0"))
+        throw new Error(`invalid worker environment key: ${key}`);
+      return [key, entry];
+    })
+  );
+};
+var templates = (value) => {
+  if (!object(value)) throw new Error("templates must be an object");
+  return Object.fromEntries(
+    WORKER_TEMPLATES.map((template) => {
+      const raw = value[template.id];
+      if (!object(raw)) throw new Error(`template ${template.id} must be configured`);
+      const workerEnv2 = environment(raw.workerEnv);
+      if (template.id === "mini-codex") {
+        if (raw.pi !== void 0) throw new Error("mini-codex does not support pi");
+        return [template.id, { workerEnv: workerEnv2 }];
+      }
+      const provider = template.id === "mini-glm-codeplan" ? "zai-coding-cn" : "qwen-token-plan-cn";
+      const apiKey = template.id === "mini-glm-codeplan" ? "ZAI_CODING_CN_API_KEY" : "QWEN_TOKEN_PLAN_CN_API_KEY";
+      if (!workerEnv2.ANTHROPIC_BASE_URL || !(workerEnv2.ANTHROPIC_AUTH_TOKEN || workerEnv2.ANTHROPIC_API_KEY) || !workerEnv2[apiKey])
+        throw new Error(`template ${template.id} requires Claude and Pi credentials`);
+      if (!object(raw.pi) || raw.pi.provider !== provider || typeof raw.pi.model !== "string" || !raw.pi.model.trim())
+        throw new Error(`template ${template.id} requires its Pi provider and model`);
+      return [template.id, { workerEnv: workerEnv2, pi: { provider, model: raw.pi.model.trim() } }];
+    })
+  );
+};
+var commandEnvironment = (config) => ({
+  ...process.env,
+  PATH: config.workerEnv.PATH ?? process.env.PATH ?? "/usr/bin:/bin"
+});
+var loadProvisionerConfig = async (path) => {
+  if (process.platform !== "darwin") throw new Error("provisioner requires macOS");
+  absolutePath(path, "config");
+  if ((await stat2(path)).mode & 63) throw new Error("config must be private: chmod 600 <config>");
+  const text = await readFile(path, "utf8");
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    throw new Error("invalid provisioner JSON config");
+  }
+  if (!object(raw) || typeof raw.server !== "string" || typeof raw.token !== "string")
+    throw new Error("server and token required");
+  let server;
+  try {
+    server = new URL(raw.server);
+  } catch (error) {
+    if (!(error instanceof TypeError)) throw error;
+    throw new Error("server must be a valid HTTP(S) URL");
+  }
+  if (!["http:", "https:"].includes(server.protocol) || server.username || server.password || server.search || server.hash)
+    throw new Error("server must be an HTTP(S) URL without credentials, query, or fragment");
+  if (!raw.token.trim() || /[\r\n]/.test(raw.token))
+    throw new Error("valid provisioner token required");
+  const config = {
+    server: server.toString().replace(/\/$/, ""),
+    token: raw.token.trim(),
+    projectsRoot: absolutePath(raw.projectsRoot, "projectsRoot"),
+    cliPath: absolutePath(raw.cliPath, "cliPath"),
+    nodePath: absolutePath(raw.nodePath ?? process.execPath, "nodePath"),
+    workerEnv: environment(raw.workerEnv),
+    templates: templates(raw.templates)
+  };
+  await access(config.cliPath, constants.R_OK);
+  await access(config.nodePath ?? process.execPath, constants.X_OK);
+  const env = commandEnvironment(config);
+  await promisify(execFile)("git", ["--version"], { env, timeout: 1e4 });
+  await promisify(execFile)("launchctl", ["help"], { env, timeout: 1e4 });
+  await promisify(execFile)("/usr/bin/plutil", ["-help"], { timeout: 1e4 });
+  return config;
+};
+
+// src/provisioner/client.ts
+var createProvisionerClient = (config) => {
+  const request2 = async (path, token, body, signal) => {
+    const timeout = AbortSignal.timeout(1e4);
+    const response = await fetch(`${config.server}${path}`, {
+      method: body === void 0 ? "GET" : "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        ...body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new HttpError(response.status, `provisioner request ${path}: HTTP ${response.status}`);
+    }
+    return await response.json();
+  };
+  return {
+    get: (id, signal) => request2(`/provisioner/worker-creations/${id}`, config.token, void 0, signal),
+    report: (id, report, signal) => request2(`/provisioner/worker-creations/${id}/progress`, config.token, report, signal),
+    register: (id, hostname2, signal) => request2(`/provisioner/worker-creations/${id}/worker`, config.token, { hostname: hostname2 }, signal),
+    worker: (id, token, signal) => request2(`/workers/${id}`, token, void 0, signal)
+  };
+};
+
+// src/provisioner/executor.ts
+import { execFile as execFile3 } from "node:child_process";
+import { lstat, mkdir as mkdir3, realpath, writeFile as writeFile2 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join as join5 } from "node:path";
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+import { promisify as promisify3 } from "node:util";
+
+// src/provisioner/launchd.ts
+import { execFile as execFile2 } from "node:child_process";
+import { mkdir, open } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join as join3 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var workerStatePath = (config, creation) => join3(
+  config.projectsRoot,
+  ".worker-state",
+  `project-${creation.projectId}`,
+  `creation-${creation.id}`
+);
+var workerLogPath = (creation) => join3(homedir(), "Library/Logs", `baton-worker-creation-${creation.id}.log`);
+var startAgent = async (config, agent, signal) => {
+  signal?.throwIfAborted();
+  const plist = join3(homedir(), "Library/LaunchAgents", `${agent.label}.plist`);
+  await mkdir(dirname(plist), { recursive: true });
+  await mkdir(dirname(agent.log), { recursive: true });
+  const domain = `gui/${process.getuid?.()}`;
+  const env = commandEnvironment(config);
+  try {
+    await promisify2(execFile2)("launchctl", ["print", `${domain}/${agent.label}`], {
+      env,
+      timeout: 1e4,
+      signal
+    });
+    throw new Error(
+      `launchd service already exists: ${agent.label}; stop it manually before installing`
+    );
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === 113 && "stderr" in error && typeof error.stderr === "string" && error.stderr.includes("Could not find service")))
+      throw error;
+  }
+  const handle = await open(plist, "wx", 384);
+  try {
+    const payload = {
+      Label: agent.label,
+      ProgramArguments: agent.args,
+      WorkingDirectory: agent.cwd,
+      EnvironmentVariables: agent.env,
+      RunAtLoad: true,
+      KeepAlive: true,
+      ThrottleInterval: 10,
+      StandardOutPath: agent.log,
+      StandardErrorPath: agent.log
+    };
+    await handle.writeFile(JSON.stringify(payload));
+  } finally {
+    await handle.close();
+  }
+  const log = await open(agent.log, "a", 384);
+  await log.close();
+  try {
+    await promisify2(execFile2)("/usr/bin/plutil", ["-convert", "xml1", plist], {
+      timeout: 1e4,
+      signal
+    });
+    await promisify2(execFile2)("/usr/bin/plutil", ["-lint", plist], { timeout: 1e4, signal });
+    await promisify2(execFile2)("launchctl", ["bootstrap", domain, plist], {
+      env,
+      timeout: 1e4,
+      signal
+    });
+  } catch {
+    throw new Error(`launchd start failed; inspect ${plist} and ${agent.log}`);
+  }
+};
+var launchWorkerAgent = async (config, creation, repoPath, workerEnv2, signal) => startAgent(
+  config,
+  {
+    label: `dev.fmap.baton-worker-creation-${creation.id}`,
+    args: [config.nodePath ?? process.execPath, config.cliPath, "worker", "run"],
+    cwd: repoPath,
+    env: {
+      PATH: workerEnv2.PATH ?? process.env.PATH ?? "/usr/bin:/bin",
+      ...workerEnv2,
+      HOME: homedir(),
+      XDG_DATA_HOME: workerStatePath(config, creation)
+    },
+    log: workerLogPath(creation)
+  },
+  signal
+);
+var installProvisionerAgent = async (config, configPath) => startAgent(config, {
+  label: "dev.fmap.baton-provisioner",
+  args: [
+    config.nodePath ?? process.execPath,
+    config.cliPath,
+    "provisioner",
+    "run",
+    "--config",
+    configPath
+  ],
+  cwd: dirname(configPath),
+  env: { HOME: homedir(), PATH: config.workerEnv.PATH ?? process.env.PATH ?? "/usr/bin:/bin" },
+  log: join3(homedir(), "Library/Logs/baton-provisioner.log")
+});
+
+// src/provisioner/worker-template.ts
+import { mkdir as mkdir2, writeFile } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var workerTemplateEnvironment = async (config, creation, state) => {
+  if (!workerTemplateAgentKinds(creation.templateId).includes(creation.agentKind))
+    throw new Error("agentKind is not supported by this template");
+  if (creation.templateId === "mini-local") return config.workerEnv;
+  const profile = config.templates[creation.templateId];
+  if (!profile) throw new Error(`template ${creation.templateId} is not configured`);
+  if (creation.agentKind !== "pi") return profile.workerEnv;
+  if (!profile.pi) throw new Error("Pi provider and model are not configured");
+  const agentDir = join4(state, "pi");
+  await mkdir2(agentDir, { mode: 448 });
+  await writeFile(
+    join4(agentDir, "settings.json"),
+    JSON.stringify({
+      defaultProvider: profile.pi.provider,
+      defaultModel: profile.pi.model
+    }),
+    { flag: "wx", mode: 384 }
+  );
+  return { ...profile.workerEnv, PI_CODING_AGENT_DIR: agentDir };
+};
+
+// src/provisioner/executor.ts
+var directory = async (path) => {
+  try {
+    await mkdir3(path, { mode: 448 });
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+  }
+  const info = await lstat(path);
+  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`unsafe directory: ${path}`);
+};
+var provisionWorker = async (config, creation, client, signal) => {
+  const repoPath = join5(
+    config.projectsRoot,
+    `project-${creation.projectId}`,
+    `creation-${creation.id}`
+  );
+  const progress = (step) => client.report(creation.id, { status: "running", step, repoPath }, signal);
+  await progress("directory");
+  signal.throwIfAborted();
+  await mkdir3(config.projectsRoot, { recursive: true, mode: 448 });
+  const root = await realpath(config.projectsRoot);
+  await directory(join5(root, `project-${creation.projectId}`));
+  await mkdir3(join5(root, `project-${creation.projectId}`, `creation-${creation.id}`), {
+    mode: 448
+  });
+  await progress("git");
+  const git2 = async (args) => {
+    try {
+      await promisify3(execFile3)("git", ["-C", repoPath, ...args], {
+        env: commandEnvironment(config),
+        signal,
+        timeout: 1e4
+      });
+    } catch (error) {
+      signal.throwIfAborted();
+      throw new Error("Git repository initialization failed", { cause: error });
+    }
+  };
+  await git2(["init", "-b", "main"]);
+  await writeFile2(join5(repoPath, ".git/info/exclude"), "\n.baton.json\n", { flag: "a" });
+  await git2([
+    "-c",
+    "user.name=Baton",
+    "-c",
+    "user.email=baton@localhost",
+    "commit",
+    "--allow-empty",
+    "-m",
+    "chore: initialize repository"
+  ]);
+  await progress("register");
+  const result = await client.register(creation.id, hostname(), signal);
+  const state = workerStatePath(config, creation);
+  await directory(join5(root, ".worker-state"));
+  await directory(join5(root, ".worker-state", `project-${creation.projectId}`));
+  await mkdir3(state, { mode: 448 });
+  await mkdir3(join5(state, "baton"), { mode: 448 });
+  await writeFile2(join5(state, "baton/machine-id"), `${creation.machineId}
+`, {
+    flag: "wx",
+    mode: 384
+  });
+  const cfg = workerProjectConfig({
+    server: config.server,
+    projectId: creation.projectId,
+    workerId: result.worker.id,
+    name: result.worker.name,
+    agentKind: result.worker.agentKind,
+    machineId: result.worker.machineId,
+    apiToken: result.apiToken
+  });
+  await writeFile2(join5(repoPath, ".baton.json"), `${JSON.stringify(cfg, null, 2)}
+`, {
+    flag: "wx",
+    mode: 384
+  });
+  await progress("start");
+  signal.throwIfAborted();
+  const workerEnv2 = await workerTemplateEnvironment(config, creation, state);
+  await launchWorkerAgent(config, creation, repoPath, workerEnv2, signal);
+  await progress("connect");
+  const deadline = Date.now() + 6e4;
+  while (Date.now() < deadline) {
+    const worker2 = await client.worker(result.worker.id, result.apiToken, signal);
+    if (worker2.connected) {
+      await client.report(creation.id, { status: "succeeded" }, signal);
+      return;
+    }
+    await setTimeout2(1e3, void 0, { signal });
+  }
+  throw new Error("Worker did not connect within 60 seconds");
+};
+
+// src/provisioner/daemon.ts
+var taskError = (error, config) => {
+  const message = error instanceof Error ? error.message : "unknown creation error";
+  return [
+    config.token,
+    ...Object.values(config.workerEnv),
+    ...Object.values(config.templates).flatMap((template) => Object.values(template.workerEnv))
+  ].filter((value) => value.length > 0).reduce((safe, secret) => safe.replaceAll(secret, "[redacted]"), message);
+};
+var processCreation = async (id, config, client, signal) => {
+  let creation;
+  try {
+    creation = await client.get(id, signal);
+  } catch (error) {
+    if (error instanceof HttpError && error.status === 404) {
+      console.error(`[provisioner] creation ${id} no longer exists`);
+      return;
+    }
+    throw error;
+  }
+  if (creation.status === "succeeded" || creation.status === "failed") return;
+  if (creation.status === "running") {
+    await client.report(
+      id,
+      {
+        status: "failed",
+        error: "Provisioner interrupted; inspect retained resources before creating again"
+      },
+      signal
+    );
+    return;
+  }
+  try {
+    await provisionWorker(config, creation, client, signal);
+  } catch (error) {
+    if (signal.aborted) {
+      console.error(`[provisioner] creation ${id} interrupted: ${taskError(error, config)}`);
+      return;
+    }
+    if (!(error instanceof HttpError) || ![401, 403].includes(error.status)) {
+      const message = `${taskError(error, config)}; worker log: ${workerLogPath(creation)}`;
+      console.error(`[provisioner] creation ${id}: ${message}`);
+      await client.report(id, { status: "failed", error: message }, signal);
+      return;
+    }
+    throw error;
+  }
+};
+var runProvisioner = async (config, signal) => {
+  const client = createProvisionerClient(config);
+  const abort = new AbortController();
+  const queued = /* @__PURE__ */ new Set();
+  let tail = Promise.resolve();
+  let fatal;
+  let finish = () => {
+  };
+  const ended = new Promise((resolve4) => {
+    finish = resolve4;
+  });
+  const stream = new EventSource(`${config.server}/provisioner/stream`, {
+    fetch: (url, init2) => fetch(url, {
+      ...init2,
+      headers: { ...init2?.headers, authorization: `Bearer ${config.token}` },
+      signal: abort.signal
+    })
+  });
+  const stop = () => {
+    stream.close();
+    abort.abort();
+    finish();
+  };
+  const fail = (error) => {
+    fatal = error;
+    console.error(`[provisioner] ${taskError(error, config)}`);
+    stop();
+  };
+  stream.onmessage = (event) => {
+    try {
+      const message = JSON.parse(event.data);
+      if (!message || !Number.isSafeInteger(message.creationId) || message.creationId <= 0 || !["create", "inspect"].includes(message.action))
+        throw new Error("invalid provisioner signal");
+      if (queued.has(message.creationId)) return;
+      queued.add(message.creationId);
+      tail = tail.then(async () => {
+        try {
+          if (!abort.signal.aborted)
+            await processCreation(message.creationId, config, client, abort.signal);
+        } finally {
+          queued.delete(message.creationId);
+        }
+      }).catch((error) => {
+        if (!abort.signal.aborted) fail(error);
+        else console.error(`[provisioner] stopped: ${taskError(error, config)}`);
+      });
+    } catch (error) {
+      fail(error);
+    }
+  };
+  stream.onerror = (event) => {
+    if (stream.readyState === EventSource.CLOSED || [401, 403, 409].includes(event.code ?? 0))
+      fail(new Error(`provisioner stream rejected: HTTP ${event.code}`));
+    else
+      console.error(`[provisioner] stream disconnected (${event.code ?? "network"}); reconnecting`);
+  };
+  signal.addEventListener("abort", stop, { once: true });
+  if (signal.aborted) stop();
+  console.log("[provisioner] waiting for worker creation requests");
+  try {
+    await ended;
+    await tail;
+  } finally {
+    stop();
+    signal.removeEventListener("abort", stop);
+  }
+  if (fatal !== void 0) throw new Error(taskError(fatal, config));
+};
+
+// src/commands/provisioner.ts
+var configArg = {
+  config: {
+    type: "string",
+    required: true,
+    description: "absolute path to private provisioner JSON config"
+  }
+};
+var provisioner = defineCommand({
+  meta: {
+    name: "provisioner",
+    description: "prepare local repositories and launch workers on macOS"
+  },
+  subCommands: {
+    run: defineCommand({
+      args: configArg,
+      run: async ({ args }) => {
+        const config = await loadProvisionerConfig(args.config);
+        const abort = new AbortController();
+        const stop = () => abort.abort();
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        try {
+          await runProvisioner(config, abort.signal);
+        } finally {
+          process.off("SIGINT", stop);
+          process.off("SIGTERM", stop);
+        }
+      }
+    }),
+    install: defineCommand({
+      args: configArg,
+      run: async ({ args }) => {
+        const config = await loadProvisionerConfig(args.config);
+        await installProvisionerAgent(config, args.config);
+        console.log(
+          "installed dev.fmap.baton-provisioner; inspect ~/Library/Logs/baton-provisioner.log"
+        );
+      }
+    })
+  }
+});
+
 // src/commands/relay.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/client/relay.ts
 var relayClient = (baseUrl) => {
@@ -7395,11 +8059,11 @@ var listenCommand2 = defineCommand({
       process.stdout.write(`${JSON.stringify(o)}
 `);
     };
-    const spillDir = join4(tmpdir2(), "hotline", args.channel);
+    const spillDir = join6(tmpdir2(), "hotline", args.channel);
     mkdirSync2(spillDir, { recursive: true });
     const surface = (m) => {
       const text = typeof m.text === "string" ? m.text : "";
-      const file = join4(spillDir, `${m.seq}.txt`);
+      const file = join6(spillDir, `${m.seq}.txt`);
       writeFileSync4(file, text);
       const truncated = text.length > PREVIEW2;
       emit({
@@ -7413,7 +8077,7 @@ var listenCommand2 = defineCommand({
         file
       });
     };
-    const describe2 = (e) => {
+    const describe3 = (e) => {
       const ev = e;
       return ev?.code ? `${ev.code}${ev.message ? ` ${ev.message}` : ""}` : String(e);
     };
@@ -7423,13 +8087,13 @@ var listenCommand2 = defineCommand({
       onMessage: (m) => {
         if (m.from !== me) surface(m);
       },
-      onError: (e) => emit({ type: "relay.error", error: describe2(e) })
+      onError: (e) => emit({ type: "relay.error", error: describe3(e) })
     });
     emit({ type: "relay.listening", channel: args.channel, from: me, url });
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       const stop = () => {
         close();
-        resolve3();
+        resolve4();
       };
       process.on("SIGINT", stop);
       process.on("SIGTERM", stop);
@@ -7553,6 +8217,9 @@ var requirement = defineCommand({
   }
 });
 
+// src/commands/service.ts
+import { resolve as resolve2 } from "node:path";
+
 // src/worker/service-child.ts
 import { spawn } from "node:child_process";
 
@@ -7633,25 +8300,15 @@ var formatUptime = (startedAt, now = Date.now()) => {
   if (seconds >= 60) return `${Math.floor(seconds / 60)}m`;
   return `${seconds}s`;
 };
-var currentContext = () => {
-  const config = loadProjectConfig(projectConfigPath());
-  if (!config.worker || !config.session)
-    throw new Error("service run requires a Baton session worktree");
-  return { workerId: config.worker.id, sessionId: config.session };
-};
-var currentWorker = () => {
-  const worker2 = loadProjectConfig(projectConfigPath()).worker;
-  if (!worker2) throw new Error("no worker in scope");
-  return worker2.id;
-};
 var parseTarget = (target) => {
   const explicit = target.match(/^W-(\d+)\/(.+)$/i);
-  return explicit ? { workerId: Number(explicit[1]), name: explicit[2] ?? "" } : { workerId: currentWorker(), name: target };
+  return explicit ? { workerId: Number(explicit[1]), name: explicit[2] ?? "" } : { workerId: resolveWorkerId(), name: target };
 };
 var runCommand2 = defineCommand({
   meta: { name: "run", description: "run a service on the current worker" },
   args: {
     name: { type: "positional", required: true, description: "service name" },
+    cwd: { type: "string", required: true, description: "service working directory on the Worker" },
     "public-url": { type: "string", description: "public HTTP(S) URL for this service" },
     note: { type: "string", description: "short note describing this service" },
     ...common
@@ -7666,9 +8323,9 @@ var runCommand2 = defineCommand({
       throw new Error("--public-url must be an absolute HTTP(S) URL");
     if (note && !isServiceNote(note))
       throw new Error("service note must be 500 characters or fewer");
-    const context = currentContext();
-    const result = await clientFor(args).services.run(context.workerId, {
-      sessionId: context.sessionId,
+    const workerId = resolveWorkerId();
+    const result = await clientFor(args).services.run(workerId, {
+      cwd: resolve2(args.cwd),
       name: args.name,
       argv,
       ...publicUrl ? { publicUrl } : {},
@@ -7676,7 +8333,7 @@ var runCommand2 = defineCommand({
     });
     if (!result.ok) throw new Error(result.error);
     if (args.json) return console.log(toJson(result));
-    console.log(`running W-${context.workerId}/${args.name}`);
+    console.log(`running W-${workerId}/${args.name}`);
     if (publicUrl) console.log(`public: ${publicUrl}`);
     if (result.logPath) console.log(`logs: ${result.logPath}`);
   }
@@ -7693,7 +8350,7 @@ var lsCommand = defineCommand({
     const workers = await client.workers.listByProject(projectId);
     const names = new Map(workers.map((worker2) => [worker2.id, worker2.name]));
     services.sort((a, b) => a.workerId - b.workerId || a.name.localeCompare(b.name)).map(
-      (item) => `${serviceHandle(item)}  ${names.get(item.workerId) ?? "unknown"}  session=${item.sessionId}  uptime=${formatUptime(item.startedAt)}`
+      (item) => `${serviceHandle(item)}  ${names.get(item.workerId) ?? "unknown"}  cwd=${item.cwd}  uptime=${formatUptime(item.startedAt)}`
     ).forEach((line) => {
       console.log(line);
     });
@@ -7743,7 +8400,7 @@ var sessionAbortCommand = defineCommand({
 var sessionClearCommand = defineCommand({
   meta: {
     name: "clear",
-    description: "reset the conversation context (keeps the session + worktree)"
+    description: "reset the conversation context (keeps the session + directory)"
   },
   args: {
     session: { type: "positional", required: true, description: "session int id or name" },
@@ -7852,7 +8509,7 @@ var sessionResumeCommand = defineCommand({
 
 // src/commands/session/rm.ts
 var sessionRmCommand = defineCommand({
-  meta: { name: "rm", description: "delete a session (irreversible; removes its worktree)" },
+  meta: { name: "rm", description: "delete a session (irreversible; removes its runtime files)" },
   args: {
     session: { type: "positional", required: true, description: "session int id or name" },
     project: { type: "string", description: "project id (overrides .baton.json)" },
@@ -7863,7 +8520,9 @@ var sessionRmCommand = defineCommand({
     const c = clientFor(args);
     const handle = await resolveSession(c, resolveProjectId(args), args.session);
     if (!args.confirm) {
-      console.log(`[dry-run] would delete session ${handle.name} (#${handle.id}) + its worktree`);
+      console.log(
+        `[dry-run] would delete session ${handle.name} (#${handle.id}) + its runtime files`
+      );
       console.log("re-run with --confirm to proceed.");
       return;
     }
@@ -7879,12 +8538,12 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 // src/session/runner/transcript.ts
 import { readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 var findTranscriptPath = (agentSessionId) => {
-  const root = join5(homedir2(), ".claude", "projects");
+  const root = join7(homedir2(), ".claude", "projects");
   try {
     for (const dir of readdirSync(root)) {
-      const candidate = join5(root, dir, `${agentSessionId}.jsonl`);
+      const candidate = join7(root, dir, `${agentSessionId}.jsonl`);
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
@@ -7962,16 +8621,15 @@ var readFirstExchange = (agentSessionId) => {
 };
 
 // src/session/runner/turn.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 
 // src/session/runner/attachments.ts
 import { createWriteStream } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { mkdir as mkdir4 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-var ATTACH_DIR = "attachments";
 var dedupe = (name, taken) => {
   if (!taken.has(name)) {
     taken.add(name);
@@ -7991,25 +8649,24 @@ var dedupe = (name, taken) => {
 };
 var materializeAttachments = async (opts) => {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const dir = join6(opts.worktreePath, ATTACH_DIR);
-  await mkdir(dir, { recursive: true });
-  await writeFile(join6(dir, ".gitignore"), "*\n", "utf8");
-  const taken = /* @__PURE__ */ new Set([".gitignore"]);
-  const relPaths = [];
+  const dir = opts.directory;
+  await mkdir4(dir, { recursive: true });
+  const taken = /* @__PURE__ */ new Set();
+  const paths = [];
   for (const att of opts.attachments) {
     const name = dedupe(att.filename, taken);
     const res = await fetchImpl(`${opts.serverBase}${att.url}`);
     if (!res.ok || !res.body) throw new Error(`attachment ${att.id} \u2192 ${res.status}`);
-    await pipeline(Readable.fromWeb(res.body), createWriteStream(join6(dir, name)));
-    relPaths.push(`${ATTACH_DIR}/${name}`);
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(join8(dir, name)));
+    paths.push(join8(dir, name));
   }
-  return relPaths;
+  return paths;
 };
-var augmentPrompt = (text, relPaths, labels) => {
-  if (relPaths.length === 0) return text;
+var augmentPrompt = (text, paths, labels) => {
+  if (paths.length === 0) return text;
   const header = [
-    "[Attached files \u2014 already saved in the working directory. Reference them by label:]",
-    ...relPaths.map((p, i) => `- {${labels[i]}} ${p}`)
+    "[Attached files \u2014 already saved locally. Reference them by label:]",
+    ...paths.map((p, i) => `- {${labels[i]}} ${p}`)
   ].join("\n");
   return text.length > 0 ? `${header}
 
@@ -8017,19 +8674,20 @@ ${text}` : header;
 };
 
 // src/session/runner/codex.ts
+import { join as join9 } from "node:path";
 import { Codex } from "@openai/codex-sdk";
 
 // src/session/runner/sdk-env.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { isAbsolute } from "node:path";
+import { isAbsolute as isAbsolute2 } from "node:path";
 var buildSdkEnv = (overlay) => overlay ? { ...process.env, ...overlay } : void 0;
 var claudeExecutable = () => process.env.BATON_CLAUDE_BIN;
-var additionalDirs = () => {
+var additionalDirs = (required = []) => {
   const raw = process.env.BATON_ADD_DIRS;
-  if (!raw) return void 0;
-  const dirs = raw.split(":").map((s) => s.trim()).filter((s) => s !== "" && isAbsolute(s) && existsSync3(s));
-  return dirs.length > 0 ? dirs : void 0;
+  const dirs = [...required, ...(raw ?? "").split(":")].map((s) => s.trim()).filter((s) => s !== "" && isAbsolute2(s) && existsSync3(s));
+  return dirs.length > 0 ? [...new Set(dirs)] : void 0;
 };
+var PLAN_MODE_PREFIX = "Plan mode: inspect and propose a plan only. Do not edit files or run mutating commands.\n\n";
 var truthy = (value) => {
   if (value === void 0) return void 0;
   const normalized = value.trim().toLowerCase();
@@ -8050,17 +8708,8 @@ var codexApprovalPolicy = () => {
     return raw;
   return "never";
 };
-var claudeEffort = (raw) => {
-  if (raw === "minimal") return "low";
-  if (raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
-    return raw;
-  return void 0;
-};
-var codexEffort = (raw) => {
-  if (raw === "minimal" || raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
-    return raw;
-  return void 0;
-};
+var claudeEffort = (raw) => raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max" ? raw : void 0;
+var codexEffort = (raw) => isAgentEffort(raw) ? raw : void 0;
 
 // src/session/runner/codex.ts
 var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -8178,17 +8827,16 @@ var toAgentEvent = (raw) => {
   return { type: "raw", raw };
 };
 var withPlanPrefix = (input) => {
-  const prefix = "Plan mode: inspect and propose a plan only. Do not edit files or run mutating commands.\n\n";
-  if (typeof input === "string") return `${prefix}${input}`;
+  if (typeof input === "string") return `${PLAN_MODE_PREFIX}${input}`;
   return input.map(
-    (entry, i) => i === 0 && entry.type === "text" ? { ...entry, text: `${prefix}${entry.text}` } : entry
+    (entry, i) => i === 0 && entry.type === "text" ? { ...entry, text: `${PLAN_MODE_PREFIX}${entry.text}` } : entry
   );
 };
 async function* startCodexEvents(config, input, worker2, opts) {
   const env = compactEnv(buildSdkEnv(opts.envOverlay));
   const codex = new Codex(env ? { env } : void 0);
   const resuming = !config.agentSessionId.startsWith("pending:");
-  const addDirs = additionalDirs();
+  const addDirs = additionalDirs([join9(config.runtimeDir, "attachments")]);
   const sandboxMode = codexSandboxMode(opts.planMode ?? false);
   const approvalPolicy = codexApprovalPolicy();
   const networkAccessEnabled = codexNetworkAccess();
@@ -8199,7 +8847,7 @@ async function* startCodexEvents(config, input, worker2, opts) {
   if (opts.model) opts.log(`[model] ${opts.model}`);
   if (reasoningEffort) opts.log(`[effort] ${reasoningEffort}`);
   const threadOptions = {
-    workingDirectory: config.worktreePath,
+    workingDirectory: config.cwd,
     skipGitRepoCheck: true,
     sandboxMode,
     approvalPolicy,
@@ -8218,8 +8866,7 @@ async function* startCodexEvents(config, input, worker2, opts) {
     if (event.type === "thread.started" && !resuming && event.sessionId) {
       config.agentSessionId = event.sessionId;
       await worker2.materialize({
-        agentSessionId: event.sessionId,
-        worktreePath: config.worktreePath
+        agentSessionId: event.sessionId
       });
       opts.log(`[codex] thread ${event.sessionId}`);
     }
@@ -8227,18 +8874,241 @@ async function* startCodexEvents(config, input, worker2, opts) {
   }
 }
 
+// src/session/runner/pi.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join10 } from "node:path";
+var newPiTurnState = (startedAt = Date.now()) => ({
+  startedAt,
+  usage: {},
+  toolArgs: {}
+});
+var READ_ONLY_TOOLS = ["read", "grep", "find", "ls"];
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str2 = (v) => typeof v === "string" ? v : void 0;
+var resultText = (result) => isRecord3(result) && Array.isArray(result.content) ? result.content.filter(isRecord3).map((block) => str2(block.text) ?? "").join("") : "";
+var startedItem = (id, name, args) => {
+  const input = isRecord3(args) ? args : {};
+  if (name === "bash") {
+    return {
+      type: "command_execution",
+      id,
+      status: "in_progress",
+      command: str2(input.command) ?? "",
+      output: ""
+    };
+  }
+  if (name === "write" || name === "edit") {
+    return {
+      type: "file_change",
+      id,
+      status: "in_progress",
+      changes: [{ path: str2(input.path) ?? "", kind: "update" }]
+    };
+  }
+  return { type: "tool_call", id, status: "in_progress", name, input: args ?? null };
+};
+var completedItem = (id, name, args, result, isError) => {
+  const status = isError ? "failed" : "completed";
+  const started = startedItem(id, name, args);
+  if (started.type === "command_execution") {
+    const structured = isRecord3(result) && isRecord3(result.structuredContent) ? result.structuredContent : {};
+    return {
+      ...started,
+      status,
+      output: str2(structured.output) ?? resultText(result),
+      exitCode: typeof structured.exit_code === "number" ? structured.exit_code : void 0
+    };
+  }
+  if (started.type === "tool_call") {
+    return { ...started, status, output: resultText(result), isError };
+  }
+  return { ...started, status };
+};
+var messageItems = (message) => message.content.flatMap((block, index) => {
+  const id = `${message.responseId ?? message.timestamp}:${index}`;
+  if (block.type === "text" && block.text.trim()) {
+    return [{ type: "agent_message", id, status: "completed", text: block.text }];
+  }
+  if (block.type === "thinking" && block.thinking.trim()) {
+    return [{ type: "reasoning", id, status: "completed", text: block.thinking }];
+  }
+  return [];
+});
+var addUsage = (total, usage) => ({
+  inputTokens: (total.inputTokens ?? 0) + usage.input,
+  cachedInputTokens: (total.cachedInputTokens ?? 0) + usage.cacheRead,
+  outputTokens: (total.outputTokens ?? 0) + usage.output,
+  reasoningOutputTokens: (total.reasoningOutputTokens ?? 0) + (usage.reasoning ?? 0),
+  totalCostUsd: (total.totalCostUsd ?? 0) + usage.cost.total,
+  numTurns: (total.numTurns ?? 0) + 1
+});
+var piToAgentEvents = (event, state, now = Date.now()) => {
+  if (event.type === "tool_execution_start") {
+    return {
+      events: [
+        { type: "item.started", item: startedItem(event.toolCallId, event.toolName, event.args) }
+      ],
+      state: { ...state, toolArgs: { ...state.toolArgs, [event.toolCallId]: event.args } }
+    };
+  }
+  if (event.type === "tool_execution_end") {
+    const args = state.toolArgs[event.toolCallId];
+    return {
+      events: [
+        {
+          type: "item.completed",
+          item: completedItem(event.toolCallId, event.toolName, args, event.result, event.isError)
+        }
+      ],
+      state
+    };
+  }
+  if (event.type === "message_end" && event.message.role === "assistant") {
+    const message = event.message;
+    return {
+      events: messageItems(message).map((item) => ({ type: "item.completed", item })),
+      // Reset on every assistant message: pi auto-retries, and only the last
+      // response decides whether the turn failed.
+      state: {
+        ...state,
+        usage: addUsage(state.usage, message.usage),
+        error: message.stopReason === "error" ? message.errorMessage ?? "pi turn failed" : void 0
+      }
+    };
+  }
+  if (event.type === "agent_settled") {
+    const usage = { ...state.usage, durationMs: now - state.startedAt };
+    return {
+      events: [
+        state.error ? { type: "turn.failed", error: { message: state.error }, usage } : { type: "turn.completed", usage }
+      ],
+      state
+    };
+  }
+  return { events: [], state };
+};
+var resolveModel = (runtime, raw) => {
+  const slash = raw.indexOf("/");
+  const model = slash > 0 ? runtime.getModel(raw.slice(0, slash), raw.slice(slash + 1)) : void 0;
+  if (!model) throw new Error(`unknown pi model "${raw}" (expected provider/model)`);
+  return model;
+};
+var promptParts = async (input) => {
+  if (typeof input === "string") return { text: input, images: [] };
+  const text = input.flatMap((entry) => entry.type === "text" ? [entry.text] : []).join("\n");
+  const images = await Promise.all(
+    input.flatMap(
+      (entry) => entry.type === "local_image" ? [
+        readFile2(entry.path).then((data) => ({
+          type: "image",
+          data: data.toString("base64"),
+          mimeType: contentTypeForPath(entry.path)
+        }))
+      ] : []
+    )
+  );
+  return { text, images };
+};
+async function* startPiEvents(config, input, opts) {
+  const pi = await import("@earendil-works/pi-coding-agent");
+  const modelRuntime = await pi.ModelRuntime.create();
+  const model = opts.model ? resolveModel(modelRuntime, opts.model) : void 0;
+  const effort = isAgentEffort(opts.effort) ? opts.effort : void 0;
+  const thinkingLevel = effort === "ultra" ? void 0 : effort;
+  const agentDir = pi.getAgentDir();
+  const resourceLoader = new pi.DefaultResourceLoader({
+    cwd: config.cwd,
+    agentDir,
+    // pi discovers .pi/ and .agents/ skills natively; Baton workers deploy theirs
+    // under .claude/skills (project and user level).
+    additionalSkillPaths: [join10(config.cwd, ".claude/skills"), join10(homedir3(), ".claude/skills")]
+  });
+  await resourceLoader.reload();
+  const existing = pi.SessionManager.findById(config.cwd, config.agentSessionId);
+  const sessionManager = existing ? pi.SessionManager.open(existing) : pi.SessionManager.create(config.cwd, void 0, { id: config.agentSessionId });
+  const { session: session2 } = await pi.createAgentSession({
+    cwd: config.cwd,
+    agentDir,
+    modelRuntime,
+    resourceLoader,
+    sessionManager,
+    ...model ? { model } : {},
+    ...thinkingLevel ? { thinkingLevel } : {},
+    ...opts.planMode ? { tools: READ_ONLY_TOOLS } : {}
+  });
+  const modelId = session2.model ? `${session2.model.provider}/${session2.model.id}` : void 0;
+  opts.log(`[pi] ${existing ? "resume" : "new"} session ${session2.sessionId}`);
+  if (modelId) opts.log(`[model] ${modelId}`);
+  if (thinkingLevel) opts.log(`[effort] ${thinkingLevel}`);
+  if (opts.planMode) opts.log("[plan] read-only tools");
+  const queue = [];
+  let wake = () => {
+  };
+  let failure;
+  let finished = false;
+  let settled = false;
+  const unsubscribe = session2.subscribe((event) => {
+    queue.push(event);
+    wake();
+  });
+  const abort = () => {
+    void session2.abort().catch((error) => opts.log(`[pi] abort: ${String(error)}`));
+  };
+  opts.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    yield { type: "thread.started", sessionId: session2.sessionId, model: modelId };
+    yield { type: "turn.started" };
+    const { text, images } = await promptParts(input);
+    if (opts.signal?.aborted) return;
+    const running = session2.prompt(opts.planMode ? `${PLAN_MODE_PREFIX}${text}` : text, images?.length ? { images } : {}).then(
+      () => {
+        finished = true;
+        wake();
+      },
+      (error) => {
+        failure = error;
+        wake();
+      }
+    );
+    let state = newPiTurnState();
+    while (!settled) {
+      const event = queue.shift();
+      if (!event) {
+        if (failure !== void 0) throw failure;
+        if (finished) break;
+        await new Promise((resolve4) => {
+          wake = resolve4;
+        });
+        continue;
+      }
+      const folded = piToAgentEvents(event, state);
+      state = folded.state;
+      settled = event.type === "agent_settled";
+      yield* folded.events;
+    }
+    await running;
+    if (failure !== void 0) throw failure;
+  } finally {
+    opts.signal?.removeEventListener("abort", abort);
+    unsubscribe();
+    session2.dispose();
+  }
+}
+
 // src/session/runner/query.ts
+import { join as join11 } from "node:path";
 var startQuery = (config, text, resuming, queryFn, abortController, log, { envOverlay, planMode = false, model, effort } = {}) => {
   const env = buildSdkEnv(envOverlay);
   const exe = claudeExecutable();
-  const addDirs = additionalDirs();
+  const addDirs = additionalDirs([join11(config.runtimeDir, "attachments")]);
   const level = claudeEffort(effort);
   if (addDirs) log(`[add-dir] ${addDirs.join(", ")}`);
   if (planMode) log("[plan] read-only planning turn");
   if (model) log(`[model] ${model}`);
   if (level) log(`[effort] ${level}`);
   const options = {
-    cwd: config.worktreePath,
+    cwd: config.cwd,
     permissionMode: planMode ? "plan" : "bypassPermissions",
     // Headless relay: no TTY/TUI can answer an interactive ask, so AskUserQuestion
     // would fail the whole turn. Block it — the model asks in plain text instead,
@@ -8279,34 +9149,34 @@ var streamAgentEvents = async (events, worker2) => {
   return result;
 };
 var streamClaudeSdkEvents = (messages, worker2) => streamAgentEvents(claudeToAgentEvents(messages), worker2);
-var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var str2 = (v) => typeof v === "string" ? v : void 0;
+var isRecord4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str3 = (v) => typeof v === "string" ? v : void 0;
 var messageContent = (payload) => {
   const msg = payload.message;
-  if (!isRecord3(msg) || !Array.isArray(msg.content)) return [];
-  return msg.content.filter(isRecord3);
+  if (!isRecord4(msg) || !Array.isArray(msg.content)) return [];
+  return msg.content.filter(isRecord4);
 };
 var textFromToolResult = (raw) => {
   const c = raw.content;
   if (typeof c === "string") return c;
   if (Array.isArray(c)) {
-    return c.map((b) => isRecord3(b) && typeof b.text === "string" ? b.text : JSON.stringify(b)).join("\n");
+    return c.map((b) => isRecord4(b) && typeof b.text === "string" ? b.text : JSON.stringify(b)).join("\n");
   }
   return JSON.stringify(c ?? "");
 };
 var commandOf = (input) => {
-  if (!isRecord3(input)) return "";
-  return str2(input.command) ?? str2(input.cmd) ?? "";
+  if (!isRecord4(input)) return "";
+  return str3(input.command) ?? str3(input.cmd) ?? "";
 };
 var pathOf = (input) => {
-  if (!isRecord3(input)) return void 0;
-  return str2(input.file_path) ?? str2(input.path);
+  if (!isRecord4(input)) return void 0;
+  return str3(input.file_path) ?? str3(input.path);
 };
 var fileKindOf = (name) => name === "Delete" ? "delete" : "update";
 var todoItems2 = (input) => {
-  if (!isRecord3(input) || !Array.isArray(input.todos)) return [];
-  return input.todos.filter(isRecord3).map((todo) => ({
-    text: str2(todo.content) ?? str2(todo.text) ?? "",
+  if (!isRecord4(input) || !Array.isArray(input.todos)) return [];
+  return input.todos.filter(isRecord4).map((todo) => ({
+    text: str3(todo.content) ?? str3(todo.text) ?? "",
     completed: todo.status === "completed" || todo.completed === true
   }));
 };
@@ -8315,8 +9185,8 @@ var mcpParts = (name) => {
   return match ? { server: match[1] ?? "", tool: match[2] ?? "" } : null;
 };
 var startedItemFromToolUse = (block) => {
-  const id = str2(block.id) ?? `tool-${Math.random().toString(36).slice(2)}`;
-  const name = str2(block.name) ?? "tool";
+  const id = str3(block.id) ?? `tool-${Math.random().toString(36).slice(2)}`;
+  const name = str3(block.name) ?? "tool";
   const input = block.input ?? null;
   if (name === "Bash") {
     return {
@@ -8352,7 +9222,7 @@ var startedItemFromToolUse = (block) => {
       type: "web_search",
       id,
       status: "in_progress",
-      query: isRecord3(input) ? str2(input.query) ?? "" : ""
+      query: isRecord4(input) ? str3(input.query) ?? "" : ""
     };
   }
   if (name === "TodoWrite") {
@@ -8371,9 +9241,9 @@ var completeItem = (item, output, isError) => {
 };
 var resultEvent = (message) => {
   const rec = message;
-  const subtype = str2(rec.subtype) ?? "unknown";
+  const subtype = str3(rec.subtype) ?? "unknown";
   const isError = rec.is_error === true || subtype !== "success";
-  const resultText = str2(rec.result) ?? "";
+  const resultText2 = str3(rec.result) ?? "";
   const usage = {
     numTurns: typeof rec.num_turns === "number" ? rec.num_turns : void 0,
     totalCostUsd: typeof rec.total_cost_usd === "number" ? rec.total_cost_usd : void 0,
@@ -8381,7 +9251,7 @@ var resultEvent = (message) => {
   };
   return isError ? {
     type: "turn.failed",
-    error: { message: resultText || `claude result: ${subtype}`, subtype },
+    error: { message: resultText2 || `claude result: ${subtype}`, subtype },
     usage,
     raw: message
   } : { type: "turn.completed", subtype, usage, raw: message };
@@ -8398,8 +9268,8 @@ async function* claudeToAgentEvents(messages) {
         systemEmitted = true;
         yield {
           type: "thread.started",
-          sessionId: str2(p.session_id) ?? "",
-          model: str2(p.model) ?? (isRecord3(p.model_info) ? str2(p.model_info.id) : void 0),
+          sessionId: str3(p.session_id) ?? "",
+          model: str3(p.model) ?? (isRecord4(p.model_info) ? str3(p.model_info.id) : void 0),
           raw: message
         };
         yield { type: "turn.started", raw: message };
@@ -8438,7 +9308,7 @@ async function* claudeToAgentEvents(messages) {
           pendingTools.set(item.id, item);
           yield { type: "item.started", item, raw: block };
         } else if (block.type === "tool_result") {
-          const id = str2(block.tool_use_id) ?? "";
+          const id = str3(block.tool_use_id) ?? "";
           const item = pendingTools.get(id);
           if (item) {
             const completed = completeItem(item, textFromToolResult(block), block.is_error === true);
@@ -8456,7 +9326,7 @@ async function* claudeToAgentEvents(messages) {
     if (message.type === "user") {
       for (const block of messageContent(p)) {
         if (block.type !== "tool_result") continue;
-        const id = str2(block.tool_use_id) ?? "";
+        const id = str3(block.tool_use_id) ?? "";
         const item = pendingTools.get(id);
         if (!item) {
           yield { type: "raw", raw: block };
@@ -8482,15 +9352,19 @@ var UnsettledExecution = class extends Error {
 var materializeImages = async (config, execution) => {
   const images = execution.message.payload.images ?? [];
   if (!images.length) return [];
-  const directory = join7(config.worktreePath, "attachments");
-  await mkdir2(directory, { recursive: true });
-  await writeFile2(join7(directory, ".gitignore"), "*\n");
+  const directory2 = join12(
+    config.runtimeDir,
+    "attachments",
+    `message-${execution.message.id}`,
+    "pasted"
+  );
+  await mkdir5(directory2, { recursive: true });
   return Promise.all(
     images.map(async (image, index) => {
       const match = /^data:image\/(png|jpeg|webp|gif);base64,([A-Za-z0-9+/=\r\n]+)$/.exec(image);
       if (!match) throw new Error("unsupported pasted image");
-      const path = `attachments/pasted-${execution.message.id}-${index + 1}.${match[1]}`;
-      await writeFile2(join7(config.worktreePath, path), Buffer.from(match[2] ?? "", "base64"));
+      const path = join12(directory2, `pasted-${index + 1}.${match[1]}`);
+      await writeFile3(path, Buffer.from(match[2] ?? "", "base64"));
       return path;
     })
   );
@@ -8498,7 +9372,12 @@ var materializeImages = async (config, execution) => {
 var buildPrompt = async (config, execution, fetchImpl) => {
   const { text: rawText, attachments = [] } = execution.message.payload;
   const paths = attachments.length ? await materializeAttachments({
-    worktreePath: config.worktreePath,
+    directory: join12(
+      config.runtimeDir,
+      "attachments",
+      `message-${execution.message.id}`,
+      "files"
+    ),
     serverBase: config.server,
     attachments,
     fetchImpl
@@ -8515,7 +9394,7 @@ var buildPrompt = async (config, execution, fetchImpl) => {
   ];
   const images = imagePaths.map((path) => ({
     type: "local_image",
-    path: join7(config.worktreePath, path)
+    path
   }));
   return { text, input: images.length ? [{ type: "text", text }, ...images] : text };
 };
@@ -8576,25 +9455,27 @@ var runTurn = async (config, worker2, execution, resuming, queryFn, log, envOver
     const built = await buildPrompt(config, execution, fetchImpl);
     if (abort.signal.aborted) throw new Error("interrupted before SDK start");
     const { planMode, model, effort } = execution.message.payload;
-    return config.agentKind === "codex" ? streamAgentEvents(
-      startCodexEvents(config, built.input, worker2, {
-        envOverlay,
-        planMode,
-        model,
-        effort,
-        signal: abort.signal,
-        log
-      }),
-      output
-    ) : streamClaudeSdkEvents(
-      startQuery(config, built.text, resuming, queryFn, abort, log, {
-        envOverlay,
-        planMode,
-        model,
-        effort
-      }),
-      output
-    );
+    const turn = { planMode, model, effort };
+    const run4 = {
+      "claude-code": () => streamClaudeSdkEvents(
+        startQuery(config, built.text, resuming, queryFn, abort, log, { envOverlay, ...turn }),
+        output
+      ),
+      codex: () => streamAgentEvents(
+        startCodexEvents(config, built.input, worker2, {
+          envOverlay,
+          ...turn,
+          signal: abort.signal,
+          log
+        }),
+        output
+      ),
+      pi: () => streamAgentEvents(
+        startPiEvents(config, built.input, { ...turn, signal: abort.signal, log }),
+        output
+      )
+    };
+    return run4[config.agentKind]();
   };
   const consuming = consume().then(
     (value) => ({ kind: "result", value }),
@@ -8618,7 +9499,7 @@ var runTurn = async (config, worker2, execution, resuming, queryFn, log, envOver
 };
 
 // src/session/runner.ts
-var isAgentConversationResumable = (config, transcriptPath = findTranscriptPath) => config.agentKind === "codex" ? !config.agentSessionId.startsWith("pending:") : transcriptPath(config.agentSessionId) !== null;
+var isAgentConversationResumable = (config, transcriptPath = findTranscriptPath) => config.agentKind === "claude-code" ? transcriptPath(config.agentSessionId) !== null : !config.agentSessionId.startsWith("pending:");
 var shouldReap = (lastActivity, now, busy, queueLen, idleMs) => !busy && queueLen === 0 && now - lastActivity >= idleMs;
 var runDaemon = async (config, deps, signal) => {
   const log = deps.log ?? console.log;
@@ -8632,12 +9513,12 @@ var runDaemon = async (config, deps, signal) => {
   let lastActivity = Date.now();
   let stop = () => {
   };
-  const stopped = new Promise((resolve3) => {
-    stop = resolve3;
+  const stopped = new Promise((resolve4) => {
+    stop = resolve4;
   });
   const drain = async () => {
     if (draining || closed || stranded) return;
-    const run2 = async () => {
+    const run4 = async () => {
       while (!closed && !stranded && !signal.aborted) {
         let claimed;
         try {
@@ -8680,7 +9561,7 @@ var runDaemon = async (config, deps, signal) => {
         }
       }
     };
-    draining = run2();
+    draining = run4();
     try {
       await draining;
     } finally {
@@ -8745,6 +9626,19 @@ var runDaemon = async (config, deps, signal) => {
   }
 };
 
+// src/worker/runtime-paths.ts
+import { createHash } from "node:crypto";
+import { homedir as homedir4 } from "node:os";
+import { join as join13 } from "node:path";
+var workerRuntimeDir = (owner, env = process.env) => join13(
+  env.XDG_DATA_HOME ?? join13(env.HOME ?? homedir4(), ".local/share"),
+  "baton",
+  "runtime",
+  createHash("sha256").update(owner.server).digest("hex"),
+  `worker-${owner.workerId}`
+);
+var sessionRuntimeDir = (owner, sessionId, env = process.env) => join13(workerRuntimeDir(owner, env), "sessions", String(sessionId));
+
 // src/commands/session/run.ts
 var bearerFetch = (token) => (input, init2) => fetch(input, {
   ...init2,
@@ -8774,13 +9668,13 @@ var sessionRunCommand = defineCommand({
   },
   run: async ({ args }) => {
     if (!process.connected) throw new Error("session runner requires supervisor IPC");
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       const onMessage = (message) => {
         if (typeof message !== "object" || message === null || !("type" in message) || message.type !== "execute")
           return;
         process.off("message", onMessage);
         process.off("disconnect", onDisconnect);
-        resolve3();
+        resolve4();
       };
       const onDisconnect = () => {
         process.off("message", onMessage);
@@ -8797,9 +9691,10 @@ var sessionRunCommand = defineCommand({
     const sessionId = Number(args.session);
     if (!Number.isInteger(sessionId) || sessionId <= 0)
       throw new Error(`invalid session id: ${args.session}`);
+    process.env.BATON_SESSION_ID = String(sessionId);
     const client = createClient(server, { bearer: workerToken });
     const s = await client.sessions.get(sessionId);
-    if (!s.agentSessionId || !s.worktreePath)
+    if (!s.agentSessionId || !s.cwd)
       throw new Error(`session #${sessionId} is not materialized yet`);
     const config = {
       server,
@@ -8807,7 +9702,8 @@ var sessionRunCommand = defineCommand({
       name: s.name,
       agentKind: s.agentKind,
       agentSessionId: s.agentSessionId,
-      worktreePath: s.worktreePath
+      cwd: s.cwd,
+      runtimeDir: sessionRuntimeDir({ server, workerId: s.workerId }, sessionId)
     };
     const worker2 = createWorkerClient(server, workerToken, sessionId);
     const ac = new AbortController();
@@ -9100,185 +9996,480 @@ var task = defineCommand({
 // src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
-// src/session/worktree.ts
-import { execFile, execFileSync, spawnSync } from "node:child_process";
+// src/worker/bundled-skills.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { cpSync, existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname3, join as join14 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/worker/git-exclude.ts
+import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { dirname, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
-import { promisify } from "node:util";
-var git = (repo, args) => spawnSync("git", ["-C", repo, ...args], {
-  stdio: "pipe",
-  encoding: "utf8"
-});
-var commandError = (result) => {
-  const raw = result.stderr || result.stdout || result.error?.message || `exit ${result.status}`;
-  return raw.trim().replace(/(https?:\/\/)[^/@\s]+@/g, "$1***@");
-};
-var execFileAsync = promisify(execFile);
-var DEFAULT_SYNC_TIMEOUT_MS = 6e4;
-var asyncCommandError = (error, timeoutMs) => {
-  const failure = error;
-  if (failure.killed || failure.code === "ETIMEDOUT") return `timed out after ${timeoutMs}ms`;
-  const raw = failure.stderr || failure.stdout || failure.message || String(error);
-  return raw.trim().replace(/(https?:\/\/)[^/@\s]+@/g, "$1***@");
-};
-var validateBaseBranch = (branch) => {
-  const normalized = branch.trim();
-  const valid = spawnSync("git", ["check-ref-format", "--branch", normalized], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  if (valid.status !== 0)
-    throw new Error(`invalid base branch "${normalized}": ${commandError(valid)}`);
-  return normalized;
-};
-var createWorktree = (input) => {
-  if (existsSync4(input.worktreePath))
-    throw new Error(`worktree path already exists: ${input.worktreePath}`);
-  const head = spawnSync("git", ["-C", input.repo, "rev-parse", "--verify", "-q", "HEAD"], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  if (head.status !== 0)
-    throw new Error(
-      `repo has no commits (unborn HEAD) \u2014 create an initial commit before starting sessions`
-    );
-  mkdirSync3(dirname(input.worktreePath), { recursive: true });
-  const branch = `baton/${input.sessionCode}`;
-  const r = spawnSync(
-    "git",
-    ["-C", input.repo, "worktree", "add", "-b", branch, input.worktreePath, input.base],
-    { stdio: "pipe", encoding: "utf8" }
-  );
-  if (r.status !== 0) {
-    throw new Error(`git worktree add failed: ${r.stderr || r.stdout || `exit ${r.status}`}`);
-  }
-};
-var repoHeadBranch = (repo) => {
-  const r = git(repo, ["symbolic-ref", "--short", "HEAD"]);
-  const branch = r.status === 0 ? r.stdout.trim() : "";
-  return branch || "main";
-};
-var syncBaseBranch = async (repo, branch, options = {}) => {
-  const checkedBranch = validateBaseBranch(branch);
-  const env = options.env ?? process.env;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS;
-  const origin = git(repo, ["remote", "get-url", "origin"]);
-  if (origin.status !== 0) {
-    const localRef = `refs/heads/${checkedBranch}`;
-    const verified2 = git(repo, ["rev-parse", "--verify", "-q", localRef]);
-    if (verified2.status !== 0) throw new Error(`local base branch does not exist: ${checkedBranch}`);
-    return localRef;
-  }
-  const helper = env.BATON_GIT_SYNC_BIN?.trim();
-  const command = helper ?? "git";
-  const args = helper ? [repo, checkedBranch] : [
-    "-C",
-    repo,
-    "fetch",
-    "--no-tags",
-    "origin",
-    `+refs/heads/${checkedBranch}:refs/remotes/origin/${checkedBranch}`
-  ];
-  let synced;
-  try {
-    synced = await execFileAsync(command, args, {
-      encoding: "utf8",
-      env: { ...env, GIT_TERMINAL_PROMPT: "0" },
-      timeout: timeoutMs
-    });
-  } catch (error) {
-    const via = helper ? ` via ${helper}` : "";
-    throw new Error(
-      `git sync failed for origin/${checkedBranch}${via}: ${asyncCommandError(error, timeoutMs)}`
-    );
-  }
-  const remoteRef = `refs/remotes/origin/${checkedBranch}`;
-  const verified = git(repo, ["rev-parse", "--verify", "-q", remoteRef]);
-  if (verified.status !== 0) throw new Error(`git sync succeeded but ${remoteRef} does not exist`);
-  if (helper) {
-    const reportedCommit = synced.stdout.trim();
-    const actualCommit = verified.stdout.trim();
-    if (!/^[0-9a-f]{40,64}$/i.test(reportedCommit))
-      throw new Error("git sync helper did not report the synced commit on stdout");
-    if (reportedCommit !== actualCommit)
-      throw new Error(`git sync helper reported a commit that does not match ${remoteRef}`);
-  }
-  return remoteRef;
-};
-var ensureExcluded = (repo, pattern) => {
-  try {
-    const r = spawnSync("git", ["-C", repo, "rev-parse", "--git-path", "info/exclude"], {
-      stdio: "pipe",
-      encoding: "utf8"
-    });
-    if (r.status !== 0) return;
-    const rel = r.stdout.trim();
-    const path = isAbsolute2(rel) ? rel : resolve2(repo, rel);
-    const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
-    if (current.split("\n").includes(pattern)) return;
-    mkdirSync3(dirname(path), { recursive: true });
-    const sep = current === "" || current.endsWith("\n") ? "" : "\n";
-    appendFileSync(path, `${sep}${pattern}
-`, "utf8");
-  } catch {
-  }
-};
-var removeWorktree = (repo, worktreePath) => {
-  if (!existsSync4(worktreePath)) return;
-  try {
-    execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktreePath], {
-      stdio: "pipe"
-    });
-  } catch {
-  }
-};
-var restoreWorktree = async (repo, worktreePath, sessionCode, baseBranch = repoHeadBranch(repo)) => {
-  spawnSync("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
-  mkdirSync3(dirname(worktreePath), { recursive: true });
-  const branch = `baton/${sessionCode}`;
-  const reuse = spawnSync("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  if (reuse.status === 0) return;
-  createWorktree({
-    repo,
-    worktreePath,
-    sessionCode,
-    base: await syncBaseBranch(repo, baseBranch)
+import { dirname as dirname2, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
+var ensureExcluded = (cwd, pattern) => {
+  const result = spawnSync("git", ["-C", cwd, "rev-parse", "--git-path", "info/exclude"], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C" }
   });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    if (result.stderr.includes("not a git repository")) return;
+    throw new Error(`cannot locate Git exclude file: ${result.stderr.trim()}`);
+  }
+  const location = result.stdout.trim();
+  const path = isAbsolute3(location) ? location : resolve3(cwd, location);
+  const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
+  if (current.split("\n").includes(pattern)) return;
+  mkdirSync3(dirname2(path), { recursive: true });
+  appendFileSync(path, `${current && !current.endsWith("\n") ? "\n" : ""}${pattern}
+`);
 };
 
 // src/worker/bundled-skills.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { cpSync, existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2, join as join8 } from "node:path";
-import { fileURLToPath } from "node:url";
 var SKILL_NAME = "baton-publish-artifact";
 var TARGETS = [`.claude/skills/${SKILL_NAME}`, `.agents/skills/${SKILL_NAME}`];
 var bundledSkillPath = () => {
-  const here = dirname2(fileURLToPath(import.meta.url));
+  const here = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
-    join8(here, "..", "skills", SKILL_NAME),
-    join8(here, "..", "..", "skills", SKILL_NAME)
+    join14(here, "..", "skills", SKILL_NAME),
+    join14(here, "..", "..", "skills", SKILL_NAME)
   ];
   const found = candidates.find(existsSync5);
   if (!found) throw new Error(`bundled skill missing: ${SKILL_NAME}`);
   return found;
 };
-var isTracked = (worktreePath, relativePath) => {
-  const result = spawnSync2("git", ["-C", worktreePath, "ls-files", "--", relativePath], {
+var isTracked = (cwd, relativePath) => {
+  const result = spawnSync2("git", ["-C", cwd, "ls-files", "--", relativePath], {
     encoding: "utf8",
     stdio: "pipe"
   });
   return result.status === 0 && result.stdout.trim().length > 0;
 };
-var syncBundledArtifactSkill = (repo, worktreePath) => {
+var syncBundledArtifactSkill = (cwd) => {
   const source = bundledSkillPath();
-  TARGETS.filter((target) => !isTracked(worktreePath, target)).forEach((target) => {
-    ensureExcluded(repo, `${target}/`);
-    cpSync(source, join8(worktreePath, target), { recursive: true, force: true });
+  TARGETS.filter((target) => !isTracked(cwd, target)).forEach((target) => {
+    ensureExcluded(cwd, `${target}/`);
+    cpSync(source, join14(cwd, target), { recursive: true, force: true });
+  });
+};
+
+// src/worker/files/branches.ts
+import { realpath as realpath2 } from "node:fs/promises";
+
+// src/worker/files/git.ts
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var run = promisify4(execFile4);
+var GIT_TIMEOUT_MS = 3e3;
+var runGit = async (cwd, args, maxBuffer = 4 * 1024 * 1024) => {
+  const { stdout } = await run("git", ["--literal-pathspecs", "-C", cwd, ...args], {
+    encoding: "buffer",
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer,
+    env: { ...process.env, LC_ALL: "C", GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" }
   });
+  return stdout;
+};
+
+// src/worker/files/branches.ts
+var NOT_A_WORK_TREE_EXIT = 128;
+var git = async (cwd, args) => (await runGit(cwd, args)).toString("utf8");
+var workTreeTop = async (dir) => {
+  try {
+    return await realpath2((await git(dir, ["rev-parse", "--show-toplevel"])).trim());
+  } catch (error) {
+    if (error.code !== NOT_A_WORK_TREE_EXIT)
+      console.warn("[files] git rev-parse failed; no branches to browse", error);
+    return null;
+  }
+};
+var parseWorktrees = (stdout) => stdout.split("\0\0").map((record) => record.split("\0").filter(Boolean)).flatMap((fields) => {
+  const path = fields.find((field) => field.startsWith("worktree "))?.slice("worktree ".length);
+  const ref = fields.find((field) => field.startsWith("branch "))?.slice("branch ".length);
+  const skipped = fields.some((field) => field === "bare" || field.startsWith("prunable"));
+  return path && ref && !skipped ? [{ path, name: ref.replace(/^refs\/heads\//, "") }] : [];
+});
+var parseTips = (stdout) => new Map(
+  stdout.split("\n").map((line) => line.split("\0")).flatMap(
+    ([ref, commit]) => ref && commit ? [[ref.replace(/^refs\/heads\//, ""), commit]] : []
+  )
+);
+var existingPath = async (path) => {
+  try {
+    return await realpath2(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      console.warn(`[files] cannot resolve worktree ${path}`, error);
+    return null;
+  }
+};
+var rank = (branch) => branch.current ? 0 : branch.worktree ? 1 : 2;
+var discoverBranches = async (baseDir) => {
+  const base = await realpath2(baseDir);
+  if (await workTreeTop(base) !== base) return [];
+  let worktrees;
+  let tips;
+  try {
+    const [listed, refs] = await Promise.all([
+      git(base, ["worktree", "list", "--porcelain", "-z"]),
+      git(base, ["for-each-ref", "--format=%(refname)%00%(objectname)", "refs/heads"])
+    ]);
+    worktrees = parseWorktrees(listed);
+    tips = parseTips(refs);
+  } catch (error) {
+    console.warn("[files] listing git branches failed; no branches to browse", error);
+    return [];
+  }
+  const checkedOut = new Map(
+    (await Promise.all(
+      worktrees.map(async ({ path, name }) => [name, await existingPath(path)])
+    )).filter((entry) => entry[1] !== null)
+  );
+  return [.../* @__PURE__ */ new Set([...checkedOut.keys(), ...tips.keys()])].map((name) => {
+    const worktree = checkedOut.get(name) ?? null;
+    return { name, worktree, commit: tips.get(name) ?? null, current: worktree === base };
+  }).sort((a, b) => rank(a) - rank(b) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+};
+
+// src/worker/files/common.ts
+var FileError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var notFound = (path) => new FileError("file_not_found", `not found: ${path}`);
+var checkedPath = (path, allowRoot) => {
+  const rel = normalizeFilePath(path, allowRoot);
+  if (rel === null) throw new FileError("invalid_request", `invalid path: ${path}`);
+  if (isSensitiveFilePath(rel)) throw new FileError("forbidden_path", `protected file: ${rel}`);
+  return rel;
+};
+var searchNeedle = (query3) => {
+  const trimmed = query3.trim();
+  if (trimmed === "" || trimmed.length > FILE_SEARCH_QUERY_MAX_LENGTH)
+    throw new FileError(
+      "invalid_request",
+      `search query must be 1-${FILE_SEARCH_QUERY_MAX_LENGTH} characters`
+    );
+  return trimmed.toLowerCase();
+};
+var byKindThenName = (a, b) => {
+  if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+};
+var decodeText = (bytes) => {
+  if (bytes.includes(0)) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch (error) {
+    if (error instanceof TypeError) return null;
+    throw error;
+  }
+};
+var hasBytes = (bytes, signature, offset = 0) => signature.every((byte, index) => bytes[offset + index] === byte);
+var hasText = (bytes, text, offset = 0) => bytes.subarray(offset, offset + text.length).toString("latin1") === text;
+var SVG_START = /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*)*(?:<!DOCTYPE[^>]*>\s*)?<svg[\s>]/i;
+var RAW_SIGNATURES = {
+  "image/png": (bytes) => hasBytes(bytes, [137, 80, 78, 71, 13, 10, 26, 10]),
+  "image/jpeg": (bytes) => hasBytes(bytes, [255, 216, 255]),
+  "image/gif": (bytes) => hasText(bytes, "GIF8"),
+  "image/webp": (bytes) => hasText(bytes, "RIFF") && hasText(bytes, "WEBP", 8),
+  "image/avif": (bytes) => hasText(bytes, "ftyp", 4) && bytes.subarray(8, 32).toString("latin1").includes("avif"),
+  "image/bmp": (bytes) => hasText(bytes, "BM"),
+  "image/x-icon": (bytes) => hasBytes(bytes, [0, 0, 1, 0]),
+  "image/svg+xml": (bytes) => {
+    const text = decodeText(bytes);
+    return text !== null && SVG_START.test(text.slice(0, 4096));
+  },
+  "text/css": (bytes) => decodeText(bytes) !== null,
+  "font/woff": (bytes) => hasText(bytes, "wOFF"),
+  "font/woff2": (bytes) => hasText(bytes, "wOF2"),
+  "font/ttf": (bytes) => hasBytes(bytes, [0, 1, 0, 0]) || hasText(bytes, "true"),
+  "font/otf": (bytes) => hasText(bytes, "OTTO")
+};
+var rawPayload = (path, mediaType, bytes) => {
+  if (!RAW_SIGNATURES[mediaType]?.(bytes))
+    throw new FileError("unsupported", `not a valid ${mediaType} file: ${path}`);
+  return { mediaType, base64: bytes.toString("base64") };
+};
+
+// src/worker/files/commit.ts
+var MISSING_OBJECT_EXIT = 128;
+var SEARCH_MAX_OUTPUT = 64 * 1024 * 1024;
+var REGULAR_FILE_MODES = /* @__PURE__ */ new Set(["100644", "100755"]);
+var parseTree = (stdout) => stdout.toString("utf8").split("\0").flatMap((record) => {
+  const tab = record.indexOf("	");
+  if (tab < 0) return [];
+  const [mode = "", type = "", oid = "", size = ""] = record.slice(0, tab).split(/ +/);
+  const bytes = /^\d+$/.test(size) ? Number(size) : null;
+  return [{ mode, type, oid, size: bytes, path: record.slice(tab + 1) }];
+});
+var isRegularFile = (entry) => entry.type === "blob" && REGULAR_FILE_MODES.has(entry.mode);
+var lsTree = async (repo, args) => {
+  try {
+    return parseTree(await runGit(repo, ["ls-tree", "-z", ...args]));
+  } catch (error) {
+    if (error.code === MISSING_OBJECT_EXIT) return null;
+    throw error;
+  }
+};
+var listCommitDirectory = async (repo, commit, path) => {
+  const rel = checkedPath(path, true);
+  const children = await lsTree(repo, [`${commit}:${rel}`]);
+  if (children === null) throw notFound(rel || ".");
+  const entries = children.flatMap((entry) => {
+    const child = rel ? `${rel}/${entry.path}` : entry.path;
+    if (isSensitiveFilePath(child)) return [];
+    if (entry.type === "tree")
+      return isExcludedDirectoryName(entry.path) ? [] : [{ name: entry.path, path: child, kind: "directory" }];
+    return isRegularFile(entry) ? [{ name: entry.path, path: child, kind: "file" }] : [];
+  }).sort(byKindThenName);
+  return {
+    path: rel,
+    entries: entries.slice(0, FILE_DIRECTORY_MAX_ENTRIES),
+    truncated: entries.length > FILE_DIRECTORY_MAX_ENTRIES
+  };
+};
+var searchCommit = async (repo, commit, query3) => {
+  const needle = searchNeedle(query3);
+  let stdout;
+  try {
+    stdout = await runGit(repo, ["ls-tree", "-r", "-z", commit], SEARCH_MAX_OUTPUT);
+  } catch (error) {
+    if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+      throw new FileError("unavailable", "the branch has too many files to search");
+    throw error;
+  }
+  const matches = parseTree(stdout).filter(
+    (entry) => isRegularFile(entry) && !entry.path.split("/").slice(0, -1).some(isExcludedDirectoryName) && !isSensitiveFilePath(entry.path) && entry.path.toLowerCase().includes(needle)
+  );
+  return {
+    entries: matches.slice(0, FILE_SEARCH_MAX_RESULTS).map((entry) => ({
+      name: entry.path.split("/").at(-1) ?? entry.path,
+      path: entry.path,
+      kind: "file"
+    })),
+    truncated: matches.length > FILE_SEARCH_MAX_RESULTS
+  };
+};
+var regularEntry = async (repo, commit, rel) => {
+  const entry = (await lsTree(repo, ["-l", commit, "--", rel]))?.find((item) => item.path === rel);
+  if (!entry || !isRegularFile(entry) || entry.size === null) throw notFound(rel);
+  return { oid: entry.oid, size: entry.size };
+};
+var viewCommitFile = async (repo, commit, path) => {
+  const rel = checkedPath(path, false);
+  const entry = await regularEntry(repo, commit, rel);
+  const meta = { path: rel, name: rel.split("/").at(-1) ?? rel, commit };
+  const mediaType = imageMediaType(rel);
+  if (mediaType)
+    return entry.size > FILE_RAW_MAX_BYTES ? { ...meta, size: entry.size, kind: "too_large", limit: FILE_RAW_MAX_BYTES } : { ...meta, size: entry.size, kind: "image", mediaType };
+  if (entry.size > FILE_TEXT_MAX_BYTES)
+    return { ...meta, size: entry.size, kind: "too_large", limit: FILE_TEXT_MAX_BYTES };
+  const bytes = await runGit(repo, ["cat-file", "blob", entry.oid], FILE_TEXT_MAX_BYTES + 1);
+  const content = decodeText(bytes);
+  return content === null ? { ...meta, size: bytes.length, kind: "binary" } : { ...meta, size: bytes.length, kind: "text", content };
+};
+var readRawCommitFile = async (repo, commit, path) => {
+  const rel = checkedPath(path, false);
+  const mediaType = rawMediaType(rel);
+  if (!mediaType) throw new FileError("unsupported", `not served raw: ${rel}`);
+  const entry = await regularEntry(repo, commit, rel);
+  if (entry.size > FILE_RAW_MAX_BYTES)
+    throw new FileError("unsupported", `too large to serve raw: ${rel}`);
+  const bytes = await runGit(repo, ["cat-file", "blob", entry.oid], FILE_RAW_MAX_BYTES + 1);
+  return rawPayload(rel, mediaType, bytes);
+};
+
+// src/worker/files/disk.ts
+import { constants as constants2 } from "node:fs";
+import { open as open2, readdir, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute4, join as join15, relative, sep } from "node:path";
+var isMissing = (error) => ["ENOENT", "ENOTDIR", "ELOOP"].includes(error.code ?? "");
+var childPath = (parent, name) => parent ? `${parent}/${name}` : name;
+var inside = (root, real) => {
+  const rel = relative(root, real);
+  if (isAbsolute4(rel) || rel === ".." || rel.startsWith(`..${sep}`)) return null;
+  return rel.split(sep).join("/");
+};
+var resolveInside = async (root, path, allowRoot) => {
+  const rel = checkedPath(path, allowRoot);
+  let real;
+  try {
+    real = await realpath3(join15(root, rel));
+  } catch (error) {
+    if (isMissing(error)) throw notFound(rel);
+    throw error;
+  }
+  const target = inside(root, real);
+  if (target === null || isSensitiveFilePath(target)) throw notFound(rel);
+  return { path: rel, real };
+};
+var symlinkEntry = async (root, linkPath, name, path) => {
+  let real;
+  try {
+    real = await realpath3(linkPath);
+  } catch (error) {
+    if (!isMissing(error)) console.warn(`[files] cannot resolve symlink ${linkPath}`, error);
+    return null;
+  }
+  const target = inside(root, real);
+  if (target === null || isSensitiveFilePath(target)) return null;
+  const info = await stat3(real);
+  if (info.isDirectory())
+    return isExcludedDirectoryName(name) ? null : { name, path, kind: "directory" };
+  return info.isFile() ? { name, path, kind: "file" } : null;
+};
+var toEntry = async (root, dir, dirent) => {
+  const path = childPath(dir.path, dirent.name);
+  if (isSensitiveFilePath(path)) return null;
+  if (dirent.isDirectory())
+    return isExcludedDirectoryName(dirent.name) ? null : { name: dirent.name, path, kind: "directory" };
+  if (dirent.isFile()) return { name: dirent.name, path, kind: "file" };
+  return dirent.isSymbolicLink() ? symlinkEntry(root, join15(dir.real, dirent.name), dirent.name, path) : null;
+};
+var listDirectory = async (root, path) => {
+  const dir = await resolveInside(root, path, true);
+  if (!(await stat3(dir.real)).isDirectory()) throw notFound(dir.path);
+  const dirents = await readdir(dir.real, { withFileTypes: true });
+  const entries = (await Promise.all(dirents.map((dirent) => toEntry(root, dir, dirent)))).filter((entry) => entry !== null).sort(byKindThenName);
+  return {
+    path: dir.path,
+    entries: entries.slice(0, FILE_DIRECTORY_MAX_ENTRIES),
+    truncated: entries.length > FILE_DIRECTORY_MAX_ENTRIES
+  };
+};
+var searchFiles = async (root, query3, now = Date.now) => {
+  const needle = searchNeedle(query3);
+  const deadline = now() + FILE_SEARCH_DEADLINE_MS;
+  const entries = [];
+  const pending = [""];
+  for (let index = 0; index < pending.length; index += 1) {
+    if (now() > deadline) return { entries, truncated: true };
+    const dir = pending[index] ?? "";
+    let dirents;
+    try {
+      dirents = await readdir(join15(root, dir), { withFileTypes: true });
+    } catch (error) {
+      console.warn(`[files] search skipped unreadable directory ${dir || "."}`, error);
+      continue;
+    }
+    for (const dirent of dirents) {
+      const path = childPath(dir, dirent.name);
+      if (isSensitiveFilePath(path)) continue;
+      if (dirent.isDirectory()) {
+        if (!isExcludedDirectoryName(dirent.name)) pending.push(path);
+      } else if (dirent.isFile() && path.toLowerCase().includes(needle)) {
+        if (entries.length === FILE_SEARCH_MAX_RESULTS) return { entries, truncated: true };
+        entries.push({ name: dirent.name, path, kind: "file" });
+      }
+    }
+  }
+  return { entries, truncated: false };
+};
+var readWithin = async (file, limit) => {
+  const info = await stat3(file.real);
+  if (!info.isFile()) throw notFound(file.path);
+  if (info.size > limit) return { oversize: info.size };
+  const handle = await open2(file.real, constants2.O_RDONLY | constants2.O_NONBLOCK);
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile()) throw notFound(file.path);
+    if (opened.size > limit) return { oversize: opened.size };
+    const bytes = await handle.readFile();
+    return bytes.length > limit ? { oversize: bytes.length } : { bytes };
+  } finally {
+    await handle.close();
+  }
+};
+var viewFile = async (root, path) => {
+  const file = await resolveInside(root, path, false);
+  const meta = { path: file.path, name: file.path.split("/").at(-1) ?? file.path, commit: null };
+  const mediaType = imageMediaType(file.path);
+  if (mediaType) {
+    const info = await stat3(file.real);
+    if (!info.isFile()) throw notFound(file.path);
+    return info.size > FILE_RAW_MAX_BYTES ? { ...meta, size: info.size, kind: "too_large", limit: FILE_RAW_MAX_BYTES } : { ...meta, size: info.size, kind: "image", mediaType };
+  }
+  const read = await readWithin(file, FILE_TEXT_MAX_BYTES);
+  if ("oversize" in read)
+    return { ...meta, size: read.oversize, kind: "too_large", limit: FILE_TEXT_MAX_BYTES };
+  const content = decodeText(read.bytes);
+  return content === null ? { ...meta, size: read.bytes.length, kind: "binary" } : { ...meta, size: read.bytes.length, kind: "text", content };
+};
+var readRawFile = async (root, path) => {
+  const file = await resolveInside(root, path, false);
+  const mediaType = rawMediaType(file.path);
+  if (!mediaType) throw new FileError("unsupported", `not served raw: ${file.path}`);
+  const read = await readWithin(file, FILE_RAW_MAX_BYTES);
+  if ("oversize" in read) throw new FileError("unsupported", `too large to serve raw: ${file.path}`);
+  return rawPayload(file.path, mediaType, read.bytes);
+};
+
+// src/worker/files/handler.ts
+var DEFAULT_CONCURRENCY = 4;
+var readerFor = (baseDir, branch) => {
+  const { worktree, commit } = branch;
+  if (worktree !== null)
+    return {
+      list: (path) => listDirectory(worktree, path),
+      search: (query3) => searchFiles(worktree, query3),
+      view: (path) => viewFile(worktree, path),
+      raw: (path) => readRawFile(worktree, path)
+    };
+  if (commit === null) throw new FileError("branch_not_found", `branch ${branch.name} is empty`);
+  return {
+    list: (path) => listCommitDirectory(baseDir, commit, path),
+    search: (query3) => searchCommit(baseDir, commit, query3),
+    view: (path) => viewCommitFile(baseDir, commit, path),
+    raw: (path) => readRawCommitFile(baseDir, commit, path)
+  };
+};
+var run2 = async (baseDir, query3) => {
+  const branches = await discoverBranches(baseDir);
+  if (query3.op === "branches") return { ok: true, data: branches };
+  const branch = branches.find((candidate) => candidate.name === query3.branch);
+  if (!branch) throw new FileError("branch_not_found", `branch ${query3.branch} does not exist`);
+  const reader = readerFor(baseDir, branch);
+  if (query3.op === "list") return { ok: true, data: await reader.list(query3.path) };
+  if (query3.op === "search") return { ok: true, data: await reader.search(query3.query) };
+  if (query3.op === "raw") return { ok: true, data: await reader.raw(query3.path) };
+  return { ok: true, data: await reader.view(query3.path) };
+};
+var handleFileQuery = async (baseDir, query3) => {
+  try {
+    return await run2(baseDir, query3);
+  } catch (error) {
+    if (error instanceof FileError) return { ok: false, code: error.code, message: error.message };
+    console.error(`[files] ${query3.op} query failed`, error);
+    return { ok: false, code: "unavailable", message: "the worker could not complete the read" };
+  }
+};
+var createFileQueryRunner = (baseDir, limit = DEFAULT_CONCURRENCY) => {
+  let active = 0;
+  const waiting = [];
+  const acquire = async () => {
+    if (active < limit) {
+      active += 1;
+      return;
+    }
+    await new Promise((resolve4) => waiting.push(resolve4));
+  };
+  const release = () => {
+    const next = waiting.shift();
+    if (next) next();
+    else active -= 1;
+  };
+  return async (query3) => {
+    await acquire();
+    try {
+      return await handleFileQuery(baseDir, query3);
+    } finally {
+      release();
+    }
+  };
 };
 
 // src/worker/watchdog.ts
@@ -9339,12 +10530,13 @@ var createLiveness = (deps) => {
 
 // src/worker/service-supervisor.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { stat as stat4 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 
 // src/worker/service-process.ts
 import { spawn as spawn2 } from "node:child_process";
 import { closeSync, existsSync as existsSync6, openSync } from "node:fs";
-import { dirname as dirname3, join as join9 } from "node:path";
+import { dirname as dirname4, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var START_TIMEOUT_MS = 1e4;
 var isWrapperMessage = (message) => {
@@ -9354,8 +10546,8 @@ var isWrapperMessage = (message) => {
   return value.type === "error" && typeof value.error === "string";
 };
 var binPath = () => {
-  const here = dirname3(fileURLToPath2(import.meta.url));
-  const devShim = join9(here, "..", "..", "bin", "baton.mjs");
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const devShim = join16(here, "..", "..", "bin", "baton.mjs");
   return existsSync6(devShim) ? devShim : fileURLToPath2(import.meta.url);
 };
 var startServiceProcess = (input) => {
@@ -9370,7 +10562,7 @@ var startServiceProcess = (input) => {
   } finally {
     closeSync(logFd);
   }
-  const started = new Promise((resolve3, reject) => {
+  const started = new Promise((resolve4, reject) => {
     let settled = false;
     let timer;
     const cleanup = () => {
@@ -9384,7 +10576,7 @@ var startServiceProcess = (input) => {
       settled = true;
       cleanup();
       if (result instanceof Error) reject(result);
-      else resolve3(result);
+      else resolve4(result);
     };
     const onMessage = (message) => {
       if (!isWrapperMessage(message)) return;
@@ -9409,13 +10601,13 @@ var startServiceProcess = (input) => {
 };
 
 // src/worker/service-supervisor.ts
-var waitForExit = (child) => child.exitCode !== null ? Promise.resolve() : new Promise((resolve3) => child.once("exit", () => resolve3()));
+var waitForExit = (child) => child.exitCode !== null ? Promise.resolve() : new Promise((resolve4) => child.once("exit", () => resolve4()));
 var createServiceSupervisor = (deps) => {
-  const { getSession, sendReport, cfg, log } = deps;
+  const { sendReport, cfg, log } = deps;
   const entries = /* @__PURE__ */ new Map();
   let reportQueue = Promise.resolve();
-  const snapshot = () => [...entries.values()].filter((entry) => entry.appPid !== void 0).map(({ sessionId, name, startedAt, publicUrl, note }) => ({
-    sessionId,
+  const snapshot = () => [...entries.values()].filter((entry) => entry.appPid !== void 0).map(({ cwd, name, startedAt, publicUrl, note }) => ({
+    cwd,
     name,
     startedAt,
     ...publicUrl ? { publicUrl } : {},
@@ -9425,15 +10617,13 @@ var createServiceSupervisor = (deps) => {
     const body = { services: snapshot(), ...result ? { result } : {} };
     const request2 = reportQueue.then(() => sendReport(body)).then(() => {
     });
-    reportQueue = request2.catch(() => {
-    });
+    reportQueue = request2.catch((error) => log(`service report failed: ${String(error)}`));
     return request2;
   };
   const remove = (entry) => {
     if (entries.get(entry.name) !== entry) return;
     entries.delete(entry.name);
-    void report().catch(() => {
-    });
+    void report().catch((error) => log(`service removal report failed: ${String(error)}`));
   };
   const stopEntry = (entry) => {
     if (entry.wrapper.connected) {
@@ -9442,7 +10632,18 @@ var createServiceSupervisor = (deps) => {
     }
     if (entry.appPid) killPidGroup(entry.appPid, "SIGKILL");
   };
-  const runOne = async (requestId, sessionId, name, argv, publicUrl, note) => {
+  const runOne = async (requestId, cwd, name, argv, publicUrl, note) => {
+    try {
+      if (!(await stat4(cwd)).isDirectory())
+        return report({ requestId, ok: false, error: `not a directory: ${cwd}`, status: 400 });
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+      return report({ requestId, ok: false, error: `directory not found: ${cwd}`, status: 400 });
+    }
+    const logDir = join17(workerRuntimeDir(cfg), "services");
+    const logPath = join17(logDir, `${name}.log`);
+    mkdirSync4(logDir, { recursive: true, mode: 448 });
     if (entries.has(name))
       return report({
         requestId,
@@ -9450,21 +10651,10 @@ var createServiceSupervisor = (deps) => {
         error: `service "${name}" is already running`,
         status: 409
       });
-    const session2 = await getSession(sessionId);
-    if (session2.workerId !== cfg.workerId || !session2.worktreePath)
-      return report({
-        requestId,
-        ok: false,
-        error: "session is not materialized on this worker",
-        status: 400
-      });
-    const logDir = join10(session2.worktreePath, ".baton-services");
-    const logPath = join10(logDir, `${name}.log`);
-    mkdirSync4(logDir, { recursive: true });
-    const { wrapper, started } = startServiceProcess({ argv, cwd: session2.worktreePath, logPath });
+    const { wrapper, started } = startServiceProcess({ argv, cwd, logPath });
     const entry = {
       wrapper,
-      sessionId,
+      cwd,
       name,
       startedAt: Date.now(),
       publicUrl,
@@ -9483,19 +10673,20 @@ var createServiceSupervisor = (deps) => {
     }
     const service2 = {
       workerId: cfg.workerId,
-      sessionId,
+      cwd,
       name,
       startedAt: entry.startedAt,
       ...publicUrl ? { publicUrl } : {},
       ...note ? { note } : {}
     };
-    log(`service ${name} started in ${session2.worktreePath}`);
+    log(`service ${name} started in ${cwd}`);
     await report({ requestId, ok: true, service: service2, logPath });
   };
-  const run2 = async (requestId, sessionId, name, argv, publicUrl, note) => {
+  const run4 = async (requestId, cwd, name, argv, publicUrl, note) => {
     try {
-      await runOne(requestId, sessionId, name, argv, publicUrl, note);
+      await runOne(requestId, cwd, name, argv, publicUrl, note);
     } catch (error) {
+      log(`service ${name} failed: ${String(error)}`);
       await report({ requestId, ok: false, error: String(error), status: 500 });
     }
   };
@@ -9508,21 +10699,16 @@ var createServiceSupervisor = (deps) => {
     remove(entry);
     await report({ requestId, ok: true });
   };
-  const stopSession = async (sessionId) => {
-    const matches = [...entries.values()].filter((entry) => entry.sessionId === sessionId);
-    matches.forEach(stopEntry);
-    await Promise.all(matches.map((entry) => waitForExit(entry.wrapper)));
-    matches.forEach(remove);
-  };
   const killAll = () => entries.forEach(stopEntry);
-  return { run: run2, stop, stopSession, report, killAll };
+  return { run: run4, stop, report, killAll };
 };
 
 // src/worker/session-supervisor.ts
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname4, join as join13 } from "node:path";
+import { mkdir as mkdir6, rm as rm3, stat as stat5 } from "node:fs/promises";
+import { dirname as dirname5, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -9559,7 +10745,7 @@ var buildTitlePrompt = (userText, assistantText) => {
   ].join("\n");
 };
 var generateTitle = async (input) => {
-  const { worktreePath, userText, assistantText, queryFn } = input;
+  const { cwd, userText, assistantText, queryFn } = input;
   if (`${userText}${assistantText}`.trim().length < 4) return { kind: "declined" };
   const exe = claudeExecutable();
   const abort = new AbortController();
@@ -9572,7 +10758,7 @@ var generateTitle = async (input) => {
     const messages = queryFn({
       prompt: buildTitlePrompt(userText, assistantText),
       options: {
-        cwd: worktreePath,
+        cwd,
         // A one-shot summarizer, not an agent: replace the ~18k-token Claude
         // Code preset system prompt. Inside the agent harness the model
         // routinely answers NONE to this ask (verified against reclaude);
@@ -9616,7 +10802,7 @@ var generateTitle = async (input) => {
 // src/session/runner/title-codex.ts
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join18 } from "node:path";
 import { Codex as Codex2 } from "@openai/codex-sdk";
 var generateTitleWithCodex = async (input) => {
   const { userText, assistantText } = input;
@@ -9625,7 +10811,7 @@ var generateTitleWithCodex = async (input) => {
   const timer = setTimeout(() => abort.abort(), TITLE_TIMEOUT_MS);
   let cwd = "";
   try {
-    cwd = await mkdtemp(join11(tmpdir3(), "baton-title-"));
+    cwd = await mkdtemp(join18(tmpdir3(), "baton-title-"));
     const client = input.client ?? new Codex2();
     const thread = client.startThread({
       workingDirectory: cwd,
@@ -9651,19 +10837,79 @@ var generateTitleWithCodex = async (input) => {
   }
 };
 
+// src/session/runner/title-pi.ts
+import { mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join19 } from "node:path";
+var generateTitleWithPi = async (input) => {
+  const { userText, assistantText } = input;
+  if (`${userText}${assistantText}`.trim().length < 4) return { kind: "declined" };
+  let cwd = "";
+  let timedOut = false;
+  let timer;
+  try {
+    cwd = await mkdtemp2(join19(tmpdir4(), "baton-title-"));
+    const pi = await import("@earendil-works/pi-coding-agent");
+    const agentDir = pi.getAgentDir();
+    const resourceLoader = new pi.DefaultResourceLoader({
+      cwd,
+      agentDir,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      systemPrompt: "You title chat sessions."
+    });
+    await resourceLoader.reload();
+    const { session: session2 } = await pi.createAgentSession({
+      cwd,
+      agentDir,
+      resourceLoader,
+      sessionManager: pi.SessionManager.inMemory(cwd),
+      noTools: "all"
+    });
+    let error;
+    session2.subscribe((event) => {
+      if (event.type === "message_end" && event.message.role === "assistant")
+        error = event.message.stopReason === "error" ? event.message.errorMessage : void 0;
+    });
+    timer = setTimeout(() => {
+      timedOut = true;
+      void session2.abort().catch((e) => console.error(`[title] pi abort: ${String(e)}`));
+    }, TITLE_TIMEOUT_MS);
+    try {
+      await session2.prompt(buildTitlePrompt(userText, assistantText));
+      if (timedOut) return { kind: "error", reason: `timeout after ${TITLE_TIMEOUT_MS / 1e3}s` };
+      if (error) return { kind: "error", reason: error.slice(0, 300) };
+      return titleOutcome(session2.getLastAssistantText() ?? "");
+    } finally {
+      session2.dispose();
+    }
+  } catch (error) {
+    return { kind: "error", reason: String(error).slice(0, 300) };
+  } finally {
+    clearTimeout(timer);
+    if (cwd)
+      await rm2(cwd, { recursive: true, force: true }).catch(
+        (e) => console.error(`[title] cleanup ${cwd}: ${String(e)}`)
+      );
+  }
+};
+
 // src/worker/session-process.ts
-import { execFile as execFile2 } from "node:child_process";
-import { readFile, rename, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var run = promisify2(execFile2);
+import { execFile as execFile5 } from "node:child_process";
+import { readFile as readFile3, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+var run3 = promisify5(execFile5);
 var RUNNER_RECORD = ".baton-runner.json";
-var recordPath = (worktreePath) => join12(worktreePath, RUNNER_RECORD);
+var recordPath = (cwd) => join20(cwd, RUNNER_RECORD);
 var codeOf = (error) => typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-var readRunnerRecord = async (worktreePath) => {
+var readRunnerRecord = async (cwd) => {
   let raw;
   try {
-    raw = await readFile(recordPath(worktreePath), "utf8");
+    raw = await readFile3(recordPath(cwd), "utf8");
   } catch (error) {
     if (codeOf(error) === "ENOENT") return null;
     throw error;
@@ -9673,10 +10919,10 @@ var readRunnerRecord = async (worktreePath) => {
     throw new Error("invalid session process record");
   return value;
 };
-var writeRunnerRecord = async (worktreePath, record) => {
-  const path = recordPath(worktreePath);
+var writeRunnerRecord = async (cwd, record) => {
+  const path = recordPath(cwd);
   const temporary = `${path}.${record.runnerToken}.tmp`;
-  await writeFile3(temporary, JSON.stringify(record), { mode: 384, flag: "wx" });
+  await writeFile4(temporary, JSON.stringify(record), { mode: 384, flag: "wx" });
   await rename(temporary, path);
 };
 var groupExists = (pgid) => {
@@ -9701,7 +10947,7 @@ var stopRecordedRunner = async (record, expected, graceMs = 5e3) => {
   if (!groupExists(record.pgid)) return;
   let stdout;
   try {
-    const result = await run("ps", ["-ww", "-p", String(record.pid), "-o", "pgid=", "-o", "args="]);
+    const result = await run3("ps", ["-ww", "-p", String(record.pid), "-o", "pgid=", "-o", "args="]);
     stdout = result.stdout;
   } catch (error) {
     if (!groupExists(record.pgid)) return;
@@ -9714,37 +10960,23 @@ var stopRecordedRunner = async (record, expected, graceMs = 5e3) => {
   signalGroup(record.pgid, "SIGTERM");
   const deadline = Date.now() + graceMs;
   while (groupExists(record.pgid) && Date.now() < deadline)
-    await new Promise((resolve3) => setTimeout(resolve3, 50));
+    await new Promise((resolve4) => setTimeout(resolve4, 50));
   if (!groupExists(record.pgid)) return;
   signalGroup(record.pgid, "SIGKILL");
   const killDeadline = Date.now() + graceMs;
   while (groupExists(record.pgid) && Date.now() < killDeadline)
-    await new Promise((resolve3) => setTimeout(resolve3, 50));
+    await new Promise((resolve4) => setTimeout(resolve4, 50));
   if (groupExists(record.pgid)) throw new Error("session process group has not exited");
 };
 
 // src/worker/session-supervisor.ts
 var binPath2 = () => {
-  const here = dirname4(fileURLToPath3(import.meta.url));
-  const devShim = join13(here, "..", "..", "bin", "baton.mjs");
+  const here = dirname5(fileURLToPath3(import.meta.url));
+  const devShim = join21(here, "..", "..", "bin", "baton.mjs");
   return existsSync7(devShim) ? devShim : fileURLToPath3(import.meta.url);
 };
 var createSessionSupervisor = (deps) => {
-  const { client, cfg, repo, log, hasTerminal, closeTerminal } = deps;
-  const worktreeDir = defaultWorktreeDir();
-  const baseBranch = cfg.baseBranch ?? repoHeadBranch(repo);
-  const syncBase = deps.syncBase ?? syncBaseBranch;
-  let syncInFlight = null;
-  const syncedBase = () => {
-    if (syncInFlight) return syncInFlight;
-    const pending = syncBase(repo, baseBranch);
-    syncInFlight = pending;
-    const clear = () => {
-      if (syncInFlight === pending) syncInFlight = null;
-    };
-    void pending.then(clear, clear);
-    return pending;
-  };
+  const { client, cfg, cwd, log, hasTerminal, closeTerminal } = deps;
   const children = /* @__PURE__ */ new Map();
   const lifecycle = /* @__PURE__ */ new Map();
   const enqueue = (id, action) => {
@@ -9763,8 +10995,8 @@ var createSessionSupervisor = (deps) => {
   const cancelStart = (sessionId) => {
     startEpochs.set(sessionId, currentStartEpoch(sessionId) + 1);
   };
-  const stopRecord = async (sessionId, worktreePath, token) => {
-    const record = await readRunnerRecord(worktreePath);
+  const stopRecord = async (sessionId, token) => {
+    const record = await readRunnerRecord(sessionRuntimeDir(cfg, sessionId));
     if (!record) {
       if (token) throw new Error("missing record for an unfinished execution");
       return;
@@ -9773,9 +11005,9 @@ var createSessionSupervisor = (deps) => {
       throw new Error("runner identity does not match the attempt");
     await stopRecordedRunner(record, { server: cfg.server, workerId: cfg.workerId, sessionId });
   };
-  const spawnChild = async (sessionId, worktreePath, wasCanceled) => {
+  const spawnChild = async (sessionId, cwd2, wasCanceled) => {
     if (children.has(sessionId)) return;
-    await stopRecord(sessionId, worktreePath);
+    await stopRecord(sessionId);
     const runnerToken = randomUUID2();
     const child = spawn3(
       process.execPath,
@@ -9783,16 +11015,17 @@ var createSessionSupervisor = (deps) => {
       {
         detached: true,
         stdio: ["inherit", "inherit", "inherit", "ipc"],
-        env: { ...process.env, BATON_SERVER: cfg.server, BATON_WORKER_TOKEN: cfg.apiToken }
+        cwd: cwd2,
+        env: workerEnv(cfg)
       }
     );
-    const entry = { child, worktreePath };
+    const entry = { child };
     children.set(sessionId, entry);
     let readyTimer;
-    const ready = new Promise((resolve3, reject) => {
+    const ready = new Promise((resolve4, reject) => {
       child.on("message", (message) => {
         if (typeof message === "object" && message !== null && "type" in message && message.type === "ready")
-          resolve3();
+          resolve4();
       });
       child.once("error", reject);
       child.once("exit", () => reject(new Error("session child exited before ready")));
@@ -9812,8 +11045,8 @@ var createSessionSupervisor = (deps) => {
         void stop(sessionId).catch((error) => log(`stuck execution cleanup failed: ${String(error)}`));
     });
     try {
-      await new Promise((resolve3, reject) => {
-        child.once("spawn", resolve3);
+      await new Promise((resolve4, reject) => {
+        child.once("spawn", resolve4);
         child.once("error", reject);
       });
       if (!child.pid) throw new Error("session child has no PID");
@@ -9825,11 +11058,11 @@ var createSessionSupervisor = (deps) => {
         pid: child.pid,
         pgid: child.pid
       };
-      await writeRunnerRecord(worktreePath, record);
+      await writeRunnerRecord(sessionRuntimeDir(cfg, sessionId), record);
       await readiness;
       if (wasCanceled()) return;
       await new Promise(
-        (resolve3, reject) => child.send({ type: "execute" }, (error) => error ? reject(error) : resolve3())
+        (resolve4, reject) => child.send({ type: "execute" }, (error) => error ? reject(error) : resolve4())
       );
     } catch (error) {
       killProcessGroup(child);
@@ -9847,37 +11080,20 @@ var createSessionSupervisor = (deps) => {
     if (execution.paused || execution.contextResetRequested || execution.attempt?.status === "running" || execution.attempt?.status === "stopping")
       return;
     if (wasCanceled()) return log(`session #${sessionId} start canceled before materializing`);
-    let worktreePath = session2.worktreePath;
-    if (!session2.agentSessionId || !worktreePath) {
-      const sessionCode = randomUUID2();
-      const agentSessionId = session2.agentKind === "codex" ? `pending:${sessionCode}` : sessionCode;
-      worktreePath = join13(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
-      const base = await syncedBase();
-      if (wasCanceled()) return log(`session #${sessionId} start canceled during git sync`);
-      createWorktree({
-        repo,
-        worktreePath,
-        sessionCode: sessionCode.slice(0, 8),
-        base
-      });
-      await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
-      if (wasCanceled()) return log(`session #${sessionId} start canceled after materializing`);
-      log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
-    } else if (!existsSync7(worktreePath)) {
-      await restoreWorktree(repo, worktreePath, session2.agentSessionId.slice(0, 8), baseBranch);
-      if (wasCanceled()) return log(`session #${sessionId} start canceled during worktree restore`);
-      log(`recreated session #${sessionId} worktree (was missing) \u2192 ${worktreePath}`);
-    }
-    ensureExcluded(repo, PROJECT_CONFIG_NAME);
-    ensureExcluded(repo, ".baton-services/");
-    ensureExcluded(repo, RUNNER_RECORD);
-    ensureExcluded(repo, ".baton-runner.json.*.tmp");
-    saveProjectConfig(join13(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg, sessionId));
-    syncBundledArtifactSkill(repo, worktreePath);
+    const directory2 = session2.cwd ?? cwd;
+    if (!(await stat5(directory2)).isDirectory()) throw new Error(`not a directory: ${directory2}`);
+    if (wasCanceled()) return;
+    if (!session2.agentSessionId || !session2.cwd) {
+      const id = randomUUID2();
+      const agentSessionId = session2.agentKind === "codex" ? `pending:${id}` : id;
+      await client.sessions.materialize(sessionId, { agentSessionId, cwd: directory2 }, cfg.apiToken);
+      log(`materialized session #${sessionId} (${name}) \u2192 ${directory2}`);
+    }
+    await mkdir6(sessionRuntimeDir(cfg, sessionId), { recursive: true, mode: 448 });
     if (hasTerminal(sessionId))
       return log(`session #${sessionId} terminal opened mid-start \u2014 skipping headless start`);
     if (wasCanceled()) return;
-    await spawnChild(sessionId, worktreePath, wasCanceled);
+    await spawnChild(sessionId, directory2, wasCanceled);
   };
   const start = (sessionId, name) => {
     const epoch = currentStartEpoch(sessionId);
@@ -9895,38 +11111,31 @@ var createSessionSupervisor = (deps) => {
     cancelStart(sessionId);
     return enqueue(sessionId, async () => {
       const entry = children.get(sessionId);
-      const session2 = await client.sessions.get(sessionId);
-      if (session2.worktreePath) await stopRecord(sessionId, session2.worktreePath);
+      await stopRecord(sessionId);
       if (entry && children.get(sessionId) === entry) children.delete(sessionId);
     });
   };
-  const remove = (sessionId, worktreePath) => {
+  const remove = (sessionId) => {
     cancelStart(sessionId);
     closeTerminal(sessionId);
     return enqueue(sessionId, async () => {
       const entry = children.get(sessionId);
-      const path = entry?.worktreePath ?? worktreePath;
-      if (path) {
-        await stopRecord(sessionId, path);
-        removeWorktree(repo, path);
-      }
+      await stopRecord(sessionId);
+      await rm3(sessionRuntimeDir(cfg, sessionId), { recursive: true, force: true });
       if (children.get(sessionId) === entry) children.delete(sessionId);
     });
   };
-  const title = async (sessionId, agentSessionId, worktreePath) => {
+  const title = async (sessionId, agentSessionId, cwd2) => {
     const session2 = await client.sessions.get(sessionId);
     const events = await client.sessions.listEvents(sessionId);
     const exchange = parseFirstExchangeFromEvents(events) ?? (session2.agentKind === "claude-code" ? readFirstExchange(agentSessionId) : null);
     if (!exchange) return log(`title #${sessionId}: no transcript yet, skipping`);
-    const outcome = session2.agentKind === "codex" ? await generateTitleWithCodex({
-      userText: exchange.userText,
-      assistantText: exchange.assistantText
-    }) : await generateTitle({
-      worktreePath,
-      userText: exchange.userText,
-      assistantText: exchange.assistantText,
-      queryFn: query2
-    });
+    const titlers = {
+      "claude-code": (e) => generateTitle({ cwd: cwd2, ...e, queryFn: query2 }),
+      codex: generateTitleWithCodex,
+      pi: generateTitleWithPi
+    };
+    const outcome = await titlers[session2.agentKind](exchange);
     if (outcome.kind === "error") return log(`title #${sessionId} failed: ${outcome.reason}`);
     if (outcome.kind === "declined")
       return log(`title #${sessionId}: not enough to title yet, skipping`);
@@ -9942,10 +11151,10 @@ var createSessionSupervisor = (deps) => {
         const session2 = await client.sessions.get(candidate.id);
         let execution = await client.sessions.execution(session2.id);
         if (execution.attempt?.status === "stopping") {
-          if (!session2.worktreePath) throw new Error("unfinished execution without worktree");
+          if (!session2.cwd) throw new Error("unfinished execution without cwd");
           if (children.has(session2.id) && Date.now() - (execution.attempt.stopRequestedAt ?? 0) < 1e4)
             return;
-          await stopRecord(session2.id, session2.worktreePath, execution.attempt.runnerToken);
+          await stopRecord(session2.id, execution.attempt.runnerToken);
           children.delete(session2.id);
           await client.sessions.stopped(
             session2.id,
@@ -9955,12 +11164,12 @@ var createSessionSupervisor = (deps) => {
           execution = await client.sessions.execution(session2.id);
         }
         if (execution.paused) {
-          if (session2.worktreePath) await stopRecord(session2.id, session2.worktreePath);
+          if (session2.cwd) await stopRecord(session2.id);
           return;
         }
         if (execution.attempt?.status === "running") {
-          if (!children.has(session2.id) && session2.worktreePath)
-            await stopRecord(session2.id, session2.worktreePath, execution.attempt.runnerToken);
+          if (!children.has(session2.id) && session2.cwd)
+            await stopRecord(session2.id, execution.attempt.runnerToken);
           return;
         }
         if (execution.pendingCount || execution.turn?.status === "recovering")
@@ -9971,7 +11180,7 @@ var createSessionSupervisor = (deps) => {
       for (const [id, entry] of children) {
         if (!live.has(id))
           await enqueue(id, async () => {
-            await stopRecord(id, entry.worktreePath);
+            await stopRecord(id);
             if (children.get(id) === entry) children.delete(id);
           });
       }
@@ -9991,7 +11200,7 @@ var createSessionSupervisor = (deps) => {
 };
 
 // src/worker/terminal-manager.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { statSync as statSync2 } from "node:fs";
 import { spawn as spawn4 } from "node-pty";
 
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
@@ -10007,8 +11216,9 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 // src/worker/pty.ts
 import { existsSync as existsSync8, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire as createModuleRequire } from "node:module";
-import { homedir as homedir3 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname6, join as join22 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MAX_TERMINALS = 10;
 var claudePtyCommand = (agentSessionId, hasJsonl, env = process.env) => ({
   file: env.BATON_CLAUDE_BIN?.trim() || "claude",
@@ -10023,39 +11233,45 @@ var codexPtyCommand = (agentSessionId, env = process.env) => {
     args: [moduleRequire.resolve("@openai/codex/bin/codex.js"), ...args]
   };
 };
+var piPtyCommand = (agentSessionId, env = process.env) => {
+  const args = ["--session-id", agentSessionId];
+  const override = env.BATON_PI_BIN?.trim();
+  if (override) return { file: override, args };
+  const entry = fileURLToPath4(import.meta.resolve("@earendil-works/pi-coding-agent"));
+  return { file: process.execPath, args: [join22(dirname6(entry), "bundle", "cli.js"), ...args] };
+};
 var hasSessionJsonl = (agentSessionId) => {
-  const root = join14(homedir3(), ".claude", "projects");
+  const root = join22(homedir5(), ".claude", "projects");
   if (!existsSync8(root)) return false;
   for (const dir of readdirSync2(root))
-    if (existsSync8(join14(root, dir, `${agentSessionId}.jsonl`))) return true;
+    if (existsSync8(join22(root, dir, `${agentSessionId}.jsonl`))) return true;
   return false;
 };
+var ptyCommand = (kind, agentSessionId) => ({
+  "claude-code": () => claudePtyCommand(agentSessionId, hasSessionJsonl(agentSessionId)),
+  codex: () => codexPtyCommand(agentSessionId),
+  pi: () => piPtyCommand(agentSessionId)
+})[kind]();
 var serverTerminalWsUrl = (server, sessionId) => `${server.replace(/^http/, "ws")}/workers/me/terminal/ws?sessionId=${sessionId}`;
 var isPositiveDim = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 
 // src/worker/terminal-manager.ts
 var createTerminalManager = (deps) => {
-  const { cfg, log, hasChild, prepareWorktree } = deps;
+  const { cfg, log, hasChild } = deps;
   const terminals = /* @__PURE__ */ new Map();
-  const open = (sessionId, agentSessionId, worktreePath) => {
-    const why = terminals.has(sessionId) ? "already open" : hasChild(sessionId) ? "headless child running" : !existsSync9(worktreePath) ? `worktree missing (${worktreePath})` : terminals.size >= MAX_TERMINALS ? `cap ${MAX_TERMINALS} reached` : null;
+  const open3 = (sessionId, agentSessionId, cwd) => {
+    const why = terminals.has(sessionId) ? "already open" : hasChild(sessionId) ? "headless child running" : !statSync2(cwd, { throwIfNoEntry: false })?.isDirectory() ? `directory missing (${cwd})` : terminals.size >= MAX_TERMINALS ? `cap ${MAX_TERMINALS} reached` : null;
     if (why) {
       log(`terminal #${sessionId}: ${why} \u2014 refusing`);
       return;
     }
-    try {
-      prepareWorktree(worktreePath);
-    } catch (error) {
-      log(`terminal #${sessionId}: worktree preparation failed: ${String(error)}`);
-      return;
-    }
-    const command = cfg.agentKind === "codex" ? codexPtyCommand(agentSessionId) : claudePtyCommand(agentSessionId, hasSessionJsonl(agentSessionId));
+    const command = ptyCommand(cfg.agentKind, agentSessionId);
     const term = spawn4(command.file, command.args, {
       name: "xterm-color",
       cols: 80,
       rows: 24,
-      cwd: worktreePath,
-      env: process.env
+      cwd,
+      env: workerEnv(cfg)
     });
     const ws = new import_websocket.default(serverTerminalWsUrl(cfg.server, sessionId), {
       headers: { authorization: `Bearer ${cfg.apiToken}` }
@@ -10101,7 +11317,7 @@ var createTerminalManager = (deps) => {
     }
   };
   return {
-    open,
+    open: open3,
     close,
     has: (sessionId) => terminals.has(sessionId),
     killAll: () => {
@@ -10122,12 +11338,14 @@ var createTerminalManager = (deps) => {
 // src/worker/daemon.ts
 var ES_OPEN = 1;
 var runWorkerDaemon = async (cfg, client, signal) => {
-  const repo = process.cwd();
+  const cwd = process.cwd();
+  ensureExcluded(cwd, PROJECT_CONFIG_NAME);
+  syncBundledArtifactSkill(cwd);
   const log = (m) => console.log(`[worker #${cfg.workerId} ${cfg.name}] ${m}`);
   const supervisor = createSessionSupervisor({
     client,
     cfg,
-    repo,
+    cwd,
     log,
     hasTerminal: (id) => terminals.has(id),
     closeTerminal: (id) => terminals.close(id)
@@ -10135,11 +11353,10 @@ var runWorkerDaemon = async (cfg, client, signal) => {
   const terminals = createTerminalManager({
     cfg,
     log,
-    hasChild: (id) => supervisor.has(id),
-    prepareWorktree: (worktreePath) => syncBundledArtifactSkill(repo, worktreePath)
+    hasChild: (id) => supervisor.has(id)
   });
+  const files = createFileQueryRunner(cwd);
   const services = createServiceSupervisor({
-    getSession: (sessionId) => client.sessions.get(sessionId),
     sendReport: (report) => client.services.report(report),
     cfg,
     log
@@ -10184,28 +11401,29 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       else if (cmd.cmd === "session.reconcile")
         void supervisor.reconcile(cmd.sessionId).catch((error) => log(`reconcile failed: ${String(error)}`));
       else if (cmd.cmd === "session.delete")
-        void services.stopSession(cmd.sessionId).then(() => supervisor.remove(cmd.sessionId, cmd.worktreePath)).catch((err) => log(`service cleanup failed: ${String(err)}`));
+        void supervisor.remove(cmd.sessionId).catch((err) => log(`session cleanup failed: ${String(err)}`));
       else if (cmd.cmd === "session.title")
-        void supervisor.title(cmd.sessionId, cmd.agentSessionId, cmd.worktreePath).catch((err) => log(`title failed: ${String(err)}`));
+        void supervisor.title(cmd.sessionId, cmd.agentSessionId, cmd.cwd).catch((err) => log(`title failed: ${String(err)}`));
       else if (cmd.cmd === "session.terminal") {
-        if (cmd.action === "open")
-          terminals.open(cmd.sessionId, cmd.agentSessionId, cmd.worktreePath);
+        if (cmd.action === "open") terminals.open(cmd.sessionId, cmd.agentSessionId, cmd.cwd);
         else terminals.close(cmd.sessionId);
       } else if (cmd.cmd === "service.run")
-        void services.run(cmd.requestId, cmd.sessionId, cmd.name, cmd.argv, cmd.publicUrl, cmd.note).catch((err) => log(`service run failed: ${String(err)}`));
+        void services.run(cmd.requestId, cmd.cwd, cmd.name, cmd.argv, cmd.publicUrl, cmd.note).catch((err) => log(`service run failed: ${String(err)}`));
       else if (cmd.cmd === "service.stop")
         void services.stop(cmd.requestId, cmd.name).catch((err) => log(`service stop failed: ${String(err)}`));
+      else if (cmd.cmd === "files.query")
+        void files(cmd.query).then((reply) => client.files.report({ requestId: cmd.requestId, ...reply })).catch((err) => log(`files query failed: ${String(err)}`));
     } catch (error) {
       log(`invalid command: ${String(error)}`);
     }
   };
   es.onerror = () => log("command stream error (eventsource will retry)");
-  log(`listening for commands (server ${cfg.server}, repo ${repo})`);
+  log(`listening for commands (server ${cfg.server}, cwd ${cwd})`);
   liveness.start();
-  await new Promise((resolve3) => {
-    stop = resolve3;
-    if (signal.aborted) return resolve3();
-    signal.addEventListener("abort", () => resolve3(), { once: true });
+  await new Promise((resolve4) => {
+    stop = resolve4;
+    if (signal.aborted) return resolve4();
+    signal.addEventListener("abort", () => resolve4(), { once: true });
   });
   es.close();
   liveness.stop();
@@ -10217,22 +11435,93 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 
 // src/worker/machine-id.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join15 } from "node:path";
-var machineIdPath = (env = process.env) => join15(env.XDG_DATA_HOME ?? join15(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname7, join as join23 } from "node:path";
+var machineIdPath = (env = process.env) => join23(env.XDG_DATA_HOME ?? join23(env.HOME ?? homedir6(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
-  if (existsSync10(path)) {
+  if (existsSync9(path)) {
     const s = readFileSync6(path, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID3();
-  mkdirSync5(dirname5(path), { recursive: true });
+  mkdirSync5(dirname7(path), { recursive: true });
   writeFileSync5(path, `${id}
 `, "utf8");
   return id;
 };
 
+// src/commands/worker/provision.ts
+var projectArg = {
+  project: { type: "string", description: "project id (overrides .baton.json)" }
+};
+var positiveId = (raw) => {
+  const id = Number(raw);
+  if (!Number.isSafeInteger(id) || id <= 0) throw new Error("positive id required");
+  return id;
+};
+var workerTemplatesCommand = defineCommand({
+  meta: { name: "templates", description: "list worker creation templates for a project" },
+  args: { ...projectArg, ...common },
+  run: async ({ args }) => {
+    const list = await clientFor(args).workerCreations.templates(positiveId(resolveProjectId(args)));
+    console.log(renderList(list, fmtWorkerTemplate, Boolean(args.json)));
+  }
+});
+var workerCreateCommand = defineCommand({
+  meta: { name: "create", description: "request a worker from the mini template (asynchronous)" },
+  args: {
+    ...projectArg,
+    ...common,
+    template: {
+      type: "string",
+      required: true,
+      description: "mini-glm-codeplan | mini-dashscope-codeplan | mini-codex"
+    },
+    name: { type: "string", required: true, description: "worker name" },
+    agentKind: { type: "string", description: AGENT_KINDS.join(", ") }
+  },
+  run: async ({ args }) => {
+    if (!isWorkerTemplateId(args.template)) throw new Error("invalid worker template");
+    const agentKind = args.agentKind ?? workerTemplateAgentKinds(args.template)[0];
+    if (!isAgentKind(agentKind)) throw new Error("invalid agentKind");
+    if (!workerTemplateAgentKinds(args.template).includes(agentKind))
+      throw new Error("agentKind is not supported by this template");
+    const name = args.name.trim();
+    if (!name) throw new Error("worker name required");
+    const creation = await clientFor(args).workerCreations.create(
+      positiveId(resolveProjectId(args)),
+      {
+        templateId: args.template,
+        name,
+        agentKind
+      }
+    );
+    console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
+  }
+});
+var workerCreationCommand = defineCommand({
+  meta: { name: "creation", description: "inspect worker creation records" },
+  subCommands: {
+    ls: defineCommand({
+      args: { ...projectArg, ...common },
+      run: async ({ args }) => {
+        const list = await clientFor(args).workerCreations.listByProject(
+          positiveId(resolveProjectId(args))
+        );
+        console.log(renderList(list, fmtWorkerCreation, Boolean(args.json)));
+      }
+    }),
+    get: defineCommand({
+      args: { ...common, id: { type: "positional", required: true } },
+      run: async ({ args }) => {
+        const creation = await clientFor(args).workerCreations.get(positiveId(args.id));
+        console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
+      }
+    })
+  }
+});
+
 // src/commands/worker/index.ts
 var resolveWorker = async (client, projectId, handle) => {
   const asId = parseWorkerHandle(handle);
@@ -10246,13 +11535,8 @@ var resolveWorker = async (client, projectId, handle) => {
 };
 var parseAgentKind = (value) => {
   const raw = typeof value === "string" && value.trim() ? value.trim() : "claude-code";
-  if (raw === "claude-code" || raw === "codex") return raw;
-  throw new Error(`invalid agent kind "${raw}" (expected claude-code or codex)`);
-};
-var nonEmptyString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
-var resolveBaseBranch = (input) => {
-  const branch = nonEmptyString(input.flag) ?? nonEmptyString(input.env) ?? nonEmptyString(input.saved) ?? repoHeadBranch(input.repo ?? process.cwd());
-  return validateBaseBranch(branch);
+  if (isAgentKind(raw)) return raw;
+  throw new Error(`invalid agent kind "${raw}" (expected ${AGENT_KINDS.join(", ")})`);
 };
 var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
   const out = await client.workers.register({
@@ -10267,7 +11551,6 @@ var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
     ...existing,
     server: input.server,
     project: input.projectId,
-    baseBranch: input.baseBranch,
     worker: {
       id: out.worker.id,
       name: out.worker.name,
@@ -10281,6 +11564,9 @@ var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
 var worker = defineCommand({
   meta: { name: "worker", description: "register / inspect / close workers for a project" },
   subCommands: {
+    create: workerCreateCommand,
+    creation: workerCreationCommand,
+    templates: workerTemplatesCommand,
     register: defineCommand({
       meta: {
         name: "register",
@@ -10295,11 +11581,7 @@ var worker = defineCommand({
         },
         agentKind: {
           type: "string",
-          description: "agent engine for new sessions: claude-code or codex"
-        },
-        baseBranch: {
-          type: "string",
-          description: "branch new session worktrees start from (default: current branch, then main)"
+          description: `agent engine for new sessions: ${AGENT_KINDS.join(", ")}`
         },
         ...common
       },
@@ -10315,14 +11597,9 @@ var worker = defineCommand({
         const fileToken = savedConfig?.worker?.apiToken;
         const auth = resolveAuth(process.env, fileToken);
         const c = createClient(server, auth && auth !== "cookie" ? auth : void 0);
-        const baseBranch = resolveBaseBranch({
-          flag: args.baseBranch,
-          env: process.env.BATON_BASE_BRANCH,
-          saved: savedConfig?.baseBranch
-        });
-        const hostname = osHostname();
+        const hostname2 = osHostname();
         const machineId = readOrCreateMachineId();
-        const name = args.name ?? hostname;
+        const name = args.name ?? hostname2;
         const agentKind = parseAgentKind(args.agentKind ?? process.env.BATON_AGENT_KIND);
         const { out, configPath } = await registerWorker(
           c,
@@ -10330,20 +11607,18 @@ var worker = defineCommand({
             projectId: resolveProjectId(args),
             name,
             server,
-            hostname,
+            hostname: hostname2,
             machineId,
-            agentKind,
-            baseBranch
+            agentKind
           },
           cfgPath
         );
         if (args.json) {
-          console.log(toJson({ ...out, baseBranch, configPath, machineIdPath: machineIdPath() }));
+          console.log(toJson({ ...out, configPath, machineIdPath: machineIdPath() }));
           return;
         }
         console.log(`worker #${out.worker.id} (${out.worker.name}) \u2014 ${out.outcome}`);
         console.log(`  agentKind:      ${out.worker.agentKind}`);
-        console.log(`  baseBranch:     ${baseBranch}`);
         console.log(`  hostname:       ${out.worker.hostname}`);
         console.log(`  machineId:      ${out.worker.machineId}`);
         console.log(`  machineId file: ${machineIdPath()}`);
@@ -10452,14 +11727,12 @@ var worker = defineCommand({
           console.log("(no worker registered for this project \u2014 run `baton worker register`)");
           return;
         }
-        const baseBranch = resolveBaseBranch({ saved: cfg.baseBranch });
         if (args.json) {
           console.log(
             toJson({
               ...worker2,
               server: cfg.server,
-              projectId: cfg.project,
-              baseBranch
+              projectId: cfg.project
             })
           );
           return;
@@ -10467,7 +11740,6 @@ var worker = defineCommand({
         console.log(`worker #${worker2.id} (${worker2.name})`);
         console.log(`  machineId: ${worker2.machineId}`);
         console.log(`  agentKind: ${worker2.agentKind ?? "claude-code"}`);
-        console.log(`  baseBranch: ${baseBranch}`);
         console.log(`  server:    ${cfg?.server}`);
       }
     })
@@ -10541,10 +11813,12 @@ var main = defineCommand({
   subCommands: {
     init,
     worker,
+    provisioner,
     session,
     service,
     artifact,
     loop,
+    notify,
     relay,
     channel,
     workspace,