hermes-to-claude 0.1.0

package/dist/hbridge.mjs

@@ -0,0 +1,1677 @@
+#!/usr/bin/env node
+
+// src/hbridge/server.mjs
+import { createServer as http } from "http";
+
+// src/hbridge/bridge.mjs
+import { randomUUID } from "crypto";
+
+// src/hbridge/session.mjs
+import { spawn } from "child_process";
+
+// src/hbridge/transport/StdioTransport.mjs
+import { createInterface } from "readline";
+import { createWriteStream } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/hbridge/transport/SerialBatchEventUploader.mjs
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var RetryableError = class extends Error {
+  /**
+   * @param {string} message
+   * @param {number} [retryAfterMs]
+   */
+  constructor(message, retryAfterMs) {
+    super(message);
+    this.name = "RetryableError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var SerialBatchEventUploader = class {
+  /**
+   * @param {{
+   *   maxBatchSize: number
+   *   maxBatchBytes?: number
+   *   maxQueueSize: number
+   *   send: (batch: unknown[]) => Promise<void>
+   *   baseDelayMs: number
+   *   maxDelayMs: number
+   *   jitterMs: number
+   *   maxConsecutiveFailures?: number
+   *   onBatchDropped?: (batchSize: number, failures: number) => void
+   * }} config
+   */
+  constructor(config) {
+    this.pending = [];
+    this.pendingAtClose = 0;
+    this.draining = false;
+    this.closed = false;
+    this.backpressureResolvers = [];
+    this.flushResolvers = [];
+    this.droppedBatches = 0;
+    this._drainPromise = null;
+    this.config = {
+      maxBatchSize: config.maxBatchSize,
+      maxBatchBytes: config.maxBatchBytes,
+      maxQueueSize: config.maxQueueSize,
+      send: config.send,
+      baseDelayMs: config.baseDelayMs,
+      maxDelayMs: config.maxDelayMs,
+      jitterMs: config.jitterMs,
+      maxConsecutiveFailures: config.maxConsecutiveFailures,
+      onBatchDropped: config.onBatchDropped ?? (() => {
+      })
+    };
+  }
+  /** Monotonic count of batches dropped via maxConsecutiveFailures. */
+  get droppedBatchCount() {
+    return this.droppedBatches;
+  }
+  /** Pending queue depth. After close(), returns count at close time. */
+  get pendingCount() {
+    return this.closed ? this.pendingAtClose : this.pending.length;
+  }
+  /**
+   * Add events to the pending buffer. Returns immediately if space is
+   * available. Blocks (awaits) if the buffer is full — caller pauses until
+   * drain frees space.
+   *
+   * @param {...unknown} items
+   * @returns {Promise<void>}
+   */
+  async enqueue(...items) {
+    if (this.closed) return;
+    while (this.pending.length + items.length > this.config.maxQueueSize) {
+      if (this.closed) return;
+      await new Promise((resolve) => {
+        this.backpressureResolvers.push(resolve);
+      });
+    }
+    this.pending.push(...items);
+    this._kickDrain();
+  }
+  /**
+   * Block until all pending events are flushed. Resolves immediately when
+   * nothing is pending.
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    if (this.closed) return;
+    if (this.draining && this._drainPromise) {
+      await this._drainPromise;
+    }
+    if (this.pending.length === 0) return;
+    await new Promise((resolve) => {
+      this.flushResolvers.push(resolve);
+    });
+  }
+  /**
+   * Stop accepting new events and release resources. Best-effort drain of
+   * any remaining pending events.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.pendingAtClose = this.pending.length;
+    this.pending = [];
+    for (const resolve of this.backpressureResolvers) {
+      resolve();
+    }
+    this.backpressureResolvers = [];
+    for (const resolve of this.flushResolvers) {
+      resolve();
+    }
+    this.flushResolvers = [];
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  /** Start the drain loop if not already running. */
+  _kickDrain() {
+    if (this.draining || this.closed) return;
+    this.draining = true;
+    this._drainPromise = this._drainLoop();
+  }
+  async _drainLoop() {
+    while (!this.closed && this.pending.length > 0) {
+      const batch = this._takeBatch();
+      if (batch.length === 0) break;
+      let consecutiveFailures = 0;
+      let success = false;
+      while (!success && !this.closed) {
+        try {
+          await this.config.send(batch);
+          success = true;
+        } catch (err) {
+          consecutiveFailures++;
+          const maxFail = this.config.maxConsecutiveFailures;
+          if (maxFail !== void 0 && consecutiveFailures > maxFail) {
+            this.droppedBatches++;
+            this.config.onBatchDropped(batch.length, consecutiveFailures);
+            break;
+          }
+          let delayMs = this._backoffDelay(consecutiveFailures);
+          if (err instanceof RetryableError && err.retryAfterMs !== void 0) {
+            const clamped = Math.max(
+              this.config.baseDelayMs,
+              Math.min(err.retryAfterMs, this.config.maxDelayMs)
+            );
+            delayMs = clamped + (Math.random() - 0.5) * this.config.jitterMs;
+          }
+          await sleep(Math.max(0, delayMs));
+        }
+      }
+      this._releaseBackpressure();
+    }
+    this.draining = false;
+    for (const resolve of this.flushResolvers) {
+      resolve();
+    }
+    this.flushResolvers = [];
+  }
+  /**
+   * Take up to maxBatchSize (and maxBatchBytes) items from the pending buffer.
+   * @returns {unknown[]}
+   */
+  _takeBatch() {
+    const maxSize = this.config.maxBatchSize;
+    const maxBytes = this.config.maxBatchBytes;
+    const batch = [];
+    for (let i = 0; i < maxSize && this.pending.length > 0; i++) {
+      const item = this.pending.shift();
+      if (maxBytes !== void 0 && batch.length > 0) {
+        const itemStr = JSON.stringify(item);
+        const batchStr = JSON.stringify(batch) + "," + itemStr;
+        if (new TextEncoder().encode(batchStr).length > maxBytes) {
+          this.pending.unshift(item);
+          break;
+        }
+      }
+      batch.push(item);
+    }
+    return batch;
+  }
+  /**
+   * Exponential backoff with jitter.
+   * @param {number} attempt - 1-indexed attempt count
+   * @returns {number} delay in ms
+   */
+  _backoffDelay(attempt) {
+    const base = Math.min(
+      this.config.baseDelayMs * Math.pow(2, attempt - 1),
+      this.config.maxDelayMs
+    );
+    const jitter = (Math.random() - 0.5) * this.config.jitterMs;
+    return Math.max(0, base + jitter);
+  }
+  /** Wake up backpressure waiters now that space has freed. */
+  _releaseBackpressure() {
+    const free = this.config.maxQueueSize - this.pending.length;
+    const toRelease = Math.min(free, this.backpressureResolvers.length);
+    for (let i = 0; i < toRelease; i++) {
+      const resolve = this.backpressureResolvers.shift();
+      resolve?.();
+    }
+  }
+};
+
+// src/hbridge/transport/StdioTransport.mjs
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_QUEUE_SIZE = 1e4;
+var BASE_DELAY_MS = 200;
+var MAX_DELAY_MS = 4e3;
+var JITTER_MS = 500;
+var STATE = {
+  IDLE: "idle",
+  CONNECTED: "connected",
+  CLOSING: "closing",
+  CLOSED: "closed"
+};
+var StdioTransport = class {
+  /**
+   * @param {import('child_process').ChildProcess} child
+   * @param {object} [opts]
+   * @param {number} [opts.maxBatchSize=100] - Max items per stdin write
+   * @param {number} [opts.maxQueueSize=10000] - Max pending before backpressure
+   * @param {(err: Error) => void} [opts.onError] - Stderr parse error callback
+   */
+  constructor(child, opts = {}) {
+    this.child = child;
+    this._onData = null;
+    this._onClose = null;
+    this._onConnect = null;
+    this._state = STATE.IDLE;
+    this._onError = opts.onError ?? ((err) => {
+      process.stderr.write(`[StdioTransport] parse error: ${err.message}
+`);
+    });
+    this._transcriptPath = opts.transcriptPath;
+    if (this._transcriptPath === void 0) {
+      this._transcriptPath = join(homedir(), ".hbridge_transcript.jsonl");
+    }
+    this._transcriptStream = null;
+    this._uploader = new SerialBatchEventUploader({
+      maxBatchSize: opts.maxBatchSize ?? DEFAULT_BATCH_SIZE,
+      maxQueueSize: opts.maxQueueSize ?? DEFAULT_QUEUE_SIZE,
+      baseDelayMs: BASE_DELAY_MS,
+      maxDelayMs: MAX_DELAY_MS,
+      jitterMs: JITTER_MS,
+      send: (batch) => this._writeBatch(batch)
+    });
+  }
+  get droppedBatchCount() {
+    return this._uploader.droppedBatchCount;
+  }
+  // ── Transport interface ──────────────────────────────────────────────
+  /**
+   * Write a single message to stdin.
+   * @param {import('./types.mjs').StdoutMessage} message
+   * @returns {Promise<void>}
+   */
+  async write(message) {
+    await this._uploader.enqueue(message);
+  }
+  /**
+   * Write multiple messages as a batch (preserves order).
+   * @param {import('./types.mjs').StdoutMessage[]} messages
+   * @returns {Promise<void>}
+   */
+  async writeBatch(messages) {
+    await this._uploader.enqueue(...messages);
+  }
+  /** Graceful close — drains pending writes then releases resources. */
+  close() {
+    if (this._state === STATE.CLOSED || this._state === STATE.CLOSING) return;
+    this._state = STATE.CLOSING;
+    this._uploader.close();
+    if (this._transcriptStream) {
+      this._transcriptStream.end();
+      this._transcriptStream = null;
+    }
+    if (this._rl) {
+      this._rl.close();
+      this._rl = null;
+    }
+    this._state = STATE.CLOSED;
+    this._onClose?.(0);
+  }
+  /** @returns {string} */
+  getStateLabel() {
+    return this._state;
+  }
+  /** @returns {boolean} */
+  isConnectedStatus() {
+    return this._state === STATE.CONNECTED;
+  }
+  /**
+   * @param {import('./types.mjs').OnDataCallback} cb
+   */
+  setOnData(cb) {
+    this._onData = cb;
+  }
+  /**
+   * @param {import('./types.mjs').OnCloseCallback} cb
+   */
+  setOnClose(cb) {
+    this._onClose = cb;
+  }
+  /**
+   * @param {import('./types.mjs').OnConnectCallback} cb
+   */
+  setOnConnect(cb) {
+    this._onConnect = cb;
+  }
+  /** Initiate the connection — start reading stdout. */
+  connect() {
+    if (this._state !== STATE.IDLE) return;
+    this._state = STATE.CONNECTED;
+    this._rl = createInterface({ input: this.child.stdout });
+    if (this._transcriptPath) {
+      this._transcriptStream = createWriteStream(this._transcriptPath, { flags: "a" });
+      this._transcriptStream.on("error", (err) => {
+        process.stderr.write(`[StdioTransport] transcript error: ${err.message}
+`);
+        this._transcriptStream = null;
+      });
+    }
+    this._rl.on("line", (line) => {
+      if (this._transcriptStream) {
+        this._transcriptStream.write(line + "\n");
+      }
+      try {
+        this._onData?.(line);
+      } catch (err) {
+        this._onError(
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    });
+    this.child.stderr.on("data", (d) => {
+      process.stderr.write(`[claude] ${d.toString()}`);
+    });
+    this.child.on("error", (err) => {
+      this._state = STATE.CLOSED;
+      this._onClose?.(1);
+    });
+    this.child.on("close", (code) => {
+      this._state = STATE.CLOSED;
+      this._onClose?.(code ?? 1);
+    });
+    this._onConnect?.();
+  }
+  /**
+   * SSE-style sequence number (not used by stdio; always 0).
+   * @returns {number}
+   */
+  getLastSequenceNum() {
+    return 0;
+  }
+  // ── Internal ─────────────────────────────────────────────────────────
+  /**
+   * Safely JSON-stringify a message for NDJSON transport.
+   * Escapes U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR)
+   * which can break JavaScript readline line-splitting semantics.
+   * @param {unknown} msg
+   * @returns {string}
+   */
+  _ndjsonStringify(msg) {
+    const str = JSON.stringify(msg);
+    return str.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+  }
+  /**
+   * Actually write a batch of serialized JSON to stdin.
+   * Called by SerialBatchEventUploader.send().
+   * @param {unknown[]} batch
+   * @returns {Promise<void>}
+   */
+  async _writeBatch(batch) {
+    if (this._state === STATE.CLOSED || this._state === STATE.CLOSING) {
+      return;
+    }
+    let payload = "";
+    for (const msg of batch) {
+      payload += this._ndjsonStringify(msg) + "\n";
+    }
+    return new Promise((resolve, reject) => {
+      const canContinue = this.child.stdin.write(payload, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+      if (!canContinue) {
+        this.child.stdin.once("drain", resolve);
+      }
+    });
+  }
+};
+
+// src/hbridge/bridgeMessaging.mjs
+var BoundedUUIDSet = class {
+  /**
+   * @param {number} capacity
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.ring = new Array(capacity);
+    this.set = /* @__PURE__ */ new Set();
+    this.writeIdx = 0;
+  }
+  /**
+   * @param {string} uuid
+   */
+  add(uuid) {
+    if (this.set.has(uuid)) return;
+    const evicted = this.ring[this.writeIdx];
+    if (evicted !== void 0) {
+      this.set.delete(evicted);
+    }
+    this.ring[this.writeIdx] = uuid;
+    this.set.add(uuid);
+    this.writeIdx = (this.writeIdx + 1) % this.capacity;
+  }
+  /**
+   * @param {string} uuid
+   * @returns {boolean}
+   */
+  has(uuid) {
+    return this.set.has(uuid);
+  }
+  clear() {
+    this.set.clear();
+    this.ring.fill(void 0);
+    this.writeIdx = 0;
+  }
+};
+
+// src/hbridge/session.mjs
+var DEFAULT_TASK_TIMEOUT_MS = 0;
+var DEFAULT_MAX_AUTO_RESPOND = 5;
+var DEFAULT_PERMISSION_MODE = "approve";
+var Session = class {
+  /**
+   * @param {object} opts
+   * @param {string} opts.taskId
+   * @param {string} opts.prompt
+   * @param {string} [opts.cwd]
+   * @param {number} [opts.taskTimeoutMs]
+   * @param {number} [opts.maxAutoRespond]
+   * @param {"bypass"|"approve"} [opts.permissionMode]
+   * @param {(session: Session) => void} [opts.onComplete]
+   * @param {(session: Session, reason: string) => void} [opts.onError]
+   */
+  constructor(opts = {}) {
+    this.taskId = opts.taskId || "unknown";
+    this.prompt = opts.prompt || "";
+    this.status = "idle";
+    this.result = "";
+    this.exitCode = null;
+    this.usage = null;
+    this.startedAt = 0;
+    this._cwd = opts.cwd || void 0;
+    this._taskTimeoutMs = opts.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
+    this._maxAutoRespond = opts.maxAutoRespond ?? DEFAULT_MAX_AUTO_RESPOND;
+    this._skipPermissions = opts.skipPermissions === true;
+    this._permissionMode = opts.permissionMode ?? DEFAULT_PERMISSION_MODE;
+    this._onComplete = opts.onComplete || null;
+    this._onError = opts.onError || null;
+    this.child = null;
+    this.transport = null;
+    this._recentUUIDs = new BoundedUUIDSet(2e3);
+    this._subscribers = /* @__PURE__ */ new Set();
+    this._msgTextProgress = /* @__PURE__ */ new Map();
+    this._streamTextAccum = 0;
+    this._autoRespondCount = 0;
+    this._pendingPermission = null;
+    this._timeoutTimer = null;
+    this._resolveTask = null;
+    this._taskPromise = null;
+  }
+  // ── Public API ───────────────────────────────────────────────────────
+  /**
+   * Spawn Claude Code, connect transport, send prompt.
+   * Returns immediately — task runs asynchronously.
+   * @returns {Promise<{task_id: string, status: string}>}
+   */
+  async start() {
+    if (this.status !== "idle") {
+      throw new Error(`Session ${this.taskId} already started (${this.status})`);
+    }
+    this.status = "spawning";
+    this.startedAt = Date.now();
+    this.result = "";
+    this.exitCode = null;
+    this.usage = null;
+    this._autoRespondCount = 0;
+    this._msgTextProgress.clear();
+    this._streamTextAccum = 0;
+    const cwd = this._cwd || process.cwd();
+    const isWin = process.platform === "win32";
+    const claudeArgs = [
+      "@anthropic-ai/claude-code",
+      "--print",
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    if (this._skipPermissions) claudeArgs.push("--dangerously-skip-permissions");
+    const cmd2 = isWin ? "cmd.exe" : "npx";
+    const args2 = isWin ? ["/d", "/s", "/c", `npx.cmd ${claudeArgs.join(" ")}`] : claudeArgs;
+    try {
+      this.child = spawn(cmd2, args2, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd,
+        env: { ...process.env }
+      });
+    } catch (err) {
+      process.stderr.write(`[session] spawn error: ${err.message}
+`);
+      this.status = "failed";
+      this.result = err.message;
+      this.exitCode = 1;
+      this._notifyError(err.message);
+      return { task_id: this.taskId, status: "failed" };
+    }
+    this.transport = new StdioTransport(this.child, { transcriptPath: null });
+    this.transport.setOnData((line) => {
+      try {
+        const LS = String.fromCharCode(8232);
+        const PS = String.fromCharCode(8233);
+        const sanitized = line.replaceAll(LS, "\\u2028").replaceAll(PS, "\\u2029");
+        const msg2 = JSON.parse(sanitized);
+        this._onMessage(msg2);
+      } catch (e) {
+        process.stderr.write(`[claude:stdout] non-JSON (${line.length}B): ${line.slice(0, 200)}
+`);
+      }
+    });
+    this.transport.setOnClose((code) => {
+      process.stderr.write(`[session] ${this.taskId}: transport closed (code=${code})
+`);
+      if (this.status === "running" || this.status === "spawning") {
+        this._failTask(`Claude process exited (code=${code})`);
+      }
+    });
+    this.transport.connect();
+    this.status = "running";
+    if (this._taskTimeoutMs > 0) {
+      this._timeoutTimer = setTimeout(() => {
+        process.stderr.write(`[session] ${this.taskId}: timeout after ${this._taskTimeoutMs / 1e3}s
+`);
+        this._failTask("timeout");
+      }, this._taskTimeoutMs);
+    }
+    this._taskPromise = new Promise((resolve) => {
+      this._resolveTask = resolve;
+    });
+    const msg = {
+      type: "user",
+      session_id: "",
+      message: { role: "user", content: this.prompt },
+      parent_tool_use_id: null
+    };
+    try {
+      await this.transport.write(msg);
+    } catch (err) {
+      process.stderr.write(`[session] ${this.taskId}: transport write error: ${err.message}
+`);
+      this._failTask(`write error: ${err.message}`);
+    }
+    return { task_id: this.taskId, status: "created" };
+  }
+  /**
+   * Cancel the running task.
+   * @returns {boolean}
+   */
+  cancel() {
+    if (this.status !== "running") return false;
+    process.stderr.write(`[session] cancelling task ${this.taskId}
+`);
+    this.transport?.write({
+      type: "control_request",
+      request_id: `cancel_${this.taskId}`,
+      request: { subtype: "interrupt" }
+    }).catch(() => {
+    });
+    setTimeout(() => {
+      if (this.child && !this.child.killed) {
+        try {
+          this.child.kill();
+        } catch {
+        }
+      }
+    }, 500);
+    this._failTask("cancelled");
+    return true;
+  }
+  /**
+   * Respond to a pending permission request (can_use_tool).
+   * @param {"allow"|"deny"} behavior
+   * @param {object} [updatedInput] - Modified tool input for "allow"
+   * @param {string} [message] - Denial reason for "deny"
+   * @returns {boolean} true if a pending request was responded to
+   */
+  respondPermission(behavior, updatedInput, message) {
+    if (!this._pendingPermission) return false;
+    const req = this._pendingPermission;
+    this._pendingPermission = null;
+    const payload = behavior === "allow" ? { behavior: "allow", updatedInput: updatedInput || req.input } : { behavior: "deny", message: message || "Permission denied by Hermes" };
+    process.stderr.write(`[session] ${this.taskId} permission: ${behavior} for ${req.toolName}
+`);
+    this.transport?.write({
+      type: "control_response",
+      response_id: req.requestId,
+      response: { subtype: "success", response: payload }
+    }).catch(() => {
+    });
+    return true;
+  }
+  /** @returns {object|null} The pending permission request, if any */
+  getPendingPermission() {
+    return this._pendingPermission;
+  }
+  // ── SSE subscribers ─────────────────────────────────────────────────
+  /** @param {{ write: (data: string) => void }} subscriber */
+  subscribe(subscriber) {
+    this._subscribers.add(subscriber);
+  }
+  /** @param {{ write: (data: string) => void }} subscriber */
+  unsubscribe(subscriber) {
+    this._subscribers.delete(subscriber);
+  }
+  // ── Internal: message handling ──────────────────────────────────────
+  /**
+   * Handle a parsed NDJSON message from Claude's stdout.
+   * @param {Record<string,unknown>} msg
+   */
+  _onMessage(msg) {
+    process.stderr.write(`[session:msg] ${this.taskId} role=${msg.role || msg.type || "?"}
+`);
+    if (msg.uuid && this._recentUUIDs.has(
+      /** @type {string} */
+      msg.uuid
+    )) return;
+    if (msg.uuid) this._recentUUIDs.add(
+      /** @type {string} */
+      msg.uuid
+    );
+    if (msg.type === "keep_alive") return;
+    if (msg.type === "system" && msg.subtype === "init") return;
+    if (msg.type === "control_request") {
+      const reqId = (
+        /** @type {string} */
+        msg.request_id ?? ""
+      );
+      const subtype = (
+        /** @type {string|undefined} */
+        msg.request?.subtype
+      );
+      process.stderr.write(`[session] ${this.taskId} control_request: ${subtype || "?"} (id=${reqId})
+`);
+      if (subtype === "can_use_tool") {
+        if (this._permissionMode === "bypass") {
+          process.stderr.write(`[session] ${this.taskId} bypass permission: ${msg.request?.tool_name ?? ""}
+`);
+          this.transport?.write({
+            type: "control_response",
+            response_id: reqId,
+            response: {
+              subtype: "success",
+              response: { behavior: "allow", updatedInput: msg.request?.input ?? {} }
+            }
+          }).catch(() => {
+          });
+          return;
+        }
+        this._pendingPermission = {
+          requestId: reqId,
+          toolName: (
+            /** @type {string} */
+            msg.request?.tool_name ?? ""
+          ),
+          input: msg.request?.input ?? {},
+          toolUseId: (
+            /** @type {string} */
+            msg.request?.tool_use_id ?? ""
+          ),
+          timestamp: Date.now()
+        };
+        process.stderr.write(`[session] ${this.taskId} awaiting permission: ${this._pendingPermission.toolName}
+`);
+        this._emitTaskEvent("permission_request", {
+          request_id: reqId,
+          task_id: this.taskId,
+          tool_name: this._pendingPermission.toolName,
+          input: this._pendingPermission.input,
+          tool_use_id: this._pendingPermission.toolUseId
+        });
+        return;
+      }
+      this.transport?.write({
+        type: "control_response",
+        response_id: reqId,
+        response: { subtype: "success" }
+      }).catch(() => {
+      });
+      return;
+    }
+    if (msg.type === "tool_progress") {
+      const toolName = (
+        /** @type {string} */
+        msg.tool_name ?? ""
+      );
+      const elapsed = (
+        /** @type {number} */
+        msg.elapsed_time_seconds ?? 0
+      );
+      process.stderr.write(`[session] ${this.taskId} tool_progress: ${toolName} ${elapsed}s
+`);
+      this._emitTaskEvent("tool_progress", { tool_name: toolName, elapsed });
+      return;
+    }
+    if (msg.type === "auth_status") {
+      if (msg.isAuthenticating) process.stderr.write(`[session] ${this.taskId} auth: authenticating...
+`);
+      if (msg.error) process.stderr.write(`[session] ${this.taskId} auth error: ${msg.error}
+`);
+      return;
+    }
+    if (msg.type === "rate_limit_event") {
+      const status = (
+        /** @type {string|undefined} */
+        msg.rate_limit_info?.status
+      );
+      process.stderr.write(`[session] ${this.taskId} rate_limit: ${status || "?"}
+`);
+      return;
+    }
+    if (msg.type === "session_state_changed") {
+      const state = (
+        /** @type {string|undefined} */
+        msg.state
+      );
+      process.stderr.write(`[session] ${this.taskId} session_state: ${state}
+`);
+      if (state === "idle") {
+        process.stderr.write(`[session] ${this.taskId} session idle \u2192 finishing
+`);
+        this._finishTask(0);
+      }
+      return;
+    }
+    if (msg.type === "stream_event") {
+      const event = (
+        /** @type {any} */
+        msg.event
+      );
+      if (event?.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+        const delta = (
+          /** @type {string} */
+          event.delta.text
+        );
+        this.result += delta;
+        this._streamTextAccum += delta.length;
+        this._emitChunk(delta);
+      }
+      return;
+    }
+    const msgId = (
+      /** @type {string|undefined} */
+      msg.message?.id || msg.id
+    );
+    const blocks = msg.content || msg.message && msg.message.content;
+    if (blocks) {
+      let fullText = "";
+      for (const block of blocks) {
+        if (block.type === "text") {
+          fullText += block.text;
+        } else if (block.type === "tool_use") {
+          fullText += `
+<tool_use name="${block.name}">
+${JSON.stringify(block.input)}
+</tool_use>
+`;
+        } else if (block.type === "tool_result") {
+          let resultText = "";
+          if (typeof block.content === "string") {
+            resultText = block.content;
+          } else if (Array.isArray(block.content)) {
+            for (const item of block.content) {
+              if (item.type === "text") resultText += item.text;
+            }
+          }
+          fullText += `
+<tool_result>
+${resultText}
+</tool_result>
+`;
+        }
+      }
+      if (fullText) {
+        let delta;
+        if (msgId) {
+          const prev = this._msgTextProgress.get(msgId);
+          const prevText = prev?.lastText || "";
+          delta = fullText.slice(prevText.length);
+          if (prev) {
+            prev.lastText = fullText;
+          } else {
+            this._msgTextProgress.set(msgId, { lastText: fullText });
+          }
+        } else {
+          delta = fullText.slice(this._streamTextAccum);
+        }
+        if (delta) {
+          this.result += delta;
+          this._emitChunk(delta);
+        }
+      }
+    }
+    if (msg.type === "user") {
+      if (this._autoRespondCount < this._maxAutoRespond) {
+        this._autoRespondCount++;
+        process.stderr.write(`[session] ${this.taskId} auto-respond #${this._autoRespondCount}/${this._maxAutoRespond}
+`);
+        this.transport?.write({
+          type: "user",
+          session_id: (
+            /** @type {string} */
+            msg.session_id ?? ""
+          ),
+          message: { role: "user", content: "Continue. Do not ask for confirmation." },
+          parent_tool_use_id: null
+        }).catch(() => {
+        });
+      }
+      return;
+    }
+    if (msg.stop_reason || msg.type === "result") {
+      const totalCostUsd = (
+        /** @type {number|undefined} */
+        msg.total_cost_usd
+      );
+      const usage = (
+        /** @type {Record<string,number>|undefined} */
+        msg.usage
+      );
+      if (totalCostUsd !== void 0 || usage !== void 0) {
+        this.usage = {
+          total_cost_usd: totalCostUsd ?? 0,
+          input_tokens: usage?.input_tokens ?? 0,
+          output_tokens: usage?.output_tokens ?? 0,
+          cache_creation_input_tokens: usage?.cache_creation_input_tokens ?? 0,
+          cache_read_input_tokens: usage?.cache_read_input_tokens ?? 0
+        };
+        process.stderr.write(
+          `[session] ${this.taskId} usage: $${this.usage.total_cost_usd} (in=${this.usage.input_tokens} out=${this.usage.output_tokens} cache_creation=${this.usage.cache_creation_input_tokens} cache_read=${this.usage.cache_read_input_tokens})
+`
+        );
+      }
+      const isError = typeof msg.subtype === "string" && msg.subtype.startsWith("error_");
+      this._finishTask(isError ? 1 : 0);
+    }
+  }
+  // ── Internal: lifecycle helpers ─────────────────────────────────────
+  _finishTask(exitCode) {
+    if (this.status === "done" || this.status === "failed") return;
+    this.status = "done";
+    this.exitCode = exitCode;
+    this._clearTimeout();
+    this._emitDone(exitCode);
+    this._cleanupSubscribers();
+    this._cleanup();
+    if (this._resolveTask) {
+      this._resolveTask();
+      this._resolveTask = null;
+    }
+    this._onComplete?.(this);
+  }
+  _failTask(reason) {
+    if (this.status === "done" || this.status === "failed") return;
+    this.status = "failed";
+    this.result = reason;
+    this.exitCode = 1;
+    this._clearTimeout();
+    this._emitError(reason);
+    this._cleanupSubscribers();
+    this._cleanup();
+    if (this._resolveTask) {
+      this._resolveTask();
+      this._resolveTask = null;
+    }
+    this._onError?.(this, reason);
+  }
+  _cleanup() {
+    if (this.transport) {
+      try {
+        this.transport.close();
+      } catch {
+      }
+      this.transport = null;
+    }
+    if (this.child && !this.child.killed) {
+      try {
+        this.child.kill();
+      } catch {
+      }
+    }
+    this.child = null;
+  }
+  _clearTimeout() {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+  }
+  // ── Internal: SSE emit helpers ─────────────────────────────────────
+  _emitChunk(text) {
+    const sse = `data: ${JSON.stringify({ type: "chunk", text })}
+
+`;
+    for (const sub of this._subscribers) {
+      try {
+        sub.write(sse);
+      } catch {
+      }
+    }
+  }
+  _emitTaskEvent(eventType, data) {
+    const sse = `data: ${JSON.stringify({ type: eventType, ...data })}
+
+`;
+    for (const sub of this._subscribers) {
+      try {
+        sub.write(sse);
+      } catch {
+      }
+    }
+  }
+  _emitDone(exitCode) {
+    const sse = `data: ${JSON.stringify({ type: "done", exitCode })}
+
+`;
+    for (const sub of this._subscribers) {
+      try {
+        sub.write(sse);
+      } catch {
+      }
+    }
+  }
+  _emitError(reason) {
+    const sse = `data: ${JSON.stringify({ type: "error", reason })}
+
+`;
+    for (const sub of this._subscribers) {
+      try {
+        sub.write(sse);
+      } catch {
+      }
+    }
+  }
+  _cleanupSubscribers() {
+    this._subscribers.clear();
+  }
+  /** @param {string} reason */
+  _notifyError(reason) {
+    this._onError?.(this, reason);
+  }
+};
+
+// src/hbridge/persistence.mjs
+import { readFileSync, appendFileSync, writeFileSync, existsSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var TASKS_FILE = join2(homedir2(), ".hbridge_tasks.jsonl");
+var MAX_TASKS = 2e3;
+function appendCompletedTask(task) {
+  if (!task || !task.id) return;
+  const record = {
+    id: task.id,
+    prompt: task.prompt || "",
+    status: task.status || "unknown",
+    result: task.result || "",
+    exitCode: task.exitCode ?? null,
+    usage: task.usage ?? null,
+    completedAt: Date.now()
+  };
+  try {
+    appendFileSync(TASKS_FILE, JSON.stringify(record) + "\n", "utf8");
+  } catch (e) {
+    process.stderr.write(`[persistence] append error: ${e.message}
+`);
+  }
+}
+function loadCompletedTasks() {
+  if (!existsSync(TASKS_FILE)) return [];
+  try {
+    const content = readFileSync(TASKS_FILE, "utf8");
+    const tasks = [];
+    for (const line of content.split("\n").filter(Boolean)) {
+      try {
+        tasks.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return tasks;
+  } catch {
+    return [];
+  }
+}
+function findCompletedTask(taskId) {
+  if (!existsSync(TASKS_FILE)) return null;
+  try {
+    const content = readFileSync(TASKS_FILE, "utf8");
+    for (const line of content.split("\n").filter(Boolean)) {
+      try {
+        const task = JSON.parse(line);
+        if (task.id === taskId) return task;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function trimCompletedTasks() {
+  if (!existsSync(TASKS_FILE)) return;
+  try {
+    const content = readFileSync(TASKS_FILE, "utf8");
+    const lines = content.split("\n").filter(Boolean);
+    if (lines.length <= MAX_TASKS) return;
+    const trimmed = lines.slice(lines.length - MAX_TASKS);
+    writeFileSync(TASKS_FILE, trimmed.join("\n") + "\n", "utf8");
+    process.stderr.write(`[persistence] trimmed ${lines.length - trimmed.length} tasks (${trimmed.length} kept)
+`);
+  } catch {
+  }
+}
+
+// src/hbridge/state.mjs
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var STATE_FILE = join3(homedir3(), ".hbridge_state.json");
+var DEFAULT_STATE = {
+  running: false,
+  port: 9190,
+  tasks: 0,
+  startedAt: 0,
+  updatedAt: 0,
+  lastClientIP: "",
+  lastActiveAt: 0
+};
+function readState() {
+  if (!existsSync2(STATE_FILE)) return { ...DEFAULT_STATE };
+  try {
+    return { ...DEFAULT_STATE, ...JSON.parse(readFileSync2(STATE_FILE, "utf8")) };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function writeState(partial) {
+  const current = readState();
+  const next = { ...current, ...partial, updatedAt: Date.now() };
+  writeFileSync2(STATE_FILE, JSON.stringify(next, null, 2));
+  return next;
+}
+function markRunning(port) {
+  return writeState({ running: true, port, startedAt: Date.now() });
+}
+function markStopped() {
+  return writeState({ running: false, port: 9190, tasks: 0 });
+}
+function incrementTasks() {
+  const s = readState();
+  return writeState({ tasks: s.tasks + 1 });
+}
+
+// src/hbridge/bridge.mjs
+var DEFAULT_MAX_CONCURRENT = 3;
+var TRIM_INTERVAL = 100;
+var Bridge = class {
+  /**
+   * @param {object} [opts]
+   * @param {number} [opts.maxConcurrent] - Max parallel sessions (default 3)
+   * @param {number} [opts.taskTimeoutMs] - Per-task timeout (0 = no timeout)
+   * @param {"bypass"|"approve"} [opts.permissionMode] - Default permission mode (default "approve")
+   * @param {string} [opts.cwd] - Default working directory
+   */
+  constructor(opts = {}) {
+    this._maxConcurrent = opts.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this._taskTimeoutMs = opts.taskTimeoutMs ?? 0;
+    this._permissionMode = opts.permissionMode ?? "approve";
+    this._cwd = opts.cwd || void 0;
+    this._sessions = /* @__PURE__ */ new Map();
+    this._pendingQueue = [];
+    this._completedTasks = /* @__PURE__ */ new Map();
+    this._taskSubscribers = /* @__PURE__ */ new Map();
+    this._persistCount = 0;
+    this._loadPersistedTasks();
+  }
+  // ── Public API ───────────────────────────────────────────────────────
+  /**
+   * Create a new task. Spawns a Claude process or queues if at capacity.
+   * @param {string} prompt
+   * @param {string} [taskId]
+   * @param {{ cwd?: string, sessionId?: string, permissionMode?: "bypass"|"approve" }} [opts]
+   * @returns {Promise<{task_id: string, status: string}>}
+   */
+  async createTask(prompt, taskId, opts = {}) {
+    const id = taskId || `task_${randomUUID()}`;
+    if (this._sessions.size < this._maxConcurrent) {
+      return this._startSession(prompt, id, opts);
+    }
+    return new Promise((resolve, reject) => {
+      this._pendingQueue.push({ prompt, taskId: id, opts, resolve, reject });
+    });
+  }
+  /**
+   * Cancel a running or queued task.
+   * @param {string} taskId
+   * @param {{ sessionId?: string }} [_opts] - Ignored (kept for compat)
+   * @returns {boolean}
+   */
+  cancelTask(taskId, _opts) {
+    const session = this._sessions.get(taskId);
+    if (session) {
+      session.cancel();
+      this._removeSession(taskId);
+      return true;
+    }
+    const qIdx = this._pendingQueue.findIndex((item) => item.taskId === taskId);
+    if (qIdx !== -1) {
+      const item = this._pendingQueue[qIdx];
+      this._pendingQueue.splice(qIdx, 1);
+      item.reject(new Error("cancelled"));
+      return true;
+    }
+    if (this._completedTasks.has(taskId)) {
+      this._completedTasks.delete(taskId);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get task info (no result text).
+   * @param {string} taskId
+   * @param {{ sessionId?: string }} [_opts] - Ignored (kept for compat)
+   * @returns {object|null}
+   */
+  getTask(taskId, _opts) {
+    const session = this._sessions.get(taskId);
+    if (session) {
+      return {
+        id: session.taskId,
+        status: session.status,
+        created: session.startedAt,
+        usage: session.usage ?? null
+      };
+    }
+    const cached = this._completedTasks.get(taskId);
+    if (cached) {
+      return {
+        id: cached.id,
+        status: cached.status,
+        created: cached.completedAt || 0,
+        usage: cached.usage ?? null
+      };
+    }
+    const persisted = findCompletedTask(taskId);
+    if (persisted) {
+      return {
+        id: persisted.id,
+        status: persisted.status,
+        created: persisted.completedAt || 0,
+        usage: persisted.usage ?? null
+      };
+    }
+    return null;
+  }
+  /**
+   * Get task output (includes result text).
+   * @param {string} taskId
+   * @param {{ sessionId?: string }} [_opts] - Ignored (kept for compat)
+   * @returns {object|null}
+   */
+  getTaskOutput(taskId, _opts) {
+    const session = this._sessions.get(taskId);
+    if (session) {
+      const done = session.status === "done" || session.status === "failed";
+      return {
+        retrieval_status: done ? "success" : "pending",
+        task: {
+          id: session.taskId,
+          status: session.status,
+          result: session.result || "",
+          exitCode: session.exitCode ?? null,
+          usage: session.usage ?? null
+        }
+      };
+    }
+    const cached = this._completedTasks.get(taskId);
+    if (cached) {
+      return {
+        retrieval_status: "success",
+        task: {
+          id: cached.id,
+          status: cached.status,
+          result: cached.result || "",
+          exitCode: cached.exitCode ?? null,
+          usage: cached.usage ?? null
+        }
+      };
+    }
+    const persisted = findCompletedTask(taskId);
+    if (persisted) {
+      return {
+        retrieval_status: "success",
+        task: {
+          id: persisted.id,
+          status: persisted.status,
+          result: persisted.result || "",
+          exitCode: persisted.exitCode ?? null,
+          usage: persisted.usage ?? null
+        }
+      };
+    }
+    return null;
+  }
+  /**
+   * Subscribe to SSE streaming for a task.
+   * @param {string} taskId
+   * @param {{ write: (data: string) => void }} subscriber
+   */
+  subscribeTask(taskId, subscriber) {
+    const session = this._sessions.get(taskId);
+    if (session) {
+      session.subscribe(subscriber);
+      return;
+    }
+    if (!this._taskSubscribers.has(taskId)) {
+      this._taskSubscribers.set(taskId, /* @__PURE__ */ new Set());
+    }
+    this._taskSubscribers.get(taskId).add(subscriber);
+  }
+  /**
+   * Unsubscribe from SSE streaming for a task.
+   * @param {string} taskId
+   * @param {{ write: (data: string) => void }} subscriber
+   */
+  unsubscribeTask(taskId, subscriber) {
+    const session = this._sessions.get(taskId);
+    if (session) {
+      session.unsubscribe(subscriber);
+      return;
+    }
+    const subs = this._taskSubscribers.get(taskId);
+    if (subs) {
+      subs.delete(subscriber);
+      if (subs.size === 0) this._taskSubscribers.delete(taskId);
+    }
+  }
+  /**
+   * Get active session count.
+   * @returns {number}
+   */
+  getActiveCount() {
+    return this._sessions.size;
+  }
+  /**
+   * Get pending queue depth.
+   * @returns {number}
+   */
+  getQueueDepth() {
+    return this._pendingQueue.length;
+  }
+  /**
+   * Respond to a pending permission request for a task.
+   * @param {string} taskId
+   * @param {"allow"|"deny"} behavior
+   * @param {object} [updatedInput]
+   * @param {string} [message]
+   * @returns {boolean}
+   */
+  respondPermission(taskId, behavior, updatedInput, message) {
+    const session = this._sessions.get(taskId);
+    if (!session) return false;
+    return session.respondPermission(behavior, updatedInput, message);
+  }
+  /**
+   * Get pending permission request for a task.
+   * @param {string} taskId
+   * @returns {object|null}
+   */
+  getPendingPermission(taskId) {
+    const session = this._sessions.get(taskId);
+    if (!session) return null;
+    return session.getPendingPermission();
+  }
+  // ── Internal ─────────────────────────────────────────────────────────
+  /**
+   * Start a new session for a task.
+   * @param {string} prompt
+   * @param {string} taskId
+   * @param {object} opts
+   * @returns {Promise<{task_id: string, status: string}>}
+   */
+  async _startSession(prompt, taskId, opts) {
+    const session = new Session({
+      taskId,
+      prompt,
+      cwd: opts?.cwd || this._cwd,
+      taskTimeoutMs: this._taskTimeoutMs,
+      permissionMode: opts?.permissionMode || this._permissionMode,
+      skipPermissions: opts?.skipPermissions === true,
+      onComplete: (s) => this._onSessionComplete(s),
+      onError: (s, reason) => this._onSessionError(s, reason)
+    });
+    this._sessions.set(taskId, session);
+    const pendingSubs = this._taskSubscribers.get(taskId);
+    if (pendingSubs) {
+      for (const sub of pendingSubs) {
+        session.subscribe(sub);
+      }
+      this._taskSubscribers.delete(taskId);
+    }
+    writeState({ latestTask: { id: taskId, prompt, status: "running" } });
+    const result = await session.start();
+    return result;
+  }
+  /** @param {import("./session.mjs").Session} session */
+  _onSessionComplete(session) {
+    const record = {
+      id: session.taskId,
+      prompt: session.prompt,
+      status: "done",
+      result: session.result || "",
+      exitCode: session.exitCode ?? 0,
+      usage: session.usage ?? null,
+      completedAt: Date.now()
+    };
+    this._completedTasks.set(session.taskId, record);
+    appendCompletedTask(record);
+    writeState({ latestTask: { id: session.taskId, prompt: session.prompt, status: "done", exitCode: session.exitCode } });
+    this._removeSession(session.taskId);
+    this._persistCount++;
+    if (this._persistCount % TRIM_INTERVAL === 0) {
+      trimCompletedTasks();
+    }
+    this._dequeueNext();
+  }
+  /** @param {import("./session.mjs").Session} session */
+  _onSessionError(session, reason) {
+    const record = {
+      id: session.taskId,
+      prompt: session.prompt,
+      status: "failed",
+      result: reason || "",
+      exitCode: 1,
+      usage: null,
+      completedAt: Date.now()
+    };
+    this._completedTasks.set(session.taskId, record);
+    appendCompletedTask(record);
+    writeState({ latestTask: { id: session.taskId, prompt: session.prompt, status: "failed" } });
+    this._removeSession(session.taskId);
+    this._dequeueNext();
+  }
+  /** @param {string} taskId */
+  _removeSession(taskId) {
+    this._sessions.delete(taskId);
+  }
+  /** Start the next queued task if capacity allows. */
+  _dequeueNext() {
+    while (this._sessions.size < this._maxConcurrent && this._pendingQueue.length > 0) {
+      const item = this._pendingQueue.shift();
+      if (!item) break;
+      this._startSession(item.prompt, item.taskId, item.opts).then((r) => item.resolve(r)).catch((e) => item.reject(e));
+    }
+  }
+  /** Load persisted tasks from disk into memory cache. */
+  _loadPersistedTasks() {
+    try {
+      const tasks = loadCompletedTasks();
+      const maxCached = 500;
+      const recent = tasks.slice(-maxCached);
+      for (const t of recent) {
+        this._completedTasks.set(t.id, t);
+      }
+      if (tasks.length > 0) {
+        process.stderr.write(`[bridge] loaded ${tasks.length} persisted tasks (cached ${recent.length})
+`);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/hbridge/home.mjs
+import { createHash, randomBytes } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var BASE52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var KEY_FILE = join4(homedir4(), ".hbridge_key");
+function isHome() {
+  return process.env.HBRIDGE_HOME == 1;
+}
+function homePort(cwd) {
+  const hash = createHash("md5").update(Buffer.from(cwd, "utf-8")).digest();
+  return 9200 + hash.readUInt16BE(0) % 600;
+}
+function homeKey(_cwd) {
+  if (existsSync3(KEY_FILE)) {
+    const existing = readFileSync3(KEY_FILE, "utf8").trim();
+    if (existing && existing.startsWith("hb_")) {
+      return existing;
+    }
+  }
+  const bytes = randomBytes(8);
+  let key = "hb_";
+  for (const byte of bytes) {
+    key += BASE52[byte % 52];
+  }
+  writeFileSync3(KEY_FILE, key, "utf8");
+  return key;
+}
+
+// src/hbridge/server.mjs
+var taskCount = 0;
+var startTime = Date.now();
+function createServer(expectedKey, bridge = new Bridge()) {
+  return http((req, res) => {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      return res.end();
+    }
+    if (req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ status: "ok" }));
+    }
+    if (!isHome()) {
+      const auth = req.headers["authorization"] || "";
+      const providedKey = Buffer.from(auth.split(" ")[1] || "", "base64").toString().split(":")[1];
+      console.error(`AUTH: key_match=${providedKey === expectedKey}`);
+      if (providedKey !== expectedKey) {
+        res.writeHead(401);
+        return res.end("Unauthorized");
+      }
+    }
+    const clientIP = req.socket.remoteAddress?.replace(/^::ffff:/, "") || "unknown";
+    writeState({ lastClientIP: clientIP, lastActiveAt: Date.now() });
+    const isPost = req.method === "POST";
+    let body = "";
+    async function handle() {
+      try {
+        let result = {};
+        let status = 200;
+        const payload = body ? JSON.parse(body) : {};
+        const [_, v, endpoint, actionRaw, subactionRaw] = req.url.split("/");
+        const action = actionRaw ? actionRaw.split("?")[0] : "";
+        const subaction = subactionRaw ? subactionRaw.split("?")[0] : "";
+        if (endpoint === "task" && action === "output" && subaction === "stream") {
+          const taskId = new URL(`http://localhost${req.url}`).searchParams.get("task_id");
+          if (!taskId) {
+            status = 400;
+            result = { error: "task_id required" };
+          } else {
+            res.writeHead(200, {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive",
+              "X-Accel-Buffering": "no"
+            });
+            res.write(`data: ${JSON.stringify({ type: "connected", taskId })}
+
+`);
+            const subscriber = {
+              write: (data) => {
+                try {
+                  res.write(data);
+                } catch {
+                  cleanup();
+                }
+              }
+            };
+            const cleanup = () => {
+              try {
+                bridge.unsubscribeTask(taskId, subscriber);
+              } catch {
+              }
+              try {
+                res.end();
+              } catch {
+              }
+            };
+            bridge.subscribeTask(taskId, subscriber);
+            req.on("close", cleanup);
+            return;
+          }
+        } else if (endpoint === "task" && action === "create" && isPost) {
+          taskCount++;
+          incrementTasks();
+          const taskId = `task_${Date.now()}_${taskCount}`;
+          const createOpts = {};
+          if (payload.sessionId) createOpts.sessionId = payload.sessionId;
+          if (payload.permission_mode) createOpts.permissionMode = payload.permission_mode;
+          if (payload.skip_permissions) createOpts.skipPermissions = true;
+          result = { task_id: taskId, status: "created" };
+          bridge.createTask(payload.prompt, taskId, createOpts).catch((err) => {
+            console.error(`[server] task ${taskId} error: ${err.message}`);
+          });
+        } else if (endpoint === "task" && action === "cancel" && isPost) {
+          const taskId = payload.task_id;
+          if (!taskId) {
+            status = 400;
+            result = { error: "task_id required" };
+          } else {
+            const cancelOpts = {};
+            if (payload.sessionId) cancelOpts.sessionId = payload.sessionId;
+            const ok = bridge.cancelTask(taskId, cancelOpts);
+            result = ok ? { status: "cancelled", task_id: taskId } : { error: "not_found" };
+          }
+        } else if (endpoint === "task" && action === "permission" && isPost) {
+          const taskId = payload.task_id;
+          if (!taskId || !payload.behavior) {
+            status = 400;
+            result = { error: "task_id and behavior required" };
+          } else if (!["allow", "deny"].includes(payload.behavior)) {
+            status = 400;
+            result = { error: 'behavior must be "allow" or "deny"' };
+          } else {
+            const ok = bridge.respondPermission(taskId, payload.behavior, payload.updatedInput, payload.message);
+            result = ok ? { status: "responded", task_id: taskId } : { error: "no_pending_request" };
+          }
+        } else if (endpoint === "task" && action === "output") {
+          const taskId = new URL(`http://localhost${req.url}`).searchParams.get("task_id");
+          result = bridge.getTaskOutput(taskId) || { error: "not_found" };
+        } else if (endpoint === "task") {
+          const taskId = new URL(`http://localhost${req.url}`).searchParams.get("task_id");
+          result = bridge.getTask(taskId) || { error: "not_found" };
+        } else {
+          status = 404;
+          result = { error: "not_found" };
+        }
+        res.writeHead(status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+      } catch (e) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    }
+    if (isPost) {
+      req.on("data", (d) => body += d);
+      req.on("end", handle);
+    } else {
+      handle();
+    }
+  });
+}
+function startStatusBar(port) {
+  function render() {
+    const uptime = Math.floor((Date.now() - startTime) / 6e4);
+    process.stdout.write(`\r  hbridge: on | port: ${port} | ${taskCount} tasks | \u2191 ${uptime}min  `);
+  }
+  render();
+  return setInterval(render, 5e3);
+}
+function stopStatusBar(intervalId) {
+  clearInterval(intervalId);
+}
+
+// src/hbridge/cli.mjs
+import { networkInterfaces } from "os";
+var HBRIDGE_VERSION = "v177.0.c21a99a";
+var server = null;
+var statusBarInterval = null;
+function getLocalIPs() {
+  return Object.values(networkInterfaces()).flat().filter((n) => n.family === "IPv4" && !n.internal).map((n) => n.address);
+}
+async function cmd_enable() {
+  const cwd = process.cwd();
+  const port = homePort(cwd);
+  const key = homeKey(cwd);
+  const ips = getLocalIPs();
+  const ip = isHome() ? "127.0.0.1" : ips[0] || "127.0.0.1";
+  console.log("hbridge enabled");
+  console.log("\u{1F4C2} " + cwd);
+  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + HBRIDGE_VERSION);
+  server = createServer(key);
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      process.stderr.write(`Port ${port} already in use \u2014 hbridge may already be running
+`);
+    } else {
+      process.stderr.write(`Server error: ${err.message}
+`);
+    }
+  });
+  server.listen(port, isHome() ? "127.0.0.1" : void 0);
+  markRunning(port);
+  statusBarInterval = startStatusBar(port);
+  process.stdin.resume();
+}
+function cmd_disable() {
+  if (server) {
+    server.close(() => {
+      server = null;
+      markStopped();
+      console.log("  hbridge: off");
+      stopStatusBar(statusBarInterval);
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 1e3);
+  } else {
+    markStopped();
+    console.log("  hbridge: off");
+    process.exit(0);
+  }
+}
+function cmd_status() {
+  const cwd = process.cwd();
+  const port = homePort(cwd);
+  const key = homeKey(cwd);
+  const ips = getLocalIPs();
+  const state = readState();
+  const ip = isHome() ? "127.0.0.1" : ips[0] || "127.0.0.1";
+  const running = state.running;
+  console.log(running ? "hbridge enabled" : "hbridge stopped");
+  console.log("\u{1F4C2} " + cwd);
+  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + HBRIDGE_VERSION);
+}
+function showHelp() {
+  console.log(`
+  hbridge \u2014 Hermes Bridge
+
+  COMMANDS:
+    hbridge --enable         Start bridge with deterministic key
+    hbridge --disable        Stop bridge
+    hbridge --status         Show status + last client connection
+    hbridge --help           Show this help
+
+  Port is derived from the working directory; key is machine-global from ~/.hbridge_key.
+  Home mode (HBRIDGE_HOME=1) skips auth; remote mode enforces key.
+
+  EXAMPLES:
+    hbridge --enable         Enable with dir-derived key
+    hbridge --status         Show connected IP + last active time
+  `);
+  process.exit(0);
+}
+var args = process.argv.slice(2);
+var cmd = args[0];
+if (isHome()) {
+  cmd_enable();
+} else if (cmd === "--enable") cmd_enable();
+else if (cmd === "--disable") cmd_disable();
+else if (cmd === "--status") cmd_status();
+else if (cmd === "--help" || cmd === "-h") {
+  showHelp();
+} else {
+  console.log("hbridge \u2014 Hermes Bridge");
+  console.log("  hbridge --enable           Start bridge");
+  console.log("  hbridge --disable          Stop bridge");
+  console.log("  hbridge --status           Show status");
+  console.log("  hbridge --help             Show help");
+}