@lesscap/baton-cli 0.8.4 → 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") {
@@ -3230,7 +3234,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          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 open2() {
+          ws.once("open", function open3() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -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
@@ -5488,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}`;
@@ -5667,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 } })
   };
 };
 
@@ -5743,6 +5753,7 @@ var clientFromBase = (baseUrl) => ({
   tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
   services: servicesClient(baseUrl),
+  files: filesClient(baseUrl),
   loops: loopsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
@@ -6262,11 +6273,11 @@ var EventSource = class extends EventTarget {
         return;
       }
       const decoder = new TextDecoder(), reader = body.getReader();
-      let open2 = true;
+      let open3 = true;
       do {
         const { done, value } = await reader.read();
-        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open2 = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
-      } while (open2);
+        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) => {
@@ -6721,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]}`;
   });
@@ -6734,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;
@@ -6748,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;
@@ -6761,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) => {
@@ -7221,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));
@@ -7316,6 +7440,37 @@ var absolutePath = (value, field) => {
     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"
@@ -7345,21 +7500,14 @@ var loadProvisionerConfig = async (path) => {
     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");
-  if (!object(raw.workerEnv)) throw new Error("workerEnv must be an object");
-  const workerEnv2 = Object.fromEntries(
-    Object.entries(raw.workerEnv).map(([key, value]) => {
-      if (forbiddenEnv.has(key) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || typeof value !== "string" || value.includes("\0"))
-        throw new Error(`invalid worker environment key: ${key}`);
-      return [key, value];
-    })
-  );
   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: workerEnv2
+    workerEnv: environment(raw.workerEnv),
+    templates: templates(raw.templates)
   };
   await access(config.cliPath, constants.R_OK);
   await access(config.nodePath ?? process.execPath, constants.X_OK);
@@ -7399,9 +7547,9 @@ var createProvisionerClient = (config) => {
 
 // src/provisioner/executor.ts
 import { execFile as execFile3 } from "node:child_process";
-import { lstat, mkdir as mkdir2, realpath, writeFile } from "node:fs/promises";
+import { lstat, mkdir as mkdir3, realpath, writeFile as writeFile2 } from "node:fs/promises";
 import { hostname } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify as promisify3 } from "node:util";
 
@@ -7472,15 +7620,15 @@ var startAgent = async (config, agent, signal) => {
     throw new Error(`launchd start failed; inspect ${plist} and ${agent.log}`);
   }
 };
-var launchWorkerAgent = async (config, creation, repoPath, signal) => startAgent(
+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: config.workerEnv.PATH ?? process.env.PATH ?? "/usr/bin:/bin",
-      ...config.workerEnv,
+      PATH: workerEnv2.PATH ?? process.env.PATH ?? "/usr/bin:/bin",
+      ...workerEnv2,
       HOME: homedir(),
       XDG_DATA_HOME: workerStatePath(config, creation)
     },
