@lesscap/baton-cli 0.2.12 → 0.2.13

package/dist/baton.mjs

@@ -691,7 +691,8 @@ var createWorkerClient = (baseUrl, workerToken, sessionId) => {
       method: "POST",
       body: { active },
       headers: auth
-    })
+    }),
+    listEvents: () => request(u(`/sessions/${sessionId}/events`), { method: "GET", headers: auth })
   };
 };
 
@@ -956,331 +957,56 @@ var project = defineCommand({
   }
 });
 
-// src/commands/requirement.ts
-var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
-var updateRequirement = (c, id, patch2, json) => c.requirements.update(id, patch2).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)
-          )
-        );
-      }
-    }),
-    update: defineCommand({
-      meta: { name: "update", description: "update a requirement title / body" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code (R-N)" },
-        title: { type: "string", description: "new title" },
-        body: { type: "string", description: "new body (markdown)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const patch2 = {
-          ...args.title !== void 0 ? { title: args.title } : {},
-          ...args.body !== void 0 ? { body: args.body } : {}
-        };
-        if (Object.keys(patch2).length === 0) throw new Error("pass --title and/or --body");
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateRequirement(c, id, patch2, 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/shared.ts
-import { homedir } from "node:os";
+// src/commands/relay.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir } 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/abort.ts
-var sessionAbortCommand = defineCommand({
-  meta: {
-    name: "abort",
-    description: "interrupt the in-flight turn (like Esc); keeps the 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.abort(handle.id);
-    console.log(renderOne(s, fmtSession, Boolean(args.json)));
-  }
-});
 
-// src/commands/session/clear.ts
-var sessionClearCommand = defineCommand({
-  meta: {
-    name: "clear",
-    description: "reset the conversation context (keeps the session + worktree)"
-  },
-  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.clear(handle.id);
-    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+// ../../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;
   }
-});
-
-// 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 handle: W-N or int id (default: this machine's worker)"
-    },
-    project: {
-      type: "string",
-      description: "project id (default: the worker's own project, else .baton.json)"
-    },
-    ...common
-  },
-  run: async ({ args }) => {
-    const c = clientFor(args);
-    const workerId = args.worker ? parseWorkerHandle(args.worker) : loadProjectConfigOrNull(projectConfigPath())?.worker?.id ?? null;
-    if (workerId === null)
+};
+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(
-        "no worker \u2014 pass --worker <W-N|id> or run `baton worker register` first (names need --project)"
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
       );
-    const projectId = args.project !== void 0 && args.project !== "" ? Number(args.project) : args.worker ? (await c.workers.get(workerId)).projectId : resolveProjectId(args);
-    const s = await c.sessions.create({ projectId, workerId, name: args.name });
-    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+    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();
   }
