@lesscap/baton-cli 0.2.12 → 0.3.0

package/dist/baton.mjs

@@ -467,234 +467,590 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
   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();
+// ../../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;
+}
 
-// src/client/auth.ts
-var primed = false;
-var primeLogin = (baseUrl) => {
-  if (primed) return;
-  primed = true;
-  const token = process.env.BATON_TOKEN;
-  if (token) {
-    setAuthHeaders({ authorization: `Bearer ${token}` });
-    return;
+// ../../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;
   }
-  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 })
+  /**
+   * 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 || ""
       });
-      const cookie = (res.headers.getSetCookie()[0] ?? "").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;
+      __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));
+  }
 };
-
-// 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"),
-    update: (id, patch2) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch2 }),
-    setStatus: (id, status) => request(u(`/requirements/${id}`), { method: "PATCH", body: { status } }),
-    remove: (id) => request(u(`/requirements/${id}`), { method: "DELETE" })
+_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
   };
-};
-
-// 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" }),
-    clear: (id) => request(u(`/sessions/${id}/clear`), { method: "POST" }),
-    abort: (id) => request(u(`/sessions/${id}/abort`), { 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;
+  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/channel.ts
+var channelClient = (baseUrl) => {
+  const u = (p) => `${baseUrl}${p}`;
+  const authed = (token) => ({ authorization: `Bearer ${token}` });
+  const sendJson = (token) => ({ "content-type": "application/json", ...authed(token) });
+  const member = (channelId, name) => u(`/channels/${channelId}/members/${encodeURIComponent(name)}`);
+  return {
+    create: async (title, description) => {
+      const res = await fetch(u("/channels"), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...title ? { title } : {}, ...description ? { description } : {} })
+      });
+      if (!res.ok) throw new Error(`POST /channels \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
     },
-    sendMessage: (id, text, attachments, planMode) => request(u(`/sessions/${id}/messages`), {
-      method: "POST",
-      body: {
-        text,
-        ...attachments && attachments.length > 0 ? { attachments } : {},
-        ...planMode ? { planMode: true } : {}
-      }
-    }),
-    // 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, {
+    manifest: async (channelId, token) => {
+      const res = await fetch(u(`/channels/${channelId}`), { headers: authed(token) });
+      if (!res.ok) throw new Error(`GET channel \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    update: async (channelId, token, patch2) => {
+      const res = await fetch(u(`/channels/${channelId}`), {
+        method: "PATCH",
+        headers: sendJson(token),
+        body: JSON.stringify(patch2)
+      });
+      if (!res.ok) throw new Error(`PATCH channel \u2192 ${res.status}: ${await res.text()}`);
+      return await res.json();
+    },
+    help: async () => {
+      const res = await fetch(u("/channels/help"));
+      if (!res.ok) throw new Error(`GET /channels/help \u2192 ${res.status}: ${await res.text()}`);
+      return await res.text();
+    },
+    destroy: async (channelId, token) => {
+      const res = await fetch(u(`/channels/${channelId}`), {
+        method: "DELETE",
+        headers: authed(token)
+      });
+      if (!res.ok) throw new Error(`DELETE channel \u2192 ${res.status}: ${await res.text()}`);
+    },
+    join: async (channelId, token, name, kind) => {
+      const res = await fetch(member(channelId, name), {
+        method: "PUT",
+        headers: sendJson(token),
+        body: JSON.stringify({ kind: kind ?? "agent" })
+      });
+      if (!res.ok) throw new Error(`join channel \u2192 ${res.status}: ${await res.text()}`);
+      return (await res.json()).members;
+    },
+    leave: async (channelId, token, name) => {
+      const res = await fetch(member(channelId, name), { method: "DELETE", headers: authed(token) });
+      if (!res.ok) throw new Error(`leave channel \u2192 ${res.status}: ${await res.text()}`);
+    },
+    members: async (channelId, token) => {
+      const res = await fetch(u(`/channels/${channelId}/members`), { headers: authed(token) });
+      if (!res.ok) throw new Error(`GET members \u2192 ${res.status}: ${await res.text()}`);
+      return (await res.json()).members;
+    },
+    send: async (channelId, token, msg) => {
+      const res = await fetch(u(`/channels/${channelId}/messages`), {
         method: "POST",
-        body: input.body,
-        headers: { "content-type": input.contentType }
+        headers: sendJson(token),
+        body: JSON.stringify(msg)
       });
-      if (!res.ok) throw new Error(`POST ${url} \u2192 ${res.status}: ${await res.text()}`);
+      if (!res.ok) throw new Error(`POST channel message \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"),
-    update: (id, patch2) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch2 }),
-    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"
+    read: async (channelId, token, opts) => {
+      const params = new URLSearchParams({ since: String(opts?.since ?? 0) });
+      if (opts?.for) params.set("for", opts.for);
+      const res = await fetch(u(`/channels/${channelId}/messages?${params}`), {
+        headers: authed(token)
       });
-      const matches = all.filter((w) => w.name === name);
-      return matches.length === 0 ? null : matches[matches.length - 1] ?? null;
+      if (!res.ok) throw new Error(`GET messages \u2192 ${res.status}: ${await res.text()}`);
+      return (await res.json()).messages;
     },
-    heartbeat: (machineId) => request(u("/workers/heartbeat"), { method: "POST", body: { machineId } }),
-    destroy: async (id) => {
-      await request(u(`/workers/${id}`), { method: "DELETE" });
+    listen: (channelId, token, opts) => {
+      let cursor = opts.since ?? 0;
+      const params = new URLSearchParams({ since: String(cursor) });
+      if (opts.for) params.set("for", opts.for);
+      if (opts.as) params.set("as", opts.as);
+      const es = new EventSource(u(`/channels/${channelId}/stream?${params}`), {
+        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/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";
@@ -747,121 +1103,19 @@ var worktreeConfig = (cfg) => ({
   worker: { id: cfg.workerId, name: cfg.name, machineId: cfg.machineId, apiToken: cfg.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";
-};
-var resolveBaseUrlOrNull = (urlArg, env = process.env) => {
-  if (urlArg) return urlArg;
-  const cfg = loadProjectConfigOrNull(projectConfigPath());
-  if (cfg?.server) return cfg.server;
-  return env.BATON_URL ?? null;
-};
-
-// 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 resolveAuth = (env, fileToken) => {
-  const envBearer = env.BATON_TOKEN ?? env.BATON_WORKER_TOKEN;
-  if (envBearer) return { bearer: envBearer };
-  if (env.BATON_USER && env.BATON_PASS) return "cookie";
-  return fileToken ? { bearer: fileToken } : void 0;
-};
-var clientFor = (args) => {
-  const baseUrl = resolveBaseUrl(args.url);
-  const fileToken = loadProjectConfigOrNull(projectConfigPath())?.worker?.apiToken;
-  const auth = resolveAuth(process.env, fileToken);
-  return createClient(baseUrl, auth && auth !== "cookie" ? auth : void 0);
-};
-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 parseWorkerHandle = (handle) => {
-  const m = handle.trim().match(/^(?:[wW]-)?(\d+)$/);
-  return m ? Number(m[1]) : null;
-};
-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/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";
+};
+var resolveBaseUrlOrNull = (urlArg, env = process.env) => {
+  if (urlArg) return urlArg;
+  const cfg = loadProjectConfigOrNull(projectConfigPath());
+  if (cfg?.server) return cfg.server;
+  return env.BATON_URL ?? null;
+};
 
 // src/output.ts
 var toJson = (data) => JSON.stringify(data, null, 2);
@@ -882,838 +1136,1199 @@ var renderList = (items, fmt, json) => {
 };
 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/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 token = process.env.BATON_TOKEN;
+  if (token) {
+    setAuthHeaders({ authorization: `Bearer ${token}` });
+    return;
   }
-});
+  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.getSetCookie()[0] ?? "").split(";")[0];
+      if (res.ok && cookie) setAuthHeaders({ cookie });
+    })().catch(() => {
+    })
+  );
+};
 
-// 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))
-        );
-      }
+// 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"),
+    update: (id, patch2) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch2 }),
+    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}` }
     }),
-    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)));
-      }
+    setStatus: (id, active, workerToken) => request(u(`/sessions/${id}/status`), {
+      method: "POST",
+      body: { active },
+      headers: { authorization: `Bearer ${workerToken}` }
     }),
-    "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))
-        );
-      }
+    setName: (id, name, workerToken) => request(u(`/sessions/${id}`), {
+      method: "PATCH",
+      body: { name },
+      headers: { authorization: `Bearer ${workerToken}` }
     }),
-    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)));
+    resume: (id) => request(u(`/sessions/${id}/resume`), { method: "POST" }),
+    stop: (id) => request(u(`/sessions/${id}/stop`), { method: "POST" }),
+    clear: (id) => request(u(`/sessions/${id}/clear`), { method: "POST" }),
+    abort: (id) => request(u(`/sessions/${id}/abort`), { 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, planMode) => request(u(`/sessions/${id}/messages`), {
+      method: "POST",
+      body: {
+        text,
+        ...attachments && attachments.length > 0 ? { attachments } : {},
+        ...planMode ? { planMode: true } : {}
       }
-    })
-  }
-});
+    }),
+    // 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/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/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"),
+    update: (id, patch2) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch2 }),
+    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/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/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
+    }),
+    listEvents: () => request(u(`/sessions/${sessionId}/events`), { method: "GET", headers: auth })
+  };
+};
 
-// src/commands/session/clear.ts
-var sessionClearCommand = defineCommand({
-  meta: {
-    name: "clear",
-    description: "reset the conversation context (keeps the session + worktree)"
+// 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 resolveAuth = (env, fileToken) => {
+  const envBearer = env.BATON_TOKEN ?? env.BATON_WORKER_TOKEN;
+  if (envBearer) return { bearer: envBearer };
+  if (env.BATON_USER && env.BATON_PASS) return "cookie";
+  return fileToken ? { bearer: fileToken } : void 0;
+};
+var clientFor = (args) => {
+  const baseUrl = resolveBaseUrl(args.url);
+  const fileToken = loadProjectConfigOrNull(projectConfigPath())?.worker?.apiToken;
+  const auth = resolveAuth(process.env, fileToken);
+  return createClient(baseUrl, auth && auth !== "cookie" ? auth : void 0);
+};
+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 parseWorkerHandle = (handle) => {
+  const m = handle.trim().match(/^(?:[wW]-)?(\d+)$/);
+  return m ? Number(m[1]) : null;
+};
+var splitCsv = (s) => s ? s.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+
+// src/commands/channel/close.ts
+var closeCommand = defineCommand({
+  meta: { name: "close", description: "delete a channel (removes the room and all its messages)" },
   args: {
-    session: { type: "positional", required: true, description: "session int id or name" },
-    project: { type: "string", description: "project id (overrides .baton.json)" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
     ...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)));
+    await channelClient(resolveBaseUrl(args.url)).destroy(args.channel, args.token);
+    console.log(args.json ? toJson({ ok: true, deleted: args.channel }) : `closed ${args.channel}`);
   }
 });
 
-// src/commands/session/create.ts
-var sessionCreateCommand = defineCommand({
-  meta: { name: "create", description: "create + start a session on a worker" },
+// src/commands/channel/shared.ts
+var readStdin = async () => {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+};
+var renderRoster = (members) => members.length ? members.map((m) => `  ${m.name} (${m.kind})`).join("\n") : "  (nobody online)";
+var inviteBlock = (url, channelId, token) => [
+  "\u2500\u2500 Share this to invite anyone into the room \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 baton channel. Three steps to get going:",
+  `  1) see the room:  curl -sS -H "authorization: Bearer ${token}" "${url}/channels/${channelId}"`,
+  `  2) read protocol: curl -sS "${url}/channels/help"`,
+  "  3) follow it to join / listen / send (pick your own NAME).",
+  "",
+  `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\u2500"
+].join("\n");
+
+// src/commands/channel/create.ts
+var createCommand = defineCommand({
+  meta: { name: "create", description: "open a channel (chat room) and print an invite" },
   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)"
-    },
+    name: { type: "string", description: "room title (optional)" },
+    desc: { type: "string", description: "room self-description: purpose / topic / how to participate" },
     ...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)));
+    const url = resolveBaseUrl(args.url);
+    const { channelId, token } = await channelClient(url).create(args.name, args.desc);
+    if (args.json) {
+      console.log(toJson({ channelId, token, url, name: args.name, description: args.desc }));
+      return;
+    }
+    console.log(`channel ${channelId} opened
+`);
+    console.log(inviteBlock(url, channelId, token));
   }
 });
 
-// src/commands/session/get.ts
-var sessionGetCommand = defineCommand({
-  meta: { name: "get", description: "get a session by int id or name" },
+// src/commands/channel/info.ts
+var aboutCommand = defineCommand({
+  meta: { name: "about", description: "show a channel's manifest (description + online roster)" },
   args: {
-    session: { type: "positional", required: true, description: "session int id or name" },
-    project: { type: "string", description: "project id (overrides .baton.json)" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
     ...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)));
+    const url = resolveBaseUrl(args.url);
+    const m = await channelClient(url).manifest(args.channel, args.token);
+    if (args.json) {
+      console.log(toJson(m));
+      return;
+    }
+    console.log(`${m.title ?? "(untitled)"}  [${m.id}]`);
+    if (m.description) console.log(m.description);
+    console.log(`
+online (${m.members.length}):
+${renderRoster(m.members)}`);
+    console.log(`
+protocol: curl -sS "${url}${m.help}"`);
   }
 });
-
-// src/commands/session/ls.ts
-var sessionLsCommand = defineCommand({
-  meta: { name: "ls", description: "list sessions in a project" },
+var helpCommand = defineCommand({
+  meta: { name: "help", description: "print the channel protocol doc (no token needed)" },
+  args: { ...common },
+  run: async ({ args }) => {
+    console.log(await channelClient(resolveBaseUrl(args.url)).help());
+  }
+});
+var membersCommand = defineCommand({
+  meta: { name: "members", description: "list the channel's online roster" },
   args: {
-    project: { type: "string", description: "project id (overrides .baton.json)" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
     ...common
   },
   run: async ({ args }) => {
-    const c = clientFor(args);
-    const ss = await c.sessions.listByProject(resolveProjectId(args));
-    console.log(renderList(ss, fmtSession, Boolean(args.json)));
+    const url = resolveBaseUrl(args.url);
+    const members = await channelClient(url).members(args.channel, args.token);
+    console.log(args.json ? toJson(members) : renderRoster(members));
   }
 });
-
-// src/commands/session/rename.ts
-var sessionRenameCommand = defineCommand({
-  meta: { name: "rename", description: "rename a session (locks the name against auto-title)" },
+var updateCommand = defineCommand({
+  meta: { name: "update", description: "update a channel's title / description (topic + rules)" },
   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)" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
+    title: { type: "string", description: "new title" },
+    desc: { type: "string", description: "new description (purpose / topic / rules)" },
     ...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)));
+    if (args.title === void 0 && args.desc === void 0)
+      throw new Error("nothing to update: pass --title and/or --desc");
+    const url = resolveBaseUrl(args.url);
+    const ch = await channelClient(url).update(args.channel, args.token, {
+      title: args.title,
+      description: args.desc
+    });
+    console.log(args.json ? toJson(ch) : `updated ${ch.id}${ch.title ? ` \u2014 ${ch.title}` : ""}`);
   }
 });
 
-// src/commands/session/resume.ts
-var sessionResumeCommand = defineCommand({
-  meta: { name: "resume", description: "resume (re-start) an existing session" },
+// src/commands/channel/listen.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+
+// ../shared/src/domain/attachment.ts
+var isImageAttachment = (att) => att.contentType.startsWith("image/");
+var labelAttachments = (attachments) => {
+  const counters = { image: 0, file: 0 };
+  return attachments.map((att) => {
+    const kind = isImageAttachment(att) ? "image" : "file";
+    counters[kind] += 1;
+    return `${kind}-${counters[kind]}`;
+  });
+};
+
+// ../shared/src/domain/channel.ts
+var isMessageFor = (msg, name) => !msg.to || msg.to.length === 0 || msg.to.includes(name);
+
+// ../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/commands/channel/listen.ts
+var PREVIEW = 280;
+var describe = (e) => {
+  const ev = e;
+  return ev?.code ? `${ev.code}${ev.message ? ` ${ev.message}` : ""}` : String(e);
+};
+var runListen = async (o) => {
+  const emit = (x) => {
+    process.stdout.write(`${JSON.stringify(x)}
+`);
+  };
+  const spillDir = join2(tmpdir(), "channel", o.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: "channel.message",
+      seq: m.seq,
+      from: m.from,
+      senderKind: m.senderKind,
+      to: m.to,
+      mine: o.from ? isMessageFor(m, o.from) : void 0,
+      ts: m.ts,
+      chars: text.length,
+      truncated,
+      preview: truncated ? `${text.slice(0, PREVIEW)} \u2026` : text,
+      file
+    });
+  };
+  const close = channelClient(o.url).listen(o.channel, o.token, {
+    since: o.since,
+    for: o.for,
+    as: o.from,
+    // Skip our own messages (they echo back over the same channel).
+    onMessage: (m) => {
+      if (m.from !== o.from) surface(m);
+    },
+    onError: (e) => emit({ type: "channel.error", error: describe(e) })
+  });
+  emit({ type: "channel.listening", channel: o.channel, from: o.from, url: o.url });
+  await new Promise((resolve2) => {
+    const stop = () => {
+      close();
+      resolve2();
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+};
+var listenCommand = defineCommand({
+  meta: {
+    name: "listen",
+    description: "stream a channel: one JSON line per message (for a background subscriber)"
+  },
   args: {
-    session: { type: "positional", required: true, description: "session int id or name" },
-    project: { type: "string", description: "project id (overrides .baton.json)" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
+    from: { type: "string", description: "your name; your own messages skipped, presence kept fresh" },
+    since: { type: "string", description: "replay messages after this seq (default 0 = full)" },
+    for: { type: "string", description: "only broadcasts + messages addressed to this name" },
     ...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)));
+    await runListen({
+      url: resolveBaseUrl(args.url),
+      channel: args.channel,
+      token: args.token,
+      from: args.from ?? "",
+      since: args.since ? Number(args.since) : 0,
+      for: args.for
+    });
   }
 });
 
-// src/commands/session/rm.ts
-var sessionRmCommand = defineCommand({
-  meta: { name: "rm", description: "delete a session (irreversible; removes its worktree)" },
+// src/commands/channel/join.ts
+var joinCommand = defineCommand({
+  meta: { name: "join", description: "join a channel (register presence); --listen to also stream" },
   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" },
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
+    from: { type: "string", required: true, description: "your participant name" },
+    kind: { type: "string", description: "your kind: agent (default) | human" },
+    listen: { type: "boolean", description: "after joining, stream messages (background subscriber)" },
+    since: { type: "string", description: "with --listen: replay after this seq (default 0)" },
     ...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.");
+    const url = resolveBaseUrl(args.url);
+    const kind = args.kind === "human" ? "human" : "agent";
+    const members = await channelClient(url).join(args.channel, args.token, args.from, kind);
+    if (!args.listen) {
+      if (args.json) console.log(toJson({ joined: args.from, members }));
+      else console.log(`joined as ${args.from} (${members.length} online)
+${renderRoster(members)}`);
       return;
     }
-    await c.sessions.destroy(handle.id);
-    console.log(`deleted session ${handle.name} (#${handle.id})`);
+    await runListen({
+      url,
+      channel: args.channel,
+      token: args.token,
+      from: args.from,
+      since: args.since ? Number(args.since) : 0
+    });
   }
 });
 
-// ../../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;
+// src/commands/channel/read.ts
+var readCommand = defineCommand({
+  meta: { name: "read", description: "poll channel messages once (curl-style, since a cursor)" },
+  args: {
+    channel: { type: "positional", required: true, description: "channel id" },
+    token: { type: "string", required: true, description: "channel token" },
+    since: { type: "string", description: "only messages after this seq (default 0)" },
+    from: { type: "string", description: "skip messages from this name (no echo)" },
+    for: { type: "string", description: "only broadcasts + messages addressed to this name" },
+    ...common
+  },
+  run: async ({ args }) => {
+    const url = resolveBaseUrl(args.url);
+    const msgs = await channelClient(url).read(args.channel, args.token, {
+      since: args.since ? Number(args.since) : 0,
+      for: args.for
+    });
+    const out = args.from ? msgs.filter((m) => m.from !== args.from) : msgs;
+    if (args.json) console.log(toJson(out));
+    else console.log(out.length ? out.map((m) => `${m.seq}  ${m.from}  ${m.text}`).join("\n") : "(none)");
   }
-  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;
+// src/commands/channel/send.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+var sendCommand = defineCommand({
+  meta: { name: "send", description: "post one message to a 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)" },
+    to: { type: "string", description: "direct it at these names (comma-separated); omit = broadcast" },
+    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 channelClient(url).send(args.channel, args.token, {
+      from: args.from ?? "peer",
+      text,
+      to: splitCsv(args.to)
+    });
+    if (args.json) console.log(toJson(msg));
+    else console.log(`sent (seq ${msg.seq})`);
   }
-  /**
-   * 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);
+});
+
+// src/commands/channel.ts
+var channel = defineCommand({
+  meta: {
+    name: "channel",
+    description: "multi-agent chat room: create / about / update / help / join / members / send / read / listen / close"
+  },
+  subCommands: {
+    create: createCommand,
+    about: aboutCommand,
+    update: updateCommand,
+    help: helpCommand,
+    join: joinCommand,
+    members: membersCommand,
+    send: sendCommand,
+    read: readCommand,
+    listen: listenCommand,
+    close: closeCommand
   }
-  /**
-   * 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);
+});
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "node:fs";
+import * as readline from "node:readline/promises";
+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();
   }
 };
-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;
+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/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);
       }
-      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;
+    }),
+    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))
+        );
       }
-      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;
+    }),
+    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)));
       }
-      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;
+    }),
+    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)));
       }
-      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 || ""
+    })
+  }
+});
+
+// src/commands/relay.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+
+// 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)
       });
-      __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");
+      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();
     }
-    __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);
+  };
+};
+
+// src/commands/relay.ts
+var PREVIEW2 = 280;
+var readStdin2 = async () => {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+};
+var inviteBlock2 = (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(inviteBlock2(url, channelId, token));
   }
-  /**
-   * 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);
+});
+var sendCommand2 = 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 = readFileSync3(args.file, "utf8");
+    if (text === void 0 && !process.stdin.isTTY) text = await readStdin2();
+    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})`);
   }
-  /**
-   * 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;
+});
+var listenCommand2 = 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 = join3(tmpdir2(), "hotline", args.channel);
+    mkdirSync2(spillDir, { recursive: true });
+    const surface = (m) => {
+      const text = typeof m.text === "string" ? m.text : "";
+      const file = join3(spillDir, `${m.seq}.txt`);
+      writeFileSync3(file, text);
+      const truncated = text.length > PREVIEW2;
+      emit({
+        type: "relay.message",
+        seq: m.seq,
+        from: m.from,
+        ts: m.ts,
+        chars: text.length,
+        truncated,
+        preview: truncated ? `${text.slice(0, PREVIEW2)} \u2026` : text,
+        file
+      });
+    };
+    const describe2 = (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: describe2(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);
+    });
   }
-  /**
-   * 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);
+});
+var relay = defineCommand({
+  meta: { name: "relay", description: "Claude\u2194Claude live channel: host / listen / send" },
+  subCommands: { host: hostCommand, listen: listenCommand2, send: sendCommand2 }
+});
+
+// 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)));
+      }
+    })
   }
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
-  get onerror() {
-    return __privateGet(this, _onError);
+});
+
+// src/commands/session/shared.ts
+import { homedir } from "node:os";
+import { join as join4 } from "node:path";
+var defaultWorktreeDir = (env = process.env) => env.BATON_WORKTREE_DIR ?? join4(env.XDG_DATA_HOME ?? join4(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 };
   }
-  set onerror(value) {
-    __privateSet(this, _onError, value);
+  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)));
   }
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
-  get onmessage() {
-    return __privateGet(this, _onMessage);
+});
+
+// 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)));
   }
-  set onmessage(value) {
-    __privateSet(this, _onMessage, value);
+});
+
+// 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";
@@ -1735,14 +2350,14 @@ var additionalDirs = () => {
 };
 
 // src/session/runner/transcript.ts
-import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 var findTranscriptPath = (agentSessionId) => {
-  const root = join3(homedir2(), ".claude", "projects");
+  const root = join5(homedir2(), ".claude", "projects");
   try {
     for (const dir of readdirSync(root)) {
-      const candidate = join3(root, dir, `${agentSessionId}.jsonl`);
+      const candidate = join5(root, dir, `${agentSessionId}.jsonl`);
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
@@ -1788,27 +2403,16 @@ var readFirstExchange = (agentSessionId) => {
   const path = findTranscriptPath(agentSessionId);
   if (!path) return null;
   try {
-    return parseFirstExchange(readFileSync2(path, "utf8"));
+    return parseFirstExchange(readFileSync4(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 join6 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 var ATTACH_DIR = "attachments";
@@ -1831,16 +2435,16 @@ var dedupe = (name, taken) => {
 };
 var materializeAttachments = async (opts) => {
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const dir = join4(opts.worktreePath, ATTACH_DIR);
+  const dir = join6(opts.worktreePath, ATTACH_DIR);
   await mkdir(dir, { recursive: true });
-  await writeFile(join4(dir, ".gitignore"), "*\n", "utf8");
+  await writeFile(join6(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(join6(dir, name)));
     relPaths.push(`${ATTACH_DIR}/${name}`);
   }
   return relPaths;
@@ -1867,6 +2471,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 +2646,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 +2680,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 +2723,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 +2735,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 +3080,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 join7 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -2536,7 +3170,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 mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { dirname, isAbsolute as isAbsolute2, resolve } from "node:path";
 var createWorktree = (input) => {
   if (existsSync4(input.worktreePath))
@@ -2549,7 +3183,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 });
+  mkdirSync3(dirname(input.worktreePath), { recursive: true });
   const branch = `baton/${input.sessionCode}`;
   const r = spawnSync2(
     "git",
@@ -2577,9 +3211,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) ? readFileSync5(path, "utf8") : "";
     if (current.split("\n").includes(pattern)) return;
-    mkdirSync(dirname(path), { recursive: true });
+    mkdirSync3(dirname(path), { recursive: true });
     const sep = current === "" || current.endsWith("\n") ? "" : "\n";
     appendFileSync(path, `${sep}${pattern}
 `, "utf8");
@@ -2603,7 +3237,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 = join7(here, "..", "..", "bin", "baton.mjs");
   return existsSync5(devShim) ? devShim : fileURLToPath(import.meta.url);
 };
 var runWorkerDaemon = async (cfg, client, signal) => {
@@ -2673,7 +3307,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 = join7(worktreeDir, slug(`${name}-${agentSessionId.slice(0, 8)}`));
       createWorktree({
         repo,
         worktreePath,
@@ -2684,7 +3318,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(join7(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg));
     spawnChild(sessionId, worktreePath);
   };
   const onStop = (sessionId) => {
@@ -2787,18 +3421,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 mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } 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 join8 } from "node:path";
+var machineIdPath = (env = process.env) => join8(env.XDG_DATA_HOME ?? join8(env.HOME ?? homedir3(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
   if (existsSync6(path)) {
-    const s = readFileSync4(path, "utf8").trim();
+    const s = readFileSync6(path, "utf8").trim();
     if (s) return s;
   }
   const id = randomUUID2();
-  mkdirSync2(dirname3(path), { recursive: true });
-  writeFileSync2(path, `${id}
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, `${id}
 `, "utf8");
   return id;
 };
@@ -3066,6 +3700,8 @@ var main = defineCommand({
     init,
     worker,
     session,
+    relay,
+    channel,
     workspace,
     project,
     requirement,