@lesscap/baton-cli 0.1.0

package/dist/baton.mjs

@@ -0,0 +1,2779 @@
+#!/usr/bin/env node
+
+// ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string") return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+function snakeCase(str) {
+  return kebabCase(str || "", "_");
+}
+
+// ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "node:util";
+function toArray(val) {
+  if (Array.isArray(val)) return val;
+  return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map();
+  const mainToAliases = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name)) return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+    return "string";
+  }
+  function isStringType(name) {
+    if (strings.has(name)) return true;
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (strings.has(alias)) return true;
+    return false;
+  }
+  const allOptions = /* @__PURE__ */ new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions) if (!options[name]) options[name] = {
+    type: getType(name),
+    default: defaults[name]
+  };
+  for (const [alias, main2] of aliasToMain.entries()) if (alias.length === 1 && options[main2] && !options[main2].short) options[main2].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : void 0,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values)) {
+    let coerced = value;
+    if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+    else if (isStringType(key) && typeof value === "boolean") coerced = "";
+    out[key] = coerced;
+  }
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName) out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases) for (const alias of aliases) out[alias] = false;
+  }
+  for (const [alias, main2] of aliasToMain.entries()) {
+    if (out[alias] !== void 0 && out[main2] === void 0) out[main2] = out[alias];
+    if (out[main2] !== void 0 && out[alias] === void 0) out[alias] = out[main2];
+    if (out[alias] !== out[main2] && defaults[main2] === out[main2]) out[main2] = out[alias];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") continue;
+    if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+    if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+    if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+      if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries()) if (arg.type === "positional") {
+    const nextPositionalArgument = positionalArguments.shift();
+    if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+    else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+    else parsedArgsProxy[arg.name] = arg.default;
+  } else if (arg.type === "enum") {
+    const argument = parsedArgsProxy[arg.name];
+    const options = arg.options || [];
+    if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+  } else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+    ...argDef,
+    name,
+    alias: toArray(argDef.alias)
+  });
+  return args;
+}
+async function resolvePlugins(plugins) {
+  return Promise.all(plugins.map((p) => resolveValue(p)));
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  const plugins = await resolvePlugins(cmd.plugins ?? []);
+  let result;
+  let runError;
+  try {
+    for (const plugin of plugins) await plugin.setup?.(context);
+    if (typeof cmd.setup === "function") await cmd.setup(context);
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+      const explicitName = opts.rawArgs[subCommandArgIndex];
+      if (explicitName) {
+        const subCommand = await _findSubCommand(subCommands, explicitName);
+        if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+        await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else {
+        const defaultSubCommand = await resolveValue(cmd.default);
+        if (defaultSubCommand) {
+          if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+          const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+          if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+          await runCommand(subCommand, { rawArgs: opts.rawArgs });
+        } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      }
+    }
+    if (typeof cmd.run === "function") result = await cmd.run(context);
+  } catch (error) {
+    runError = error;
+  }
+  const cleanupErrors = [];
+  if (typeof cmd.cleanup === "function") try {
+    await cmd.cleanup(context);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  for (const plugin of [...plugins].reverse()) try {
+    await plugin.cleanup?.(context);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  if (runError) throw runError;
+  if (cleanupErrors.length === 1) throw cleanupErrors[0];
+  if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await _findSubCommand(subCommands, subCommandName);
+    if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function _findSubCommand(subCommands, name) {
+  if (name in subCommands) return resolveValue(subCommands[name]);
+  for (const sub of Object.values(subCommands)) {
+    const resolved = await resolveValue(sub);
+    const meta = await resolveValue(resolved?.meta);
+    if (meta?.alias) {
+      if (toArray(meta.alias).includes(name)) return resolved;
+    }
+  }
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--") return -1;
+    if (arg.startsWith("-")) {
+      if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
+      continue;
+    }
+    return i;
+  }
+  return -1;
+}
+function _isValueFlag(flag, argsDef) {
+  const name = flag.replace(/^-{1,2}/, "");
+  const normalized = camelCase(name);
+  for (const [key, def] of Object.entries(argsDef)) {
+    if (def.type !== "string" && def.type !== "enum") continue;
+    if (normalized === camelCase(key)) return true;
+    if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+  }
+  return false;
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + "\n");
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs) if (arg.type === "positional") {
+    const name = arg.name.toUpperCase();
+    const isRequired = arg.required !== false && arg.default === void 0;
+    posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+    usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+  } else {
+    const isRequired = arg.required === true && arg.default === void 0;
+    const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+    argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+    if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+      const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+      argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+    }
+    if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
+  }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden) continue;
+      const aliases = toArray(meta?.alias);
+      const label = [name, ...aliases].join(", ");
+      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandNames.push(name, ...aliases);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+function renderValueHint(arg) {
+  const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+  const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+  if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+  if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+  return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+  const requiredHint = required ? gray("(Required)") : "";
+  const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+  return [
+    arg.description,
+    requiredHint,
+    defaultHint
+  ].filter(Boolean).join(" ");
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    const builtinFlags = await _resolveBuiltinFlags(cmd);
+    if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else console.error(error, "\n");
+    process.exit(1);
+  }
+}
+async function _resolveBuiltinFlags(cmd) {
+  const argsDef = await resolveValue(cmd.args || {});
+  const userNames = /* @__PURE__ */ new Set();
+  const userAliases = /* @__PURE__ */ new Set();
+  for (const [name, def] of Object.entries(argsDef)) {
+    userNames.add(name);
+    for (const alias of toArray(def.alias)) userAliases.add(alias);
+  }
+  return {
+    help: _getBuiltinFlags("help", "h", userNames, userAliases),
+    version: _getBuiltinFlags("version", "v", userNames, userAliases)
+  };
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+  if (userNames.has(long) || userAliases.has(long)) return [];
+  if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+  return [`--${long}`, `-${short}`];
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "node:fs";
+import * as readline from "node:readline/promises";
+
+// src/client/request.ts
+var authHeaders = {};
+var loginGate = null;
+var setAuthHeaders = (h) => {
+  authHeaders = h;
+};
+var setLoginGate = (p) => {
+  loginGate = p;
+};
+var request = async (url, init2) => {
+  if (loginGate) await loginGate;
+  const baseHeaders = init2.body !== void 0 ? { "content-type": "application/json" } : {};
+  const res = await fetch(url, {
+    method: init2.method,
+    headers: { ...baseHeaders, ...authHeaders, ...init2.headers ?? {} },
+    ...init2.body !== void 0 ? { body: JSON.stringify(init2.body) } : {}
+  });
+  if (!res.ok) throw new Error(`${init2.method} ${url} \u2192 ${res.status}: ${await res.text()}`);
+  if (res.status === 204) return void 0;
+  return await res.json();
+};
+
+// src/client/auth.ts
+var primed = false;
+var primeLogin = (baseUrl) => {
+  if (primed) return;
+  primed = true;
+  const username = process.env.BATON_USER;
+  const password = process.env.BATON_PASS;
+  if (!username || !password) return;
+  setLoginGate(
+    (async () => {
+      const res = await fetch(`${baseUrl}/auth/login`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ username, password })
+      });
+      const cookie = (res.headers.get("set-cookie") ?? "").split(";")[0];
+      if (res.ok && cookie) setAuthHeaders({ cookie });
+    })().catch(() => {
+    })
+  );
+};
+
+// src/client/projects.ts
+var projectClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (input) => request(u("/projects"), { method: "POST", body: input }),
+    listByWorkspace: (workspaceId) => request(u(`/workspaces/${workspaceId}/projects`), { method: "GET" }),
+    get: (id) => request(u(`/projects/${id}`), { method: "GET" }),
+    update: (id, patch2) => request(u(`/projects/${id}`), { method: "PATCH", body: patch2 }),
+    remove: (id) => request(u(`/projects/${id}`), { method: "DELETE" })
+  };
+};
+
+// src/client/items.ts
+var fetchItemByCode = async (baseUrl, projectId, code, expectKind) => {
+  const r = await request(
+    `${baseUrl}/projects/${projectId}/items/${encodeURIComponent(code)}`,
+    { method: "GET" }
+  );
+  if (r.kind !== expectKind) throw new Error(`expected ${expectKind} but got ${r.kind} for ${code}`);
+  return r.item;
+};
+
+// src/client/requirements.ts
+var requirementClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (input) => request(u("/requirements"), { method: "POST", body: input }),
+    listByProject: (projectId) => request(u(`/projects/${projectId}/requirements`), { method: "GET" }),
+    get: (id) => request(u(`/requirements/${id}`), { method: "GET" }),
+    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "requirement"),
+    setStatus: (id, status) => request(u(`/requirements/${id}`), { method: "PATCH", body: { status } }),
+    remove: (id) => request(u(`/requirements/${id}`), { method: "DELETE" })
+  };
+};
+
+// src/client/sessions.ts
+var sessionsClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (input) => request(u("/sessions"), { method: "POST", body: input }),
+    materialize: (id, input, workerToken) => request(u(`/sessions/${id}`), {
+      method: "PATCH",
+      body: input,
+      headers: { authorization: `Bearer ${workerToken}` }
+    }),
+    setStatus: (id, active, workerToken) => request(u(`/sessions/${id}/status`), {
+      method: "POST",
+      body: { active },
+      headers: { authorization: `Bearer ${workerToken}` }
+    }),
+    setName: (id, name, workerToken) => request(u(`/sessions/${id}`), {
+      method: "PATCH",
+      body: { name },
+      headers: { authorization: `Bearer ${workerToken}` }
+    }),
+    resume: (id) => request(u(`/sessions/${id}/resume`), { method: "POST" }),
+    stop: (id) => request(u(`/sessions/${id}/stop`), { method: "POST" }),
+    rename: (id, name) => request(u(`/sessions/${id}/rename`), { method: "POST", body: { name } }),
+    listByProject: (projectId) => request(u(`/projects/${projectId}/sessions`), { method: "GET" }),
+    get: (id) => request(u(`/sessions/${id}`), { method: "GET" }),
+    findByName: async (projectId, name) => {
+      const all = await request(u(`/projects/${projectId}/sessions`), { method: "GET" });
+      const matches = all.filter((s) => s.name === name);
+      return matches.length === 0 ? null : matches[matches.length - 1] ?? null;
+    },
+    sendMessage: (id, text, attachments) => request(u(`/sessions/${id}/messages`), {
+      method: "POST",
+      body: attachments && attachments.length > 0 ? { text, attachments } : { text }
+    }),
+    // Raw-body upload: the file streams as the request body (no multipart), so
+    // a Blob backed by a file on disk uploads without buffering. filename rides
+    // a query param; content-type carries the media type.
+    uploadAttachment: async (id, input) => {
+      const url = u(`/sessions/${id}/attachments?filename=${encodeURIComponent(input.filename)}`);
+      const res = await fetch(url, {
+        method: "POST",
+        body: input.body,
+        headers: { "content-type": input.contentType }
+      });
+      if (!res.ok) throw new Error(`POST ${url} \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    destroy: async (id) => {
+      await request(u(`/sessions/${id}`), { method: "DELETE" });
+    }
+  };
+};
+
+// src/client/tasks.ts
+var taskClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (input) => request(u("/tasks"), { method: "POST", body: input }),
+    listByRequirement: (requirementId) => request(u(`/requirements/${requirementId}/tasks`), { method: "GET" }),
+    get: (id) => request(u(`/tasks/${id}`), { method: "GET" }),
+    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "task"),
+    setStatus: (id, status) => request(u(`/tasks/${id}`), { method: "PATCH", body: { status } }),
+    remove: (id) => request(u(`/tasks/${id}`), { method: "DELETE" }),
+    listComments: (id) => request(u(`/tasks/${id}/comments`), { method: "GET" }),
+    addComment: (id, body, workerId) => request(u(`/tasks/${id}/comments`), { method: "POST", body: { body, workerId } })
+  };
+};
+
+// src/client/workers.ts
+var workersClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    register: (input) => request(u("/workers"), { method: "POST", body: input }),
+    listByProject: (projectId) => request(u(`/projects/${projectId}/workers`), { method: "GET" }),
+    get: (id) => request(u(`/workers/${id}`), { method: "GET" }),
+    findByName: async (projectId, name) => {
+      const all = await request(u(`/projects/${projectId}/workers`), {
+        method: "GET"
+      });
+      const matches = all.filter((w) => w.name === name);
+      return matches.length === 0 ? null : matches[matches.length - 1] ?? null;
+    },
+    heartbeat: (machineId) => request(u("/workers/heartbeat"), { method: "POST", body: { machineId } }),
+    destroy: async (id) => {
+      await request(u(`/workers/${id}`), { method: "DELETE" });
+    }
+  };
+};
+
+// src/client/workspaces.ts
+var workspaceClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  return {
+    create: (input) => request(u("/workspaces"), { method: "POST", body: input }),
+    list: () => request(u("/workspaces"), { method: "GET" }),
+    get: (id) => request(u(`/workspaces/${id}`), { method: "GET" }),
+    update: (id, patch2) => request(u(`/workspaces/${id}`), { method: "PATCH", body: patch2 }),
+    remove: (id) => request(u(`/workspaces/${id}`), { method: "DELETE" })
+  };
+};
+
+// src/client.ts
+var createClient = (baseUrl, opts) => {
+  if (opts?.bearer) setAuthHeaders({ authorization: `Bearer ${opts.bearer}` });
+  else primeLogin(baseUrl);
+  return clientFromBase(baseUrl);
+};
+var clientFromBase = (baseUrl) => ({
+  workspaces: workspaceClient(baseUrl),
+  projects: projectClient(baseUrl),
+  requirements: requirementClient(baseUrl),
+  tasks: taskClient(baseUrl),
+  sessions: sessionsClient(baseUrl),
+  workers: workersClient(baseUrl)
+});
+var createWorkerClient = (baseUrl, workerToken, sessionId) => {
+  const u = (p) => `${baseUrl}${p}`;
+  const auth = { authorization: `Bearer ${workerToken}` };
+  return {
+    emitEvent: (type, payload) => request(u(`/sessions/${sessionId}/events`), {
+      method: "POST",
+      body: { type, payload },
+      headers: auth
+    }),
+    setActive: (active) => request(u(`/sessions/${sessionId}/status`), {
+      method: "POST",
+      body: { active },
+      headers: auth
+    })
+  };
+};
+
+// src/project-config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var PROJECT_CONFIG_NAME = ".baton.json";
+var projectConfigPath = (cwd = process.cwd()) => join(cwd, PROJECT_CONFIG_NAME);
+var loadProjectConfig = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    const cause = err.code === "ENOENT" ? `not found at ${path}` : String(err);
+    throw new Error(`${PROJECT_CONFIG_NAME} ${cause} \u2014 run \`baton init\` first`);
+  }
+};
+var loadProjectConfigOrNull = (path) => {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var saveProjectConfig = (path, config) => {
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+};
+var patch = (path, fn) => {
+  saveProjectConfig(path, fn(loadProjectConfig(path)));
+};
+var setWorker = (path, w) => patch(path, (cfg) => ({ ...cfg, worker: w }));
+var requireBase = (cfg) => {
+  if (!cfg.server || !cfg.project || !cfg.worker)
+    throw new Error("project-config missing server/project/worker \u2014 run `baton worker register`");
+  return { server: cfg.server, project: cfg.project, worker: cfg.worker };
+};
+var viewWorker = (cfg) => {
+  const { server, project: project2, worker: worker2 } = requireBase(cfg);
+  return {
+    server,
+    projectId: project2,
+    workerId: worker2.id,
+    name: worker2.name,
+    machineId: worker2.machineId,
+    apiToken: worker2.apiToken
+  };
+};
+
+// src/config.ts
+var resolveBaseUrl = (urlArg, env = process.env) => {
+  if (urlArg) return urlArg;
+  const cfg = loadProjectConfigOrNull(projectConfigPath());
+  if (cfg?.server) return cfg.server;
+  return env.BATON_URL ?? "http://localhost:3280";
+};
+
+// src/util.ts
+var common = {
+  url: {
+    type: "string",
+    description: "baton server url (--url > .baton.json > BATON_URL > http://localhost:3280)"
+  },
+  json: { type: "boolean", description: "output JSON" }
+};
+var clientFor = (args) => createClient(resolveBaseUrl(args.url));
+var resolveProjectId = (args) => {
+  if (args.project !== void 0 && args.project !== "") return Number(args.project);
+  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.");
+};
+var resolveWorkspaceId = (args) => {
+  if (args.workspace !== void 0 && args.workspace !== "") return Number(args.workspace);
+  const cfg = loadProjectConfigOrNull(projectConfigPath());
+  if (cfg?.workspace !== void 0) return cfg.workspace;
+  throw new Error(
+    "no workspace in scope. pass --workspace <id> or run `baton init` in this directory."
+  );
+};
+var splitCsv = (s) => s ? s.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+
+// src/commands/init.ts
+var promptPick = async (label, items) => {
+  if (items.length === 0) throw new Error(`no ${label}s found on server`);
+  console.log(`${label}s:`);
+  items.forEach((it, i) => {
+    console.log(`  [${i + 1}] #${it.id}  ${it.name}`);
+  });
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const ans = (await rl.question(`pick a ${label} (1-${items.length}): `)).trim();
+    const idx = Number(ans) - 1;
+    const picked = items[idx];
+    if (!picked) throw new Error(`invalid choice: ${ans}`);
+    return picked;
+  } finally {
+    rl.close();
+  }
+};
+var init = defineCommand({
+  meta: {
+    name: "init",
+    description: `write ${PROJECT_CONFIG_NAME} in the current directory (local state, gitignored)`
+  },
+  args: {
+    workspace: { type: "string", description: "workspace id (skip prompt)" },
+    project: { type: "string", description: "project id (skip prompt)" },
+    force: { type: "boolean", description: `overwrite existing ${PROJECT_CONFIG_NAME}` },
+    ...common
+  },
+  run: async ({ args }) => {
+    const server = resolveBaseUrl(args.url);
+    const cfgPath = projectConfigPath();
+    if (existsSync2(cfgPath) && !args.force)
+      throw new Error(`${PROJECT_CONFIG_NAME} already exists. use --force to overwrite.`);
+    const c = createClient(server);
+    let project2;
+    let workspace2;
+    if (args.project) {
+      project2 = await c.projects.get(Number(args.project));
+      workspace2 = await c.workspaces.get(project2.workspaceId);
+    } else {
+      const wsList = await c.workspaces.list();
+      workspace2 = args.workspace ? wsList.find((w) => w.id === Number(args.workspace)) ?? (() => {
+        throw new Error(`workspace ${args.workspace} not found`);
+      })() : await promptPick("workspace", wsList);
+      const projects = await c.projects.listByWorkspace(workspace2.id);
+      project2 = await promptPick("project", projects);
+    }
+    const cfg = {
+      server,
+      workspace: workspace2.id,
+      project: project2.id,
+      name: project2.name
+    };
+    saveProjectConfig(cfgPath, cfg);
+    console.log(`wrote ${cfgPath}`);
+    console.log(`  server:    ${server}`);
+    console.log(`  workspace: #${workspace2.id}  ${workspace2.name}`);
+    console.log(`  project:   #${project2.id}  ${project2.name}`);
+  }
+});
+
+// src/output.ts
+var toJson = (data) => JSON.stringify(data, null, 2);
+var fmtWorkspace = (w) => `${w.id}  ${w.name}`;
+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 fmtWorker = (w) => {
+  const offline = w.alive === false ? "  [offline]" : "";
+  return `${w.id}  ${w.name}  ${w.hostname}${offline}`;
+};
+var renderOne = (item, fmt, json) => json ? toJson(item) : fmt(item);
+var renderList = (items, fmt, json) => {
+  if (json) return toJson(items);
+  return items.length ? items.map(fmt).join("\n") : "(none)";
+};
+var removed = (kind, id, json) => json ? toJson({ ok: true, deleted: id }) : `deleted ${kind} ${id}`;
+
+// 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));
+var getProject = (c, id, json) => c.projects.get(id).then((p) => renderOne(p, fmtProject, json));
+var updateProject = (c, id, patch2, json) => c.projects.update(id, patch2).then((p) => renderOne(p, fmtProject, json));
+var removeProject = (c, id, json) => c.projects.remove(id).then(() => removed("project", id, json));
+var project = defineCommand({
+  meta: { name: "project", description: "manage projects" },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "create a project" },
+      args: {
+        name: { type: "positional", required: true },
+        workspace: { type: "string", description: "workspace id (overrides .baton.json)" },
+        desc: { type: "string", description: "description" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const out = await createProject(
+          clientFor(args),
+          { workspaceId: resolveWorkspaceId(args), name: args.name, description: args.desc },
+          Boolean(args.json)
+        );
+        console.log(out);
+      }
+    }),
+    ls: defineCommand({
+      meta: { name: "ls", description: "list projects in a workspace" },
+      args: {
+        workspace: { type: "string", description: "workspace id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        console.log(
+          await listProjects(clientFor(args), resolveWorkspaceId(args), Boolean(args.json))
+        );
+      }
+    }),
+    get: defineCommand({
+      meta: { name: "get", description: "get a project" },
+      args: { id: { type: "positional", required: true }, ...common },
+      run: async ({ args }) => {
+        console.log(await getProject(clientFor(args), Number(args.id), Boolean(args.json)));
+      }
+    }),
+    update: defineCommand({
+      meta: { name: "update", description: "rename a project / set its description" },
+      args: {
+        id: { type: "positional", required: true },
+        name: { type: "string", description: "new name" },
+        desc: { type: "string", description: "new description" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const patch2 = {
+          ...args.name !== void 0 ? { name: args.name } : {},
+          ...args.desc !== void 0 ? { description: args.desc } : {}
+        };
+        if (Object.keys(patch2).length === 0) throw new Error("pass --name and/or --desc");
+        console.log(
+          await updateProject(clientFor(args), Number(args.id), patch2, Boolean(args.json))
+        );
+      }
+    }),
+    rm: defineCommand({
+      meta: { name: "rm", description: "delete a project" },
+      args: { id: { type: "positional", required: true }, ...common },
+      run: async ({ args }) => {
+        console.log(await removeProject(clientFor(args), Number(args.id), Boolean(args.json)));
+      }
+    })
+  }
+});
+
+// src/commands/requirement.ts
+var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
+var listRequirements = (c, projectId, json) => c.requirements.listByProject(projectId).then((rs) => renderList(rs, fmtRequirement, json));
+var getRequirement = (c, id, json) => c.requirements.get(id).then((r) => renderOne(r, fmtRequirement, json));
+var setRequirementStatus = (c, id, status, json) => c.requirements.setStatus(id, status).then((r) => renderOne(r, fmtRequirement, json));
+var removeRequirement = (c, id, label, json) => c.requirements.remove(id).then(() => removed("requirement", label, json));
+var resolveByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
+var requirement = defineCommand({
+  meta: { name: "requirement", description: "manage requirements" },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "create a requirement" },
+      args: {
+        title: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        desc: { type: "string", description: "description" },
+        body: { type: "string", description: "requirement body (markdown)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        console.log(
+          await createRequirement(
+            clientFor(args),
+            {
+              projectId: resolveProjectId(args),
+              title: args.title,
+              description: args.desc,
+              body: args.body
+            },
+            Boolean(args.json)
+          )
+        );
+      }
+    }),
+    ls: defineCommand({
+      meta: { name: "ls", description: "list requirements in a project" },
+      args: {
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        console.log(
+          await listRequirements(clientFor(args), resolveProjectId(args), Boolean(args.json))
+        );
+      }
+    }),
+    get: defineCommand({
+      meta: { name: "get", description: "get a requirement by code (R-N)" },
+      args: {
+        code: { type: "positional", required: true, description: "requirement code, e.g. R-1" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveByCode(c, resolveProjectId(args), args.code);
+        console.log(await getRequirement(c, id, Boolean(args.json)));
+      }
+    }),
+    "set-status": defineCommand({
+      meta: { name: "set-status", description: "set requirement status (active|done|cancelled)" },
+      args: {
+        code: { type: "positional", required: true, description: "requirement code (R-N)" },
+        status: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveByCode(c, resolveProjectId(args), args.code);
+        console.log(
+          await setRequirementStatus(c, id, args.status, Boolean(args.json))
+        );
+      }
+    }),
+    rm: defineCommand({
+      meta: { name: "rm", description: "delete a requirement by code" },
+      args: {
+        code: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveByCode(c, resolveProjectId(args), args.code);
+        console.log(await removeRequirement(c, id, args.code, Boolean(args.json)));
+      }
+    })
+  }
+});
+
+// src/commands/session/create.ts
+var sessionCreateCommand = defineCommand({
+  meta: { name: "create", description: "create + start a session on a worker" },
+  args: {
+    name: { type: "positional", required: true, description: "session name" },
+    worker: { type: "string", description: "worker id (default: this machine's worker)" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const projectId = resolveProjectId(args);
+    const workerId = args.worker ? Number(args.worker) : loadProjectConfigOrNull(projectConfigPath())?.worker?.id;
+    if (!workerId)
+      throw new Error("no worker id \u2014 pass --worker or run `baton worker register` first");
+    const s = await c.sessions.create({ projectId, workerId, name: args.name });
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/shared.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join2(env.XDG_DATA_HOME ?? join2(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) {
+    const byId = await client.sessions.get(asInt).catch(() => null);
+    if (byId) return { id: byId.id, name: byId.name };
+  }
+  const byName = await client.sessions.findByName(projectId, handle);
+  if (byName) return { id: byName.id, name: byName.name };
+  throw new Error(`session "${handle}" not found in project ${projectId}`);
+};
+
+// src/commands/session/get.ts
+var sessionGetCommand = defineCommand({
+  meta: { name: "get", description: "get a session by int id or name" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const projectId = resolveProjectId(args);
+    const handle = await resolveSession(c, projectId, args.session);
+    const s = await c.sessions.get(handle.id);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/ls.ts
+var sessionLsCommand = defineCommand({
+  meta: { name: "ls", description: "list sessions in a project" },
+  args: {
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const ss = await c.sessions.listByProject(resolveProjectId(args));
+    console.log(renderList(ss, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/rename.ts
+var sessionRenameCommand = defineCommand({
+  meta: { name: "rename", description: "rename a session (locks the name against auto-title)" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    name: { type: "positional", required: true, description: "new name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const handle = await resolveSession(c, resolveProjectId(args), args.session);
+    const s = await c.sessions.rename(handle.id, args.name);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/resume.ts
+var sessionResumeCommand = defineCommand({
+  meta: { name: "resume", description: "resume (re-start) an existing session" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const handle = await resolveSession(c, resolveProjectId(args), args.session);
+    const s = await c.sessions.resume(handle.id);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/rm.ts
+var sessionRmCommand = defineCommand({
+  meta: { name: "rm", description: "delete a session (irreversible; removes its worktree)" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    confirm: { type: "boolean", description: "actually perform the deletion" },
+    ...common
+  },
+  run: async ({ args }) => {
+    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("re-run with --confirm to proceed.");
+      return;
+    }
+    await c.sessions.destroy(handle.id);
+    console.log(`deleted session ${handle.name} (#${handle.id})`);
+  }
+});
+
+// ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// ../../node_modules/.pnpm/eventsource@4.1.0/node_modules/eventsource/dist/index.js
+var ErrorEvent = class extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(type, errorEventInitDict) {
+    var _a, _b;
+    super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [/* @__PURE__ */ Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+};
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError(err) {
+  return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _readyState;
+var _url;
+var _redirectUrl;
+var _withCredentials;
+var _fetch;
+var _reconnectInterval;
+var _reconnectTimer;
+var _lastEventId;
+var _controller;
+var _parser;
+var _onError;
+var _onMessage;
+var _onOpen;
+var _EventSource_instances;
+var connect_fn;
+var _onFetchResponse;
+var _onFetchError;
+var getRequestOptions_fn;
+var _onEvent;
+var _onRetryChange;
+var failConnection_fn;
+var scheduleReconnect_fn;
+var _reconnect;
+var EventSource = class extends EventTarget {
+  constructor(url, eventSourceInitDict) {
+    var _a, _b;
+    super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+      var _a2;
+      __privateGet(this, _parser).reset();
+      const { body, redirected, status, headers } = response;
+      if (status === 204) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+        return;
+      }
+      if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+        return;
+      }
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.OPEN);
+      const openEvent = new Event("open");
+      if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+        return;
+      }
+      const decoder = new TextDecoder(), reader = body.getReader();
+      let open = 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);
+    }), __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) => {
+      typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+      const messageEvent = new MessageEvent(event.event || "message", {
+        data: event.data,
+        origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+        lastEventId: event.id || ""
+      });
+      __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+    }), __privateAdd(this, _onRetryChange, (value) => {
+      __privateSet(this, _reconnectInterval, value);
+    }), __privateAdd(this, _reconnect, () => {
+      __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+    });
+    try {
+      if (url instanceof URL)
+        __privateSet(this, _url, url);
+      else if (typeof url == "string")
+        __privateSet(this, _url, new URL(url, getBaseURL()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    __privateSet(this, _parser, createParser({
+      onEvent: __privateGet(this, _onEvent),
+      onRetry: __privateGet(this, _onRetryChange)
+    })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+  }
+  /**
+   * Returns the state of this EventSource object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+   *
+   * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+   * defined in the TypeScript `dom` library.
+   *
+   * @public
+   */
+  get readyState() {
+    return __privateGet(this, _readyState);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return __privateGet(this, _url).href;
+  }
+  /**
+   * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+   */
+  get withCredentials() {
+    return __privateGet(this, _withCredentials);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return __privateGet(this, _onError);
+  }
+  set onerror(value) {
+    __privateSet(this, _onError, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return __privateGet(this, _onMessage);
+  }
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return __privateGet(this, _onOpen);
+  }
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
+  }
+  addEventListener(type, listener, options) {
+    const listen = listener;
+    super.addEventListener(type, listen, options);
+  }
+  removeEventListener(type, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type, listen, options);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+  }
+};
+_readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+connect_fn = function() {
+  __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+getRequestOptions_fn = function() {
+  var _a;
+  const init2 = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
+    cache: "no-store",
+    signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+  };
+  return "window" in globalThis && (init2.credentials = this.withCredentials ? "include" : "same-origin"), init2;
+}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
+* Handles the process referred to in the EventSource specification as "failing a connection".
+*
+* @param error - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+failConnection_fn = function(message, code) {
+  var _a;
+  __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, /**
+* Schedules a reconnection attempt against the EventSource endpoint.
+*
+* @param message - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+scheduleReconnect_fn = function(message, code) {
+  var _a;
+  if (__privateGet(this, _readyState) === this.CLOSED)
+    return;
+  __privateSet(this, _readyState, this.CONNECTING);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+EventSource.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+EventSource.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+EventSource.CLOSED = 2;
+Object.defineProperty(EventSource, /* @__PURE__ */ Symbol.for("eventsource.supports-fetch-override"), {
+  value: true,
+  writable: false,
+  configurable: false,
+  enumerable: false
+});
+function getBaseURL() {
+  const doc = "document" in globalThis ? globalThis.document : void 0;
+  return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+}
+
+// src/session/runner.ts
+import { spawn, spawnSync } from "node:child_process";
+
+// src/session/runner/log.ts
+var claudeBin = () => process.env.BATON_CLAUDE_BIN ?? "claude";
+var buildClaudeArgs = (claudeSessionId, text, resuming) => [
+  "--print",
+  resuming ? "--resume" : "--session-id",
+  claudeSessionId,
+  "--output-format",
+  "stream-json",
+  "--verbose",
+  "--dangerously-skip-permissions",
+  text
+];
+var STDERR_TAIL_BYTES = 2048;
+var tailBuffer = (cap = STDERR_TAIL_BYTES) => {
+  let buf = "";
+  return {
+    append(chunk) {
+      buf = (buf + chunk).slice(-cap);
+    },
+    toString() {
+      return buf;
+    }
+  };
+};
+var maskedEnvKeys = (env) => env ? Object.keys(env).sort().join(", ") : "(none)";
+var previewText = (text, max = 80) => text.length > max ? `${text.slice(0, max)}\u2026` : text;
+
+// src/session/runner/transcript.ts
+import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+var findTranscriptPath = (agentSessionId) => {
+  const root = join3(homedir2(), ".claude", "projects");
+  try {
+    for (const dir of readdirSync(root)) {
+      const candidate = join3(root, dir, `${agentSessionId}.jsonl`);
+      try {
+        if (statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+};
+var isRecord = (v) => typeof v === "object" && v !== null;
+var textOf = (rec) => {
+  const message = rec.message;
+  const content = isRecord(message) ? message.content : rec.content;
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content))
+    return content.filter(isRecord).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+  return "";
+};
+var roleOf = (rec) => rec.type === "user" || rec.type === "assistant" ? rec.type : null;
+var parseFirstExchange = (content) => {
+  let userText = "";
+  let assistantText = "";
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const role = roleOf(parsed);
+    if (!role) continue;
+    const text = textOf(parsed);
+    if (!text) continue;
+    if (role === "user" && !userText) userText = text;
+    else if (role === "assistant" && !assistantText) assistantText = text;
+    if (userText && assistantText) break;
+  }
+  return userText || assistantText ? { userText, assistantText } : null;
+};
+var readFirstExchange = (agentSessionId) => {
+  const path = findTranscriptPath(agentSessionId);
+  if (!path) return null;
+  try {
+    return parseFirstExchange(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+};
+
+// src/session/runner/attachments.ts
+import { createWriteStream } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join as join4 } 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);
+    return name;
+  }
+  const dot = name.lastIndexOf(".");
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const ext = dot > 0 ? name.slice(dot) : "";
+  let n = 1;
+  let candidate = `${stem}-${n}${ext}`;
+  while (taken.has(candidate)) {
+    n += 1;
+    candidate = `${stem}-${n}${ext}`;
+  }
+  taken.add(candidate);
+  return candidate;
+};
+var materializeAttachments = async (opts) => {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const dir = join4(opts.worktreePath, ATTACH_DIR);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join4(dir, ".gitignore"), "*\n", "utf8");
+  const taken = /* @__PURE__ */ new Set([".gitignore"]);
+  const relPaths = [];
+  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(join4(dir, name)));
+    relPaths.push(`${ATTACH_DIR}/${name}`);
+  }
+  return relPaths;
+};
+var augmentPrompt = (text, relPaths) => {
+  if (relPaths.length === 0) return text;
+  const header = [
+    "[Attached files \u2014 already saved in the working directory:]",
+    ...relPaths.map((p) => `- ${p}`)
+  ].join("\n");
+  return text.length > 0 ? `${header}
+
+${text}` : header;
+};
+
+// src/session/runner/spawn.ts
+import { createInterface as createInterface2 } from "node:readline";
+var spawnClaude = async (config, worker2, text, resuming, spawnImpl, log, envOverlay) => {
+  const childEnv = envOverlay ? { ...process.env, ...envOverlay } : process.env;
+  const bin = claudeBin();
+  const args = buildClaudeArgs(config.agentSessionId, text, resuming);
+  log(`[spawn] ${bin} ${args.slice(0, -1).join(" ")} -- "${previewText(text)}"`);
+  log(`[spawn] cwd: ${config.worktreePath}`);
+  log(`[spawn] runtime env keys: ${maskedEnvKeys(envOverlay)}`);
+  let child;
+  try {
+    child = spawnImpl(bin, args, {
+      cwd: config.worktreePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: childEnv
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`[spawn] failed: ${message}`);
+    await worker2.emitEvent("turn_error", { message: `spawn failed: ${message}` });
+    return null;
+  }
+  if (!child.stdout) {
+    log("[spawn] no stdout from claude \u2014 aborting turn");
+    await worker2.emitEvent("turn_error", { message: "no stdout from claude" });
+    return null;
+  }
+  const tail = tailBuffer();
+  if (child.stderr) {
+    const errLines = createInterface2({ input: child.stderr });
+    void (async () => {
+      for await (const line of errLines) {
+        tail.append(`${line}
+`);
+        log(`[claude] ${line}`);
+      }
+    })();
+  }
+  return { child, tail };
+};
+
+// src/session/runner/stream.ts
+import { createInterface as createInterface3 } from "node:readline";
+var streamSdkEvents = async (stdout, worker2) => {
+  const rl = createInterface3({ input: stdout });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let payload;
+    try {
+      payload = JSON.parse(trimmed);
+    } catch {
+      payload = { raw: trimmed };
+    }
+    await worker2.emitEvent("sdk_event", payload);
+  }
+};
+
+// src/session/runner/turn.ts
+var finalizeTurn = async (child, tail, worker2, log) => {
+  const exitCode = await new Promise(
+    (resolve) => child.once("exit", (code) => resolve(code ?? -1))
+  );
+  log(`[exit] code=${exitCode}`);
+  const stderrTail = tail.toString();
+  if (exitCode !== 0) {
+    await worker2.emitEvent("turn_error", {
+      message: `claude exited with code ${exitCode}`,
+      exitCode,
+      stderrTail
+    });
+  }
+  await worker2.emitEvent("turn_complete", {
+    exitCode,
+    ...stderrTail ? { stderrTail } : {}
+  });
+  return exitCode;
+};
+var runTurn = async (config, worker2, msg, resuming, spawnImpl, log = (m) => console.log(m), envOverlay, fetchImpl) => {
+  await worker2.emitEvent("turn_start", { messageId: msg.id });
+  const payload = msg.payload;
+  const rawText = typeof payload?.text === "string" ? payload.text : "";
+  const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+  if (rawText.length === 0 && attachments.length === 0) {
+    await worker2.emitEvent("turn_error", { message: "user_message missing text and attachments" });
+    return -1;
+  }
+  let text = rawText;
+  if (attachments.length > 0) {
+    try {
+      const relPaths = await materializeAttachments({
+        worktreePath: config.worktreePath,
+        serverBase: config.server,
+        attachments,
+        fetchImpl
+      });
+      log(`[attach] downloaded ${relPaths.length} file(s) \u2192 ${config.worktreePath}/attachments`);
+      text = augmentPrompt(rawText, relPaths);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await worker2.emitEvent("turn_error", { message: `attachment download failed: ${message}` });
+      return -1;
+    }
+  }
+  const result = await spawnClaude(config, worker2, text, resuming, spawnImpl, log, envOverlay);
+  if (!result) return -1;
+  try {
+    await streamSdkEvents(result.child.stdout, worker2);
+    return await finalizeTurn(result.child, result.tail, worker2, log);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`[run] ${message}`);
+    await worker2.emitEvent("turn_error", { message, stderrTail: result.tail.toString() });
+    return -1;
+  }
+};
+
+// src/session/runner.ts
+var subscribeStream = (url, ESCtor, seen, log, onUserMessage, onReady) => {
+  const es = new ESCtor(url);
+  es.onopen = onReady;
+  es.onmessage = (e) => {
+    try {
+      const ev = JSON.parse(e.data);
+      if (seen.has(ev.sequence)) return;
+      seen.add(ev.sequence);
+      if (ev.type === "user_message") onUserMessage(ev);
+    } catch {
+    }
+  };
+  es.onerror = () => log("sse error (eventsource will retry)");
+  return es;
+};
+var waitForAbort = (signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  signal.addEventListener("abort", () => resolve(), { once: true });
+});
+var shouldReap = (lastActivity, now, busy, queueLen, idleMs) => !busy && queueLen === 0 && now - lastActivity >= idleMs;
+var idleMsFromEnv = () => Number(process.env.BATON_SESSION_IDLE_MS) || 30 * 6e4;
+var restoreTty = () => {
+  if (!process.stdout.isTTY) return;
+  try {
+    spawnSync("reset", { stdio: "inherit" });
+  } catch {
+  }
+};
+var runDaemon = async (config, deps, signal) => {
+  const log = deps.log ?? ((m) => console.log(`[#${config.sessionId} ${config.name}] ${m}`));
+  const sp = deps.spawnImpl ?? spawn;
+  const ESCtor = deps.eventSourceImpl ?? EventSource;
+  log(`bin: ${claudeBin()}  cwd: ${config.worktreePath}`);
+  log(`runtime env keys: ${maskedEnvKeys(deps.env)}`);
+  const state = {
+    firstSpawnDone: findTranscriptPath(config.agentSessionId) !== null,
+    seen: /* @__PURE__ */ new Set()
+  };
+  const pendingQueue = [];
+  let busy = false;
+  let lastActivity = Date.now();
+  const drain = async () => {
+    if (busy) return;
+    busy = true;
+    try {
+      while (pendingQueue.length > 0 && !signal.aborted) {
+        const msg = pendingQueue.shift();
+        if (!msg) break;
+        const resuming = state.firstSpawnDone;
+        log(`\u25B6 msg #${msg.sequence} (${resuming ? "resume" : "first"})`);
+        const code = await runTurn(
+          config,
+          deps.worker,
+          msg,
+          resuming,
+          sp,
+          log,
+          deps.env,
+          deps.fetchImpl
+        );
+        state.firstSpawnDone = true;
+        lastActivity = Date.now();
+        log(`\u2714 msg #${msg.sequence}${code === 0 ? "" : ` (exit ${code})`}`);
+      }
+    } finally {
+      busy = false;
+    }
+  };
+  const es = subscribeStream(
+    // live-only: the server now replays history to viewers, but the child must
+    // not re-receive (and re-run) past user_messages on connect/resume.
+    `${config.server}/sessions/${config.sessionId}/stream?live=1`,
+    ESCtor,
+    state.seen,
+    log,
+    (ev) => {
+      lastActivity = Date.now();
+      pendingQueue.push(ev);
+      void drain();
+    },
+    // Report active only now that we're subscribed — before this, a message
+    // sent right after spawn would be missed (no replay on the live stream).
+    () => {
+      void deps.worker.setActive(true).then(() => log("\u25B2 active (subscribed)")).catch((e) => log(`status(active) failed: ${String(e)}`));
+    }
+  );
+  const idleMs = idleMsFromEnv();
+  let idleTimer;
+  const reaped = new Promise((resolve) => {
+    idleTimer = setInterval(
+      () => {
+        if (shouldReap(lastActivity, Date.now(), busy, pendingQueue.length, idleMs)) {
+          log("idle \u2014 shutting down (resumes on next message)");
+          resolve();
+        }
+      },
+      Math.min(idleMs, 3e4)
+    );
+  });
+  await Promise.race([waitForAbort(signal), reaped]);
+  if (idleTimer) clearInterval(idleTimer);
+  es.close();
+  restoreTty();
+};
+
+// src/commands/session/run.ts
+var bearerFetch = (token) => (input, init2) => fetch(input, {
+  ...init2,
+  headers: {
+    ...init2?.headers,
+    authorization: `Bearer ${token}`
+  }
+});
+var authedEventSource = (token) => class extends EventSource {
+  constructor(url) {
+    super(url, {
+      fetch: (u, init2) => fetch(u, {
+        ...init2,
+        headers: {
+          ...init2?.headers,
+          authorization: `Bearer ${token}`
+        }
+      })
+    });
+  }
+};
+var sessionRunCommand = defineCommand({
+  meta: { name: "run", description: "run a session child (spawned by the worker daemon)" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id" }
+  },
+  run: async ({ args }) => {
+    const server = process.env.BATON_SERVER;
+    const workerToken = process.env.BATON_WORKER_TOKEN;
+    if (!server || !workerToken)
+      throw new Error("`session run` must be spawned by the worker daemon (missing BATON_* env)");
+    const sessionId = Number(args.session);
+    if (!Number.isInteger(sessionId) || sessionId <= 0)
+      throw new Error(`invalid session id: ${args.session}`);
+    const client = createClient(server, { bearer: workerToken });
+    const s = await client.sessions.get(sessionId);
+    if (!s.agentSessionId || !s.worktreePath)
+      throw new Error(`session #${sessionId} is not materialized yet`);
+    const config = {
+      server,
+      sessionId,
+      name: s.name,
+      agentSessionId: s.agentSessionId,
+      worktreePath: s.worktreePath
+    };
+    const worker2 = createWorkerClient(server, workerToken, sessionId);
+    const ac = new AbortController();
+    const stop = () => ac.abort();
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    await runDaemon(
+      config,
+      {
+        worker: worker2,
+        eventSourceImpl: authedEventSource(workerToken),
+        fetchImpl: bearerFetch(workerToken)
+      },
+      ac.signal
+    );
+  }
+});
+
+// src/commands/attach.ts
+import { openAsBlob } from "node:fs";
+import { basename } from "node:path";
+
+// src/mime.ts
+import { extname } from "node:path";
+var BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv"
+};
+var contentTypeForPath = (path) => BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
+
+// src/commands/attach.ts
+var attachPaths = (raw) => (raw === void 0 ? [] : Array.isArray(raw) ? raw : [raw]).flatMap((p) => p.split(",")).map((p) => p.trim()).filter(Boolean);
+var uploadAttachments = async (client, sessionId, paths) => {
+  const out = [];
+  for (const path of paths) {
+    const body = await openAsBlob(path, { type: contentTypeForPath(path) });
+    out.push(
+      await client.sessions.uploadAttachment(sessionId, {
+        filename: basename(path),
+        contentType: contentTypeForPath(path),
+        body
+      })
+    );
+  }
+  return out;
+};
+
+// src/commands/session/send.ts
+var sessionSendCommand = defineCommand({
+  meta: { name: "send", description: "post a chat message into a session (no streaming reply)" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    text: { type: "positional", required: false, description: "message text" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    attach: {
+      type: "string",
+      description: "file(s) to attach; repeat or comma-separate (e.g. --attach a.png,b.pdf)"
+    },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const projectId = resolveProjectId(args);
+    const s = await resolveSession(c, projectId, args.session);
+    const paths = attachPaths(args.attach);
+    const text = args.text ?? "";
+    if (text.length === 0 && paths.length === 0)
+      throw new Error("nothing to send: provide message text and/or --attach <file>");
+    const attachments = paths.length > 0 ? await uploadAttachments(c, s.id, paths) : void 0;
+    const ev = await c.sessions.sendMessage(s.id, text, attachments);
+    if (args.json) console.log(toJson(ev));
+    else {
+      const note = attachments ? ` +${attachments.length} attachment(s)` : "";
+      console.log(`sent (seq ${ev.sequence}) \u2192 ${s.name} (#${s.id})${note}: ${text}`);
+    }
+  }
+});
+
+// src/commands/session/stop.ts
+var sessionStopCommand = defineCommand({
+  meta: { name: "stop", description: "stop a session (keeps it; resume to restart)" },
+  args: {
+    session: { type: "positional", required: true, description: "session int id or name" },
+    project: { type: "string", description: "project id (overrides .baton.json)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const handle = await resolveSession(c, resolveProjectId(args), args.session);
+    const s = await c.sessions.stop(handle.id);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session.ts
+var session = defineCommand({
+  meta: { name: "session", description: "create / resume / stop / send to agent sessions" },
+  subCommands: {
+    create: sessionCreateCommand,
+    resume: sessionResumeCommand,
+    stop: sessionStopCommand,
+    rename: sessionRenameCommand,
+    rm: sessionRmCommand,
+    send: sessionSendCommand,
+    ls: sessionLsCommand,
+    get: sessionGetCommand,
+    run: sessionRunCommand
+  }
+});
+
+// src/commands/task.ts
+var createTask = (c, input, json) => c.tasks.create(input).then((t) => renderOne(t, fmtTask, json));
+var listTasks = (c, requirementId, json) => c.tasks.listByRequirement(requirementId).then((ts) => renderList(ts, fmtTask, json));
+var getTask = (c, id, json) => c.tasks.get(id).then((t) => renderOne(t, fmtTask, json));
+var setTaskStatus = (c, id, status, json) => c.tasks.setStatus(id, status).then((t) => renderOne(t, fmtTask, json));
+var removeTask = (c, id, label, json) => c.tasks.remove(id).then(() => removed("task", label, json));
+var addTaskComment = (c, taskId, body, workerId, json) => c.tasks.addComment(taskId, body, workerId).then((x) => renderOne(x, fmtComment, json));
+var listTaskComments = (c, taskId, json) => c.tasks.listComments(taskId).then((xs) => renderList(xs, fmtComment, json));
+var resolveReqByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
+var resolveTaskByCode = async (c, projectId, code) => (await c.tasks.getByCode(projectId, code)).id;
+var task = defineCommand({
+  meta: { name: "task", description: "manage tasks" },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "create a task" },
+      args: {
+        title: { type: "positional", required: true },
+        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        body: { type: "string", description: "task body (markdown)" },
+        deps: { type: "string", description: "comma-separated dependency task codes (T-N,T-N)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const projectId = resolveProjectId(args);
+        const requirementId = await resolveReqByCode(c, projectId, args.requirement);
+        const depCodes = splitCsv(args.deps) ?? [];
+        const dependsOn = await Promise.all(
+          depCodes.map((code) => resolveTaskByCode(c, projectId, code))
+        );
+        console.log(
+          await createTask(
+            c,
+            {
+              requirementId,
+              title: args.title,
+              body: args.body,
+              dependsOn: dependsOn.length ? dependsOn : void 0
+            },
+            Boolean(args.json)
+          )
+        );
+      }
+    }),
+    ls: defineCommand({
+      meta: { name: "ls", description: "list tasks in a requirement" },
+      args: {
+        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const reqId = await resolveReqByCode(c, resolveProjectId(args), args.requirement);
+        console.log(await listTasks(c, reqId, Boolean(args.json)));
+      }
+    }),
+    get: defineCommand({
+      meta: { name: "get", description: "get a task by code (T-N)" },
+      args: {
+        code: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
+        console.log(await getTask(c, id, Boolean(args.json)));
+      }
+    }),
+    "set-status": defineCommand({
+      meta: {
+        name: "set-status",
+        description: "set task status (todo|in_progress|done|failed|cancelled)"
+      },
+      args: {
+        code: { type: "positional", required: true, description: "task code (T-N)" },
+        status: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
+        console.log(await setTaskStatus(c, id, args.status, Boolean(args.json)));
+      }
+    }),
+    rm: defineCommand({
+      meta: { name: "rm", description: "delete a task by code" },
+      args: {
+        code: { type: "positional", required: true },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
+        console.log(await removeTask(c, id, args.code, Boolean(args.json)));
+      }
+    }),
+    comment: defineCommand({
+      meta: { name: "comment", description: "append-only task comments" },
+      subCommands: {
+        add: defineCommand({
+          meta: { name: "add", description: "add a comment to a task" },
+          args: {
+            code: { type: "positional", required: true, description: "task code (T-N)" },
+            body: { type: "positional", required: true, description: "comment text (markdown)" },
+            worker: { type: "string", description: "attribute to a worker id (omit = human)" },
+            project: { type: "string", description: "project id (overrides .baton.json)" },
+            ...common
+          },
+          run: async ({ args }) => {
+            const c = clientFor(args);
+            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
+            const workerId = args.worker ? Number(args.worker) : void 0;
+            console.log(await addTaskComment(c, id, args.body, workerId, Boolean(args.json)));
+          }
+        }),
+        ls: defineCommand({
+          meta: { name: "ls", description: "list a task\u2019s comments in order" },
+          args: {
+            code: { type: "positional", required: true, description: "task code (T-N)" },
+            project: { type: "string", description: "project id (overrides .baton.json)" },
+            ...common
+          },
+          run: async ({ args }) => {
+            const c = clientFor(args);
+            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
+            console.log(await listTaskComments(c, id, Boolean(args.json)));
+          }
+        })
+      }
+    })
+  }
+});
+
+// src/commands/worker.ts
+import { hostname as osHostname } from "node:os";
+
+// src/worker/daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/session/runner/title.ts
+var clip = (s, max) => s.length > max ? s.slice(0, max) : s;
+var isDeclined = (title) => title.replace(/[^a-z]/gi, "").toUpperCase() === "NONE";
+var sanitizeTitle = (raw) => raw.replace(/[\r\n]+/g, " ").replace(/["'`]/g, "").replace(/^\s*(title|session)\s*[:-]\s*/i, "").replace(/\s+/g, " ").trim().slice(0, 40).trim();
+var TITLE_TIMEOUT_MS = 3e4;
+var generateTitle = async (input) => {
+  const { worktreePath, userText, assistantText, spawnImpl } = input;
+  if (`${userText}${assistantText}`.trim().length < 4) return null;
+  const exchange = [
+    `User: ${clip(userText, 800)}`,
+    assistantText ? `Assistant: ${clip(assistantText, 800)}` : ""
+  ].filter(Boolean).join("\n");
+  const prompt = `Reply with ONLY a 2-5 word title (no quotes, no punctuation) summarizing this coding session. If it is too short or generic to title meaningfully, reply with exactly NONE:
+${exchange}`;
+  const out = await new Promise((resolve) => {
+    let buf = "";
+    let done = false;
+    const finish = (s) => {
+      if (!done) {
+        done = true;
+        resolve(s);
+      }
+    };
+    let child;
+    try {
+      child = spawnImpl(claudeBin(), ["--print", "--dangerously-skip-permissions", prompt], {
+        cwd: worktreePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env
+      });
+    } catch {
+      return finish("");
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      finish("");
+    }, TITLE_TIMEOUT_MS);
+    child.stdout?.on("data", (d) => {
+      buf += String(d);
+    });
+    child.on("exit", () => {
+      clearTimeout(timer);
+      finish(buf);
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      finish("");
+    });
+  });
+  const title = sanitizeTitle(out);
+  return !title || isDeclined(title) ? null : title;
+};
+
+// src/session/worktree.ts
+import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+var createWorktree = (input) => {
+  if (existsSync3(input.worktreePath))
+    throw new Error(`worktree path already exists: ${input.worktreePath}`);
+  mkdirSync(dirname(input.worktreePath), { recursive: true });
+  const branch = `baton/${input.sessionCode}`;
+  const r = spawnSync2(
+    "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 = spawnSync2("git", ["-C", repo, "symbolic-ref", "--short", "HEAD"], {
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  const branch = r.status === 0 ? r.stdout.trim() : "";
+  return branch || "main";
+};
+var removeWorktree = (repo, worktreePath) => {
+  if (!existsSync3(worktreePath)) return;
+  try {
+    execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktreePath], {
+      stdio: "pipe"
+    });
+  } catch {
+  }
+};
+
+// src/worker/daemon.ts
+var binPath = () => {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const devShim = join5(here, "..", "..", "bin", "baton.mjs");
+  return existsSync4(devShim) ? devShim : fileURLToPath(import.meta.url);
+};
+var runWorkerDaemon = async (cfg, client, signal) => {
+  const repo = process.cwd();
+  const worktreeDir = defaultWorktreeDir();
+  const children = /* @__PURE__ */ new Map();
+  const log = (m) => console.log(`[worker #${cfg.workerId} ${cfg.name}] ${m}`);
+  const ping = () => {
+    void client.workers.heartbeat(cfg.machineId).catch((e) => log(`heartbeat failed: ${String(e)}`));
+  };
+  ping();
+  const hb = setInterval(ping, 3e4);
+  const killChild = (child) => {
+    if (child.pid === void 0) return;
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+    }
+  };
+  const spawnChild = (sessionId, worktreePath) => {
+    if (children.has(sessionId)) return;
+    const child = spawn2(process.execPath, [binPath(), "session", "run", String(sessionId)], {
+      detached: true,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        BATON_SERVER: cfg.server,
+        BATON_WORKER_TOKEN: cfg.apiToken
+      }
+    });
+    children.set(sessionId, { child, worktreePath });
+    log(`spawned session #${sessionId} (${worktreePath})`);
+    child.on("exit", (code) => {
+      children.delete(sessionId);
+      log(`session #${sessionId} child exited (code=${code ?? -1})`);
+      void client.sessions.setStatus(sessionId, false, cfg.apiToken).catch(() => {
+      });
+    });
+  };
+  const onStart = async (sessionId, name) => {
+    if (children.has(sessionId)) return log(`session #${sessionId} already running`);
+    const session2 = await client.sessions.get(sessionId);
+    let worktreePath = session2.worktreePath;
+    if (!session2.agentSessionId || !worktreePath) {
+      const agentSessionId = randomUUID();
+      worktreePath = join5(worktreeDir, slug(`${name}-${agentSessionId.slice(0, 8)}`));
+      createWorktree({
+        repo,
+        worktreePath,
+        sessionCode: agentSessionId.slice(0, 8),
+        base: repoHeadBranch(repo)
+      });
+      await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
+      log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
+    }
+    spawnChild(sessionId, worktreePath);
+  };
+  const onStop = (sessionId) => {
+    const entry = children.get(sessionId);
+    if (!entry) return;
+    killChild(entry.child);
+    children.delete(sessionId);
+    log(`stopped session #${sessionId}`);
+  };
+  const onDelete = (sessionId, worktreePath) => {
+    const entry = children.get(sessionId);
+    if (entry) {
+      killChild(entry.child);
+      children.delete(sessionId);
+    }
+    const wt = entry?.worktreePath ?? worktreePath;
+    if (wt) removeWorktree(repo, wt);
+    log(`deleted session #${sessionId} (removed worktree)`);
+  };
+  const onTitle = async (sessionId, agentSessionId, worktreePath) => {
+    const exchange = readFirstExchange(agentSessionId);
+    if (!exchange) return log(`title #${sessionId}: no transcript yet, skipping`);
+    const title = await generateTitle({
+      worktreePath,
+      userText: exchange.userText,
+      assistantText: exchange.assistantText,
+      spawnImpl: spawn2
+    });
+    if (!title) return log(`title #${sessionId}: not enough to title yet, skipping`);
+    await client.sessions.setName(sessionId, title, cfg.apiToken);
+    log(`\u270E titled session #${sessionId} \u2192 ${title}`);
+  };
+  const reconcile = async () => {
+    const owned = (await client.sessions.listByProject(cfg.projectId)).filter(
+      (s) => s.workerId === cfg.workerId
+    );
+    const live = new Set(owned.map((s) => s.id));
+    for (const [sid, entry] of children) {
+      if (!live.has(sid)) {
+        killChild(entry.child);
+        children.delete(sid);
+        log(`reconcile: stopped orphan session #${sid}`);
+      }
+    }
+  };
+  const es = new EventSource(`${cfg.server}/workers/me/stream`, {
+    fetch: (url, init2) => fetch(url, {
+      ...init2,
+      headers: {
+        ...init2?.headers,
+        authorization: `Bearer ${cfg.apiToken}`
+      }
+    })
+  });
+  es.onopen = () => void reconcile().catch((err) => log(`reconcile failed: ${String(err)}`));
+  es.onmessage = (e) => {
+    try {
+      const cmd = JSON.parse(e.data);
+      if (cmd.cmd === "session.start")
+        void onStart(cmd.sessionId, cmd.name).catch((err) => log(`start failed: ${String(err)}`));
+      else if (cmd.cmd === "session.stop") onStop(cmd.sessionId);
+      else if (cmd.cmd === "session.delete") onDelete(cmd.sessionId, cmd.worktreePath);
+      else if (cmd.cmd === "session.title")
+        void onTitle(cmd.sessionId, cmd.agentSessionId, cmd.worktreePath).catch(
+          (err) => log(`title failed: ${String(err)}`)
+        );
+    } catch {
+    }
+  };
+  es.onerror = () => log("command stream error (eventsource will retry)");
+  log(`listening for commands (server ${cfg.server}, repo ${repo})`);
+  await new Promise((resolve) => {
+    if (signal.aborted) return resolve();
+    signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+  es.close();
+  clearInterval(hb);
+  for (const { child } of children.values()) killChild(child);
+};
+
+// src/worker/machine-id.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
+var machineIdPath = (env = process.env) => join6(env.XDG_DATA_HOME ?? join6(env.HOME ?? homedir3(), ".local/share"), "baton", "machine-id");
+var readOrCreateMachineId = (path = machineIdPath()) => {
+  if (existsSync5(path)) {
+    const s = readFileSync3(path, "utf8").trim();
+    if (s) return s;
+  }
+  const id = randomUUID2();
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(path, `${id}
+`, "utf8");
+  return id;
+};
+
+// src/commands/worker.ts
+var resolveWorker = async (client, projectId, handle) => {
+  const asInt = Number(handle);
+  if (Number.isInteger(asInt) && asInt > 0) {
+    const byId = await client.workers.get(asInt).catch(() => null);
+    if (byId) return { id: byId.id, name: byId.name };
+  }
+  const byName = await client.workers.findByName(projectId, handle);
+  if (byName) return { id: byName.id, name: byName.name };
+  throw new Error(`worker "${handle}" not found in project ${projectId}`);
+};
+var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
+  const out = await client.workers.register({
+    projectId: input.projectId,
+    machineId: input.machineId,
+    name: input.name,
+    hostname: input.hostname
+  });
+  try {
+    loadProjectConfig(cfgPath);
+  } catch {
+    saveProjectConfig(cfgPath, { server: input.server, project: input.projectId });
+  }
+  setWorker(cfgPath, {
+    id: out.worker.id,
+    name: out.worker.name,
+    machineId: out.worker.machineId,
+    apiToken: out.apiToken
+  });
+  return { out, configPath: cfgPath };
+};
+var worker = defineCommand({
+  meta: { name: "worker", description: "register / inspect / close workers for a project" },
+  subCommands: {
+    register: defineCommand({
+      meta: {
+        name: "register",
+        description: "register this machine as a worker for a project (idempotent)"
+      },
+      args: {
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        name: { type: "string", description: "worker display name (default: hostname)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const server = resolveBaseUrl(args.url);
+        const c = clientFor(args);
+        const hostname = osHostname();
+        const machineId = readOrCreateMachineId();
+        const name = args.name ?? hostname;
+        const { out, configPath } = await registerWorker(c, {
+          projectId: resolveProjectId(args),
+          name,
+          server,
+          hostname,
+          machineId
+        });
+        if (args.json) {
+          console.log(toJson({ ...out, configPath, machineIdPath: machineIdPath() }));
+          return;
+        }
+        console.log(`worker #${out.worker.id} (${out.worker.name}) \u2014 ${out.outcome}`);
+        console.log(`  hostname:       ${out.worker.hostname}`);
+        console.log(`  machineId:      ${out.worker.machineId}`);
+        console.log(`  machineId file: ${machineIdPath()}`);
+        console.log(`  config saved:   ${configPath}`);
+      }
+    }),
+    run: defineCommand({
+      meta: {
+        name: "run",
+        description: "run the persistent worker daemon (listens for session create/delete commands)"
+      },
+      args: { ...common },
+      run: async () => {
+        const cfg = viewWorker(loadProjectConfig(projectConfigPath()));
+        const client = createClient(cfg.server, { bearer: cfg.apiToken });
+        const ac = new AbortController();
+        const stop = () => ac.abort();
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        await runWorkerDaemon(cfg, client, ac.signal);
+      }
+    }),
+    ls: defineCommand({
+      meta: { name: "ls", description: "list workers in a project" },
+      args: {
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const ws = await c.workers.listByProject(resolveProjectId(args));
+        console.log(renderList(ws, fmtWorker, Boolean(args.json)));
+      }
+    }),
+    get: defineCommand({
+      meta: { name: "get", description: "get a worker by int id or name" },
+      args: {
+        worker: { type: "positional", required: true, description: "worker int id or name" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const projectId = resolveProjectId(args);
+        const handle = await resolveWorker(c, projectId, args.worker);
+        const w = await c.workers.get(handle.id);
+        console.log(renderOne(w, fmtWorker, Boolean(args.json)));
+      }
+    }),
+    destroy: defineCommand({
+      meta: {
+        name: "destroy",
+        description: "permanently delete a worker and its sessions (irreversible)"
+      },
+      args: {
+        worker: { type: "positional", required: true, description: "worker int id or name" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        confirm: { type: "boolean", description: "actually perform the deletion" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const projectId = resolveProjectId(args);
+        const handle = await resolveWorker(c, projectId, args.worker);
+        const sessions = (await c.sessions.listByProject(projectId)).filter(
+          (s) => s.workerId === handle.id
+        );
+        if (!args.confirm) {
+          console.log(`[dry-run] would destroy worker ${handle.name} (#${handle.id}):`);
+          console.log(`  - ${sessions.length} session(s) cascade-deleted`);
+          console.log("  - browser-local event history: NOT touched");
+          console.log("re-run with --confirm to proceed.");
+          return;
+        }
+        await c.workers.destroy(handle.id);
+        console.log(
+          `destroyed worker ${handle.name} (#${handle.id}); ${sessions.length} session(s) gone`
+        );
+      }
+    }),
+    whoami: defineCommand({
+      meta: { name: "whoami", description: "show local worker config from .baton.json" },
+      args: { ...common },
+      run: ({ args }) => {
+        const cfg = (() => {
+          try {
+            return loadProjectConfig(projectConfigPath());
+          } catch {
+            return null;
+          }
+        })();
+        const worker2 = cfg?.worker;
+        if (!worker2) {
+          console.log("(no worker registered for this project \u2014 run `baton worker register`)");
+          return;
+        }
+        if (args.json) {
+          console.log(toJson({ ...worker2, server: cfg?.server, projectId: cfg?.project }));
+          return;
+        }
+        console.log(`worker #${worker2.id} (${worker2.name})`);
+        console.log(`  machineId: ${worker2.machineId}`);
+        console.log(`  server:    ${cfg?.server}`);
+      }
+    })
+  }
+});
+
+// src/commands/workspace.ts
+var createWorkspace = (c, name, json) => c.workspaces.create({ name }).then((w) => renderOne(w, fmtWorkspace, json));
+var listWorkspaces = (c, json) => c.workspaces.list().then((ws) => renderList(ws, fmtWorkspace, json));
+var getWorkspace = (c, id, json) => c.workspaces.get(id).then((w) => renderOne(w, fmtWorkspace, json));
+var updateWorkspace = (c, id, name, json) => c.workspaces.update(id, { name }).then((w) => renderOne(w, fmtWorkspace, json));
+var removeWorkspace = (c, id, json) => c.workspaces.remove(id).then(() => removed("workspace", id, json));
+var workspace = defineCommand({
+  meta: { name: "workspace", description: "manage workspaces" },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "create a workspace" },
+      args: {
+        name: { type: "positional", required: true, description: "workspace name" },
+        ...common
+      },
+      run: async ({ args }) => {
+        console.log(await createWorkspace(clientFor(args), args.name, Boolean(args.json)));
+      }
+    }),
+    ls: defineCommand({
+      meta: { name: "ls", description: "list workspaces" },
+      args: { ...common },
+      run: async ({ args }) => {
+        console.log(await listWorkspaces(clientFor(args), Boolean(args.json)));
+      }
+    }),
+    get: defineCommand({
+      meta: { name: "get", description: "get a workspace" },
+      args: { id: { type: "positional", required: true }, ...common },
+      run: async ({ args }) => {
+        console.log(await getWorkspace(clientFor(args), Number(args.id), Boolean(args.json)));
+      }
+    }),
+    update: defineCommand({
+      meta: { name: "update", description: "rename a workspace" },
+      args: {
+        id: { type: "positional", required: true },
+        name: { type: "string", description: "new name" },
+        ...common
+      },
+      run: async ({ args }) => {
+        if (!args.name) throw new Error("pass --name <new name>");
+        console.log(
+          await updateWorkspace(clientFor(args), Number(args.id), args.name, Boolean(args.json))
+        );
+      }
+    }),
+    rm: defineCommand({
+      meta: { name: "rm", description: "delete a workspace" },
+      args: { id: { type: "positional", required: true }, ...common },
+      run: async ({ args }) => {
+        console.log(await removeWorkspace(clientFor(args), Number(args.id), Boolean(args.json)));
+      }
+    })
+  }
+});
+
+// src/index.ts
+var main = defineCommand({
+  meta: {
+    name: "baton",
+    description: "baton \u2014 run a worker daemon; manage projects / requirements / tasks / sessions"
+  },
+  // Order matters: high-level verbs first so --help shows them on top.
+  subCommands: {
+    init,
+    worker,
+    session,
+    workspace,
+    project,
+    requirement,
+    task
+  }
+});
+runMain(main);