-});
-
-// 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 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;
@@ -1608,117 +1334,595 @@ var EventSource = class extends EventTarget {
   get onmessage() {
     return __privateGet(this, _onMessage);
   }
-  set onmessage(value) {
-    __privateSet(this, _onMessage, value);
+  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/client/relay.ts
+var relayClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  const authed = (token) => ({ authorization: `Bearer ${token}` });
+  return {
+    create: async () => {
+      const res = await fetch(u("/relay/channels"), { method: "POST" });
+      if (!res.ok) throw new Error(`POST /relay/channels \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    send: async (channelId, token, msg) => {
+      const res = await fetch(u(`/relay/channels/${channelId}/messages`), {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authed(token) },
+        body: JSON.stringify(msg)
+      });
+      if (!res.ok) throw new Error(`POST relay message \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    listen: (channelId, token, opts) => {
+      let cursor = opts.since ?? 0;
+      const es = new EventSource(u(`/relay/channels/${channelId}/stream?since=${cursor}`), {
+        fetch: (url, init2) => fetch(url, {
+          ...init2,
+          headers: { ...init2?.headers, ...authed(token) }
+        })
+      });
+      es.onmessage = (e) => {
+        try {
+          const m = JSON.parse(e.data);
+          if (m.seq <= cursor) return;
+          cursor = m.seq;
+          opts.onMessage(m);
+        } catch (err) {
+          opts.onError?.(err);
+        }
+      };
+      es.onerror = (err) => opts.onError?.(err);
+      return () => es.close();
+    }
+  };
+};
+
+// src/commands/relay.ts
+var PREVIEW = 280;
+var readStdin = async () => {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+};
+var inviteBlock = (url, channelId, token) => [
+  "\u2500\u2500 Copy everything below to your peer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+  "You're invited to a live Claude\u2194Claude channel. Use the `hotline` skill in",
+  "join mode, or run these two commands directly (pick your own NAME):",
+  "",
+  `  baton relay listen ${channelId} --token ${token} --from NAME --url ${url}`,
+  `  baton relay send   ${channelId} --token ${token} --from NAME --text "..." --url ${url}`,
+  "",
+  `connection: url=${url} channel=${channelId} token=${token}`,
+  "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+].join("\n");
+var hostCommand = defineCommand({
+  meta: { name: "host", description: "open a relay channel and print an invite for a peer" },
+  args: {
+    name: { type: "string", description: "your participant name (default: host)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const url = resolveBaseUrl(args.url);
+    const { channelId, token } = await relayClient(url).create();
+    if (args.json) {
+      console.log(toJson({ channelId, token, url, host: args.name ?? "host" }));
+      return;
+    }
+    console.log(`channel ${channelId} opened
+`);
+    console.log(inviteBlock(url, channelId, token));
+  }
+});
+var sendCommand = defineCommand({
+  meta: { name: "send", description: "post one message to a relay channel" },
+  args: {
+    channel: { type: "positional", required: true, description: "channel id" },
+    text: { type: "positional", required: false, description: "message text (short one-liner)" },
+    token: { type: "string", required: true, description: "channel token" },
+    from: { type: "string", description: "your participant name (default: peer)" },
+    file: { type: "string", description: "read message body from this file (for large content)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const url = resolveBaseUrl(args.url);
+    let text = args.text;
+    if (text === void 0 && args.file) text = readFileSync2(args.file, "utf8");
+    if (text === void 0 && !process.stdin.isTTY) text = await readStdin();
+    if (text === void 0 || text === "")
+      throw new Error("nothing to send: provide text, --file <path>, or pipe stdin");
+    const msg = await relayClient(url).send(args.channel, args.token, {
+      from: args.from ?? "peer",
+      text
+    });
+    if (args.json) console.log(toJson(msg));
+    else console.log(`sent (seq ${msg.seq})`);
+  }
+});
+var listenCommand = defineCommand({
+  meta: {
+    name: "listen",
+    description: "stream a channel: one JSON line per peer message (for a background subscriber)"
+  },
+  args: {
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
+    from: {
+      type: "string",
+      description: "your name; messages from this name are skipped (no echo)"
+    },
+    since: { type: "string", description: "replay messages after this seq (default 0 = full)" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const url = resolveBaseUrl(args.url);
+    const me = args.from ?? "";
+    const emit = (o) => {
+      process.stdout.write(`${JSON.stringify(o)}
+`);
+    };
+    const spillDir = join2(tmpdir(), "hotline", args.channel);
+    mkdirSync(spillDir, { recursive: true });
+    const surface = (m) => {
+      const text = typeof m.text === "string" ? m.text : "";
+      const file = join2(spillDir, `${m.seq}.txt`);
+      writeFileSync2(file, text);
+      const truncated = text.length > PREVIEW;
+      emit({
+        type: "relay.message",
+        seq: m.seq,
+        from: m.from,
+        ts: m.ts,
+        chars: text.length,
+        truncated,
+        preview: truncated ? `${text.slice(0, PREVIEW)} \u2026` : text,
+        file
+      });
+    };
+    const describe = (e) => {
+      const ev = e;
+      return ev?.code ? `${ev.code}${ev.message ? ` ${ev.message}` : ""}` : String(e);
+    };
+    const close = relayClient(url).listen(args.channel, args.token, {
+      since: args.since ? Number(args.since) : 0,
+      // Skip our own messages (they come back over the same channel).
+      onMessage: (m) => {
+        if (m.from !== me) surface(m);
+      },
+      onError: (e) => emit({ type: "relay.error", error: describe(e) })
+    });
+    emit({ type: "relay.listening", channel: args.channel, from: me, url });
+    await new Promise((resolve2) => {
+      const stop = () => {
+        close();
+        resolve2();
+      };
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+    });
+  }
+});
+var relay = defineCommand({
+  meta: { name: "relay", description: "Claude\u2194Claude live channel: host / listen / send" },
+  subCommands: { host: hostCommand, listen: listenCommand, send: sendCommand }
+});
+
+// src/commands/requirement.ts
+var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
+var updateRequirement = (c, id, patch2, json) => c.requirements.update(id, patch2).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)
+          )
+        );
+      }
+    }),
+    update: defineCommand({
+      meta: { name: "update", description: "update a requirement title / body" },
+      args: {
+        code: { type: "positional", required: true, description: "requirement code (R-N)" },
+        title: { type: "string", description: "new title" },
+        body: { type: "string", description: "new body (markdown)" },
+        project: { type: "string", description: "project id (overrides .baton.json)" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const patch2 = {
+          ...args.title !== void 0 ? { title: args.title } : {},
+          ...args.body !== void 0 ? { body: args.body } : {}
+        };
+        if (Object.keys(patch2).length === 0) throw new Error("pass --title and/or --body");
+        const c = clientFor(args);
+        const id = await resolveByCode(c, resolveProjectId(args), args.code);
+        console.log(await updateRequirement(c, id, patch2, 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/shared.ts
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join3(env.XDG_DATA_HOME ?? join3(env.HOME ?? homedir(), ".local/share"), "baton", "worktrees");
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+var resolveSession = async (client, projectId, handle) => {
+  const asInt = Number(handle);
+  if (Number.isInteger(asInt) && asInt > 0) {
+    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/abort.ts
+var sessionAbortCommand = defineCommand({
+  meta: {
+    name: "abort",
+    description: "interrupt the in-flight turn (like Esc); keeps the 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.abort(handle.id);
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
+  }
+});
+
+// src/commands/session/clear.ts
+var sessionClearCommand = defineCommand({
+  meta: {
+    name: "clear",
+    description: "reset the conversation context (keeps the session + worktree)"
+  },
+  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.clear(handle.id);
+    console.log(renderOne(s, fmtSession, 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 handle: W-N or int id (default: this machine's worker)"
+    },
+    project: {
+      type: "string",
+      description: "project id (default: the worker's own project, else .baton.json)"
+    },
+    ...common
+  },
+  run: async ({ args }) => {
+    const c = clientFor(args);
+    const workerId = args.worker ? parseWorkerHandle(args.worker) : loadProjectConfigOrNull(projectConfigPath())?.worker?.id ?? null;
+    if (workerId === null)
+      throw new Error(
+        "no worker \u2014 pass --worker <W-N|id> or run `baton worker register` first (names need --project)"
+      );
+    const projectId = args.project !== void 0 && args.project !== "" ? Number(args.project) : args.worker ? (await c.workers.get(workerId)).projectId : resolveProjectId(args);
+    const s = await c.sessions.create({ projectId, workerId, name: args.name });
+    console.log(renderOne(s, fmtSession, Boolean(args.json)));
   }
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
-  get onopen() {
-    return __privateGet(this, _onOpen);
+});
+
+// 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)));
   }
-  set onopen(value) {
-    __privateSet(this, _onOpen, value);
+});
+
+// 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)));
   }
-  addEventListener(type, listener, options) {
-    const listen = listener;
-    super.addEventListener(type, listen, options);
+});
+
+// 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)));
   }
-  removeEventListener(type, listener, options) {
-    const listen = listener;
-    super.removeEventListener(type, listen, options);
+});
+
+// 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)));
   }
-  /**
-   * 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));
+});
+
+// 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})`);
   }
-};
-_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 { spawnSync } from "node:child_process";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
+// ../shared/src/domain/attachment.ts
+var isImageAttachment = (att) => att.contentType.startsWith("image/");
+var labelAttachments = (attachments) => {
+  const counters = { image: 0, file: 0 };
+  return attachments.map((att) => {
+    const kind = isImageAttachment(att) ? "image" : "file";
+    counters[kind] += 1;
+    return `${kind}-${counters[kind]}`;
+  });
+};
+
+// ../shared/src/domain/session-event.ts
+var startedMessageIds = (events) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.type !== "turn_start") continue;
+    const id = e.payload?.messageId;
+    if (typeof id === "number") ids.add(id);
+  }
+  return ids;
+};
+var unstartedUserMessages = (events) => {
+  const started = startedMessageIds(events);
+  return events.filter((e) => e.type === "user_message" && !started.has(e.id));
+};
+
 // src/session/runner/log.ts
 var maskedEnvKeys = (env) => env ? Object.keys(env).sort().join(", ") : "(none)";
 
@@ -1735,14 +1939,14 @@ var additionalDirs = () => {
 };
 
 // src/session/runner/transcript.ts
-import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var findTranscriptPath = (agentSessionId) => {
-  const root = join3(homedir2(), ".claude", "projects");
+  const root = join4(homedir2(), ".claude", "projects");
   try {
     for (const dir of readdirSync(root)) {
-      const candidate = join3(root, dir, `${agentSessionId}.jsonl`);
+      const candidate = join4(root, dir, `${agentSessionId}.jsonl`);
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
@@ -1788,27 +1992,16 @@ var readFirstExchange = (agentSessionId) => {
   const path = findTranscriptPath(agentSessionId);
   if (!path) return null;
   try {
-    return parseFirstExchange(readFileSync2(path, "utf8"));
+    return parseFirstExchange(readFileSync3(path, "utf8"));
   } catch {
     return null;
   }
 };
 
-// ../shared/src/domain/attachment.ts
-var isImageAttachment = (att) => att.contentType.startsWith("image/");
-var labelAttachments = (attachments) => {
-  const counters = { image: 0, file: 0 };
-  return attachments.map((att) => {
-    const kind = isImageAttachment(att) ? "image" : "file";
-    counters[kind] += 1;
-    return `${kind}-${counters[kind]}`;
-  });
-};
-
 // 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 { join as join5 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 var ATTACH_DIR = "attachments";
@@ -1831,16 +2024,16 @@ var dedupe = (name, taken) => {
 };
 var materializeAttachments = async (opts) => {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const dir = join4(opts.worktreePath, ATTACH_DIR);
+  const dir = join5(opts.worktreePath, ATTACH_DIR);
   await mkdir(dir, { recursive: true });
-  await writeFile(join4(dir, ".gitignore"), "*\n", "utf8");
+  await writeFile(join5(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)));
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(join5(dir, name)));
     relPaths.push(`${ATTACH_DIR}/${name}`);
   }
   return relPaths;
@@ -1867,6 +2060,10 @@ var startQuery = (config, text, resuming, queryFn, abortController, log, { envOv
   const options = {
     cwd: config.worktreePath,
     permissionMode: planMode ? "plan" : "bypassPermissions",
+    // Headless relay: no TTY/TUI can answer an interactive ask, so AskUserQuestion
+    // would fail the whole turn. Block it — the model asks in plain text instead,
+    // which the human reads in web/Feishu and replies to as a new turn.
+    disallowedTools: ["AskUserQuestion"],
     includePartialMessages: false,
     abortController,
     stderr: (line) => log(`[claude] ${line.trimEnd()}`),
@@ -2038,6 +2235,7 @@ var runDaemon = async (config, deps, signal) => {
   };
   const pendingQueue = [];
   let busy = false;
+  let reconciling = false;
   let lastActivity = Date.now();
   let currentTurn;
   const drain = async () => {
@@ -2071,6 +2269,28 @@ var runDaemon = async (config, deps, signal) => {
       busy = false;
     }
   };
+  const reconcile = async () => {
+    reconciling = true;
+    try {
+      const pending = unstartedUserMessages(await deps.worker.listEvents());
+      let added = 0;
+      for (const ev of pending) {
+        if (state.seen.has(ev.sequence)) continue;
+        state.seen.add(ev.sequence);
+        pendingQueue.push(ev);
+        added++;
+      }
+      if (added > 0) {
+        log(`reconciled ${added} queued message(s) from transcript`);
+        lastActivity = Date.now();
+        void drain();
+      }
+    } catch (e) {
+      log(`reconcile failed: ${String(e)}`);
+    } finally {
+      reconciling = 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.
@@ -2092,8 +2312,11 @@ var runDaemon = async (config, deps, signal) => {
     },
     // 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).
+    // Then reconcile against the durable transcript to pick up anything that
+    // landed while we weren't subscribed (initial spawn or a reconnect gap).
     () => {
       void deps.worker.setActive(true).then(() => log("\u25B2 active (subscribed)")).catch((e) => log(`status(active) failed: ${String(e)}`));
+      void reconcile();
     }
   );
   const idleMs = idleMsFromEnv();
@@ -2101,7 +2324,7 @@ var runDaemon = async (config, deps, signal) => {
   const reaped = new Promise((resolve2) => {
     idleTimer = setInterval(
       () => {
-        if (shouldReap(lastActivity, Date.now(), busy, pendingQueue.length, idleMs)) {
+        if (!reconciling && shouldReap(lastActivity, Date.now(), busy, pendingQueue.length, idleMs)) {
           log("idle \u2014 shutting down (resumes on next message)");
           resolve2();
         }
@@ -2446,7 +2669,7 @@ import { hostname as osHostname } from "node:os";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname2, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -2536,7 +2759,7 @@ var generateTitle = async (input) => {
 
 // src/session/worktree.ts
 import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "node:fs";
 import { dirname, isAbsolute as isAbsolute2, resolve } from "node:path";
 var createWorktree = (input) => {
   if (existsSync4(input.worktreePath))
@@ -2549,7 +2772,7 @@ var createWorktree = (input) => {
     throw new Error(
       `repo has no commits (unborn HEAD) \u2014 create an initial commit before starting sessions`
     );
-  mkdirSync(dirname(input.worktreePath), { recursive: true });
+  mkdirSync2(dirname(input.worktreePath), { recursive: true });
   const branch = `baton/${input.sessionCode}`;
   const r = spawnSync2(
     "git",
@@ -2577,9 +2800,9 @@ var ensureExcluded = (repo, pattern) => {
     if (r.status !== 0) return;
     const rel = r.stdout.trim();
     const path = isAbsolute2(rel) ? rel : resolve(repo, rel);
-    const current = existsSync4(path) ? readFileSync3(path, "utf8") : "";
+    const current = existsSync4(path) ? readFileSync4(path, "utf8") : "";
     if (current.split("\n").includes(pattern)) return;
-    mkdirSync(dirname(path), { recursive: true });
+    mkdirSync2(dirname(path), { recursive: true });
     const sep = current === "" || current.endsWith("\n") ? "" : "\n";
     appendFileSync(path, `${sep}${pattern}
 `, "utf8");
@@ -2603,7 +2826,7 @@ var streamWedged = (isOpen, okAt, now, thresholdMs) => !isOpen && stale(okAt, no
 // src/worker/daemon.ts
 var binPath = () => {
   const here = dirname2(fileURLToPath(import.meta.url));
-  const devShim = join5(here, "..", "..", "bin", "baton.mjs");
+  const devShim = join6(here, "..", "..", "bin", "baton.mjs");
   return existsSync5(devShim) ? devShim : fileURLToPath(import.meta.url);
 };
 var runWorkerDaemon = async (cfg, client, signal) => {
@@ -2673,7 +2896,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
     let worktreePath = session2.worktreePath;
     if (!session2.agentSessionId || !worktreePath) {
       const agentSessionId = randomUUID();
-      worktreePath = join5(worktreeDir, slug(`${name}-${agentSessionId.slice(0, 8)}`));
+      worktreePath = join6(worktreeDir, slug(`${name}-${agentSessionId.slice(0, 8)}`));
       createWorktree({
         repo,
         worktreePath,
@@ -2684,7 +2907,7 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
     }
     ensureExcluded(repo, PROJECT_CONFIG_NAME);
-    saveProjectConfig(join5(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg));
+    saveProjectConfig(join6(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg));
     spawnChild(sessionId, worktreePath);
   };
   const onStop = (sessionId) => {
@@ -2787,18 +3010,18 @@ var runWorkerDaemon = async (cfg, client, signal) => {
 
 // src/worker/machine-id.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } 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");
+import { dirname as dirname3, join as join7 } from "node:path";
+var machineIdPath = (env = process.env) => join7(env.XDG_DATA_HOME ?? join7(env.HOME ?? homedir3(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
   if (existsSync6(path)) {
-    const s = readFileSync4(path, "utf8").trim();
+    const s = readFileSync5(path, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID2();
-  mkdirSync2(dirname3(path), { recursive: true });
-  writeFileSync2(path, `${id}
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, `${id}
 `, "utf8");
   return id;
 };
@@ -3066,6 +3289,7 @@ var main = defineCommand({
     init,
     worker,
     session,
+    relay,
     workspace,
     project,
     requirement,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "license": "MIT",
   "type": "module",
   "description": "baton CLI — register/run a worker, manage projects/requirements/tasks/sessions",