@@ -7503,10 +7651,34 @@ var installProvisionerAgent = async (config, configPath) => startAgent(config, {
   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 mkdir2(path, { mode: 448 });
+    await mkdir3(path, { mode: 448 });
   } catch (error) {
     if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
   }
@@ -7514,7 +7686,7 @@ var directory = async (path) => {
   if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`unsafe directory: ${path}`);
 };
 var provisionWorker = async (config, creation, client, signal) => {
-  const repoPath = join4(
+  const repoPath = join5(
     config.projectsRoot,
     `project-${creation.projectId}`,
     `creation-${creation.id}`
@@ -7522,14 +7694,14 @@ var provisionWorker = async (config, creation, client, signal) => {
   const progress = (step) => client.report(creation.id, { status: "running", step, repoPath }, signal);
   await progress("directory");
   signal.throwIfAborted();
-  await mkdir2(config.projectsRoot, { recursive: true, mode: 448 });
+  await mkdir3(config.projectsRoot, { recursive: true, mode: 448 });
   const root = await realpath(config.projectsRoot);
-  await directory(join4(root, `project-${creation.projectId}`));
-  await mkdir2(join4(root, `project-${creation.projectId}`, `creation-${creation.id}`), {
+  await directory(join5(root, `project-${creation.projectId}`));
+  await mkdir3(join5(root, `project-${creation.projectId}`, `creation-${creation.id}`), {
     mode: 448
   });
   await progress("git");
-  const git = async (args) => {
+  const git2 = async (args) => {
     try {
       await promisify3(execFile3)("git", ["-C", repoPath, ...args], {
         env: commandEnvironment(config),
@@ -7541,9 +7713,9 @@ var provisionWorker = async (config, creation, client, signal) => {
       throw new Error("Git repository initialization failed", { cause: error });
     }
   };
-  await git(["init", "-b", "main"]);
-  await writeFile(join4(repoPath, ".git/info/exclude"), "\n.baton.json\n", { flag: "a" });
-  await git([
+  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",
@@ -7556,11 +7728,11 @@ var provisionWorker = async (config, creation, client, signal) => {
   await progress("register");
   const result = await client.register(creation.id, hostname(), signal);
   const state = workerStatePath(config, creation);
-  await directory(join4(root, ".worker-state"));
-  await directory(join4(root, ".worker-state", `project-${creation.projectId}`));
-  await mkdir2(state, { mode: 448 });
-  await mkdir2(join4(state, "baton"), { mode: 448 });
-  await writeFile(join4(state, "baton/machine-id"), `${creation.machineId}
+  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
@@ -7574,14 +7746,15 @@ var provisionWorker = async (config, creation, client, signal) => {
     machineId: result.worker.machineId,
     apiToken: result.apiToken
   });
-  await writeFile(join4(repoPath, ".baton.json"), `${JSON.stringify(cfg, null, 2)}
+  await writeFile2(join5(repoPath, ".baton.json"), `${JSON.stringify(cfg, null, 2)}
 `, {
     flag: "wx",
     mode: 384
   });
   await progress("start");
   signal.throwIfAborted();
-  await launchWorkerAgent(config, creation, repoPath, signal);
+  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) {
@@ -7598,7 +7771,11 @@ var provisionWorker = async (config, creation, client, signal) => {
 // 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)].filter((value) => value.length > 0).reduce((safe, secret) => safe.replaceAll(secret, "[redacted]"), message);
+  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;
@@ -7754,7 +7931,7 @@ var provisioner = defineCommand({
 // 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 join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/client/relay.ts
 var relayClient = (baseUrl) => {
@@ -7882,11 +8059,11 @@ var listenCommand2 = defineCommand({
       process.stdout.write(`${JSON.stringify(o)}
 `);
     };
-    const spillDir = join5(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 = join5(spillDir, `${m.seq}.txt`);
+      const file = join6(spillDir, `${m.seq}.txt`);
       writeFileSync4(file, text);
       const truncated = text.length > PREVIEW2;
       emit({
@@ -7900,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);
     };
@@ -7910,7 +8087,7 @@ 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((resolve4) => {
@@ -8361,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 join6 } from "node:path";
+import { join as join7 } from "node:path";
 var findTranscriptPath = (agentSessionId) => {
-  const root = join6(homedir2(), ".claude", "projects");
+  const root = join7(homedir2(), ".claude", "projects");
   try {
     for (const dir of readdirSync(root)) {
-      const candidate = join6(root, dir, `${agentSessionId}.jsonl`);
+      const candidate = join7(root, dir, `${agentSessionId}.jsonl`);
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
@@ -8444,13 +8621,13 @@ var readFirstExchange = (agentSessionId) => {
 };
 
 // src/session/runner/turn.ts
-import { mkdir as mkdir4, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join10 } 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 as mkdir3 } from "node:fs/promises";
-import { join as join7 } 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 dedupe = (name, taken) => {
@@ -8473,15 +8650,15 @@ var dedupe = (name, taken) => {
 var materializeAttachments = async (opts) => {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const dir = opts.directory;
-  await mkdir3(dir, { recursive: true });
+  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(join7(dir, name)));
-    paths.push(join7(dir, name));
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(join8(dir, name)));
+    paths.push(join8(dir, name));
   }
   return paths;
 };
@@ -8497,7 +8674,7 @@ ${text}` : header;
 };
 
 // src/session/runner/codex.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { Codex } from "@openai/codex-sdk";
 
 // src/session/runner/sdk-env.ts
@@ -8510,6 +8687,7 @@ var additionalDirs = (required = []) => {
   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();
@@ -8530,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);
@@ -8658,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([join8(config.runtimeDir, "attachments")]);
+  const addDirs = additionalDirs([join9(config.runtimeDir, "attachments")]);
   const sandboxMode = codexSandboxMode(opts.planMode ?? false);
   const approvalPolicy = codexApprovalPolicy();
   const networkAccessEnabled = codexNetworkAccess();
@@ -8706,12 +8874,234 @@ 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 join9 } from "node:path";
+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([join9(config.runtimeDir, "attachments")]);
+  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");
@@ -8759,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
   }));
 };
@@ -8795,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 {
@@ -8832,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") {
@@ -8851,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,
@@ -8861,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 };
@@ -8878,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 };
@@ -8918,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);
@@ -8936,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 };
@@ -8962,19 +9352,19 @@ var UnsettledExecution = class extends Error {
 var materializeImages = async (config, execution) => {
   const images = execution.message.payload.images ?? [];
   if (!images.length) return [];
-  const directory2 = join10(
+  const directory2 = join12(
     config.runtimeDir,
     "attachments",
     `message-${execution.message.id}`,
     "pasted"
   );
-  await mkdir4(directory2, { recursive: true });
+  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 = join10(directory2, `pasted-${index + 1}.${match[1]}`);
-      await writeFile2(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;
     })
   );
@@ -8982,7 +9372,7 @@ var materializeImages = async (config, execution) => {
 var buildPrompt = async (config, execution, fetchImpl) => {
   const { text: rawText, attachments = [] } = execution.message.payload;
   const paths = attachments.length ? await materializeAttachments({
-    directory: join10(
+    directory: join12(
       config.runtimeDir,
       "attachments",
       `message-${execution.message.id}`,
@@ -9065,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 }),
@@ -9107,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;
@@ -9126,7 +9518,7 @@ var runDaemon = async (config, deps, signal) => {
   });
   const drain = async () => {
     if (draining || closed || stranded) return;
-    const run2 = async () => {
+    const run4 = async () => {
       while (!closed && !stranded && !signal.aborted) {
         let claimed;
         try {
@@ -9169,7 +9561,7 @@ var runDaemon = async (config, deps, signal) => {
         }
       }
     };
-    draining = run2();
+    draining = run4();
     try {
       await draining;
     } finally {
@@ -9236,16 +9628,16 @@ var runDaemon = async (config, deps, signal) => {
 
 // src/worker/runtime-paths.ts
 import { createHash } from "node:crypto";
-import { homedir as homedir3 } from "node:os";
-import { join as join11 } from "node:path";
-var workerRuntimeDir = (owner, env = process.env) => join11(
-  env.XDG_DATA_HOME ?? join11(env.HOME ?? homedir3(), ".local/share"),
+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) => join11(workerRuntimeDir(owner, env), "sessions", String(sessionId));
+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, {
@@ -9299,6 +9691,7 @@ 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.cwd)
@@ -9606,7 +9999,7 @@ import { hostname as osHostname } from "node:os";
 // 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 join12 } from "node:path";
+import { dirname as dirname3, join as join14 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker/git-exclude.ts
@@ -9638,8 +10031,8 @@ var TARGETS = [`.claude/skills/${SKILL_NAME}`, `.agents/skills/${SKILL_NAME}`];
 var bundledSkillPath = () => {
   const here = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
-    join12(here, "..", "skills", SKILL_NAME),
-    join12(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}`);
@@ -9656,8 +10049,427 @@ var syncBundledArtifactSkill = (cwd) => {
   const source = bundledSkillPath();
   TARGETS.filter((target) => !isTracked(cwd, target)).forEach((target) => {
     ensureExcluded(cwd, `${target}/`);
-    cpSync(source, join12(cwd, target), { recursive: true, force: true });
+    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
@@ -9718,13 +10530,13 @@ var createLiveness = (deps) => {
 
 // src/worker/service-supervisor.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { stat as stat3 } from "node:fs/promises";
-import { join as join14 } 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 dirname4, join as join13 } 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) => {
@@ -9735,7 +10547,7 @@ var isWrapperMessage = (message) => {
 };
 var binPath = () => {
   const here = dirname4(fileURLToPath2(import.meta.url));
-  const devShim = join13(here, "..", "..", "bin", "baton.mjs");
+  const devShim = join16(here, "..", "..", "bin", "baton.mjs");
   return existsSync6(devShim) ? devShim : fileURLToPath2(import.meta.url);
 };
 var startServiceProcess = (input) => {
@@ -9822,15 +10634,15 @@ var createServiceSupervisor = (deps) => {
   };
   const runOne = async (requestId, cwd, name, argv, publicUrl, note) => {
     try {
-      if (!(await stat3(cwd)).isDirectory())
+      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 = join14(workerRuntimeDir(cfg), "services");
-    const logPath = join14(logDir, `${name}.log`);
+    const logDir = join17(workerRuntimeDir(cfg), "services");
+    const logPath = join17(logDir, `${name}.log`);
     mkdirSync4(logDir, { recursive: true, mode: 448 });
     if (entries.has(name))
       return report({
@@ -9870,7 +10682,7 @@ var createServiceSupervisor = (deps) => {
     log(`service ${name} started in ${cwd}`);
     await report({ requestId, ok: true, service: service2, logPath });
   };
-  const run2 = async (requestId, cwd, name, argv, publicUrl, note) => {
+  const run4 = async (requestId, cwd, name, argv, publicUrl, note) => {
     try {
       await runOne(requestId, cwd, name, argv, publicUrl, note);
     } catch (error) {
@@ -9888,15 +10700,15 @@ var createServiceSupervisor = (deps) => {
     await report({ requestId, ok: true });
   };
   const killAll = () => entries.forEach(stopEntry);
-  return { run: run2, stop, 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 { mkdir as mkdir5, rm as rm2, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname5, join as join17 } 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";
 
@@ -9990,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 join15 } 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;
@@ -9999,7 +10811,7 @@ var generateTitleWithCodex = async (input) => {
   const timer = setTimeout(() => abort.abort(), TITLE_TIMEOUT_MS);
   let cwd = "";
   try {
-    cwd = await mkdtemp(join15(tmpdir3(), "baton-title-"));
+    cwd = await mkdtemp(join18(tmpdir3(), "baton-title-"));
     const client = input.client ?? new Codex2();
     const thread = client.startThread({
       workingDirectory: cwd,
@@ -10025,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 execFile4 } from "node:child_process";
-import { readFile as readFile2, rename, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join16 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-var run = promisify4(execFile4);
+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 = (cwd) => join16(cwd, 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 (cwd) => {
   let raw;
   try {
-    raw = await readFile2(recordPath(cwd), "utf8");
+    raw = await readFile3(recordPath(cwd), "utf8");
   } catch (error) {
     if (codeOf(error) === "ENOENT") return null;
     throw error;
@@ -10050,7 +10922,7 @@ var readRunnerRecord = async (cwd) => {
 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) => {
@@ -10075,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;
@@ -10100,7 +10972,7 @@ var stopRecordedRunner = async (record, expected, graceMs = 5e3) => {
 // src/worker/session-supervisor.ts
 var binPath2 = () => {
   const here = dirname5(fileURLToPath3(import.meta.url));
-  const devShim = join17(here, "..", "..", "bin", "baton.mjs");
+  const devShim = join21(here, "..", "..", "bin", "baton.mjs");
   return existsSync7(devShim) ? devShim : fileURLToPath3(import.meta.url);
 };
 var createSessionSupervisor = (deps) => {
@@ -10209,7 +11081,7 @@ var createSessionSupervisor = (deps) => {
       return;
     if (wasCanceled()) return log(`session #${sessionId} start canceled before materializing`);
     const directory2 = session2.cwd ?? cwd;
-    if (!(await stat4(directory2)).isDirectory()) throw new Error(`not a directory: ${directory2}`);
+    if (!(await stat5(directory2)).isDirectory()) throw new Error(`not a directory: ${directory2}`);
     if (wasCanceled()) return;
     if (!session2.agentSessionId || !session2.cwd) {
       const id = randomUUID2();
@@ -10217,7 +11089,7 @@ var createSessionSupervisor = (deps) => {
       await client.sessions.materialize(sessionId, { agentSessionId, cwd: directory2 }, cfg.apiToken);
       log(`materialized session #${sessionId} (${name}) \u2192 ${directory2}`);
     }
-    await mkdir5(sessionRuntimeDir(cfg, sessionId), { recursive: true, mode: 448 });
+    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;
@@ -10249,7 +11121,7 @@ var createSessionSupervisor = (deps) => {
     return enqueue(sessionId, async () => {
       const entry = children.get(sessionId);
       await stopRecord(sessionId);
-      await rm2(sessionRuntimeDir(cfg, sessionId), { recursive: true, force: true });
+      await rm3(sessionRuntimeDir(cfg, sessionId), { recursive: true, force: true });
       if (children.get(sessionId) === entry) children.delete(sessionId);
     });
   };
@@ -10258,15 +11130,12 @@ var createSessionSupervisor = (deps) => {
     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({
-      cwd: cwd2,
-      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`);
@@ -10347,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 homedir4 } from "node:os";
-import { join as join18 } 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",
@@ -10363,13 +11233,25 @@ 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 = join18(homedir4(), ".claude", "projects");
+  const root = join22(homedir5(), ".claude", "projects");
   if (!existsSync8(root)) return false;
   for (const dir of readdirSync2(root))
-    if (existsSync8(join18(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;
 
@@ -10377,13 +11259,13 @@ var isPositiveDim = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 var createTerminalManager = (deps) => {
   const { cfg, log, hasChild } = deps;
   const terminals = /* @__PURE__ */ new Map();
-  const open2 = (sessionId, agentSessionId, cwd) => {
+  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;
     }
-    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,
@@ -10435,7 +11317,7 @@ var createTerminalManager = (deps) => {
     }
   };
   return {
-    open: open2,
+    open: open3,
     close,
     has: (sessionId) => terminals.has(sessionId),
     killAll: () => {
@@ -10473,6 +11355,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
     log,
     hasChild: (id) => supervisor.has(id)
   });
+  const files = createFileQueryRunner(cwd);
   const services = createServiceSupervisor({
     sendReport: (report) => client.services.report(report),
     cfg,
@@ -10528,6 +11411,8 @@ var runWorkerDaemon = async (cfg, client, signal) => {
         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)}`);
     }
@@ -10551,16 +11436,16 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 // src/worker/machine-id.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname6, join as join19 } from "node:path";
-var machineIdPath = (env = process.env) => join19(env.XDG_DATA_HOME ?? join19(env.HOME ?? homedir5(), ".local/share"), "baton", "machine-id");
+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 (existsSync9(path)) {
     const s = readFileSync6(path, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID3();
-  mkdirSync5(dirname6(path), { recursive: true });
+  mkdirSync5(dirname7(path), { recursive: true });
   writeFileSync5(path, `${id}
 `, "utf8");
   return id;
@@ -10588,22 +11473,28 @@ var workerCreateCommand = defineCommand({
   args: {
     ...projectArg,
     ...common,
-    template: { type: "string", required: true, description: "mini-local" },
+    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", default: "claude-code", description: "claude-code or codex" }
+    agentKind: { type: "string", description: AGENT_KINDS.join(", ") }
   },
   run: async ({ args }) => {
-    if (args.template !== "mini-local") throw new Error("template must be mini-local");
-    if (args.agentKind !== "claude-code" && args.agentKind !== "codex")
-      throw new Error("invalid agentKind");
+    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: "mini-local",
+        templateId: args.template,
         name,
-        agentKind: args.agentKind
+        agentKind
       }
     );
     console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
@@ -10644,8 +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)`);
+  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({
@@ -10690,7 +11581,7 @@ var worker = defineCommand({
         },
         agentKind: {
           type: "string",
-          description: "agent engine for new sessions: claude-code or codex"
+          description: `agent engine for new sessions: ${AGENT_KINDS.join(", ")}`
         },
         ...common
       },
@@ -10927,6 +11818,7 @@ var main = defineCommand({
     service,
     artifact,
     loop,
+    notify,
     relay,
     channel,
     workspace,