@agentchatme/agent-core 0.0.1

package/dist/daemon-entry.d.ts

@@ -0,0 +1,212 @@
+import { EventEmitter } from 'node:events';
+import { z } from 'zod';
+
+declare const SyncRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type SyncRow = z.infer<typeof SyncRowSchema>;
+declare function parseInbound(payload: unknown): SyncRow | null;
+declare function senderOf(row: SyncRow): string;
+
+type State = 'connecting' | 'ready' | 'reconnecting' | 'terminal' | 'closed';
+interface WsClientEvents {
+    inbound: (row: SyncRow) => void;
+    ready: () => void;
+    terminal: (reason: string) => void;
+}
+declare class AgentWsClient extends EventEmitter {
+    private readonly url;
+    private readonly apiKey;
+    private ws;
+    private state;
+    private attempt;
+    private reconnectTimer;
+    private livenessTimer;
+    private stopped;
+    private ackMode;
+    constructor(url: string, apiKey: string);
+    /** True only while the socket is live and ready. The heartbeat writer keys
+     *  off this, so a reconnecting/terminal daemon lets its heartbeat go stale
+     *  and the next session detects that always-on is actually down. */
+    get connected(): boolean;
+    start(): void;
+    stop(): void;
+    getState(): State;
+    /**
+     * Confirm a message as handled: `{"type":"ack","message_id":"msg_..."}`.
+     * Fire-and-forget by design — a dropped ack is loss-free (the delivery
+     * stays 'stored' and re-drains on the next reconnect, where dedup absorbs
+     * the replay). Acking by message id (not delivery id) is what lets a
+     * real-time push — which carries no delivery_id — be acked at all.
+     */
+    ack(messageId: string): void;
+    private open;
+    private scheduleReconnect;
+    private armLiveness;
+    private clearTimers;
+}
+
+interface CoordConfig {
+    apiKey: string;
+    apiBase: string;
+    /** Stable, replier-unique token, e.g. "daemon:<host>". Same token across a
+     *  restart on the same host so the daemon re-claims its own in-flight work. */
+    holder: string;
+    timeoutMs?: number;
+}
+declare class ReplyCoord {
+    private readonly cfg;
+    constructor(cfg: CoordConfig);
+    private req;
+    /** Is the agent's live coding session actively working? Fail-open → FALSE. */
+    isSessionActive(): Promise<boolean>;
+    /**
+     * Claim the sole right to reply to a message. Returns true if THIS daemon is
+     * the designated replier, false if a live session already owns it. Fail-open
+     * → TRUE (reply anyway rather than drop).
+     */
+    claim(messageId: string): Promise<boolean>;
+}
+
+interface TurnContext {
+    /** The AgentChat conversation the message belongs to. */
+    conversationId: string;
+    /** @handle of the sender. */
+    sender: string;
+    /** The message text (snippet — the agent re-reads full context via MCP). */
+    text: string;
+    /** The message's `created_at` (ISO-8601 UTC). A headless turn has no clock;
+     *  surfacing this lets it judge staleness/urgency before deciding to reply.
+     *  Explicit `| undefined` so daemon.ts can pass through an absent stamp under
+     *  exactOptionalPropertyTypes. */
+    createdAt?: string | undefined;
+    /** Message type ('text' | 'structured' | 'file' | 'system'). Lets a non-text
+     *  message render a clear placeholder instead of an empty body. */
+    type?: string | undefined;
+    /** Sender's resolved display name, or null when unset / no context block. */
+    senderDisplayName?: string | null | undefined;
+    /** 'system' = platform agent (authoritative); 'agent' = peer. */
+    senderKind?: 'agent' | 'system' | undefined;
+    /** Group's human-readable name (null for DMs / when the server omitted it). */
+    groupName?: string | null | undefined;
+    /** True when THIS agent's handle is in the server-parsed mention list. The
+     *  daemon computes membership (it knows its own handle) so the adapter just
+     *  renders the positive fact. */
+    mentioned?: boolean | undefined;
+}
+interface TurnResult {
+    ok: boolean;
+    /** true if the runtime reported an unrecoverable error (bad setup/auth). */
+    fatal?: boolean;
+    detail?: string;
+}
+interface RuntimeAdapter {
+    readonly name: string;
+    /** Verify the runtime is usable (binary present, logged in). */
+    preflight(): Promise<{
+        ok: boolean;
+        detail?: string;
+    }>;
+    /** Run one turn to handle `ctx`. Continuity per conversation is the
+     *  adapter's concern (session resume). Never throws — returns TurnResult. */
+    runTurn(ctx: TurnContext): Promise<TurnResult>;
+}
+
+/** "the group \"Ops\" (grp_x)", or a bare "the group conversation grp_x" when
+ *  the server supplied no name, or "the direct conversation conv_x". */
+declare function describeConversation(ctx: TurnContext): string;
+/** Resolved sender identity: "Display Name (@handle)" or "@handle", flagging a
+ *  system agent so the model weights its words as platform-authored. */
+declare function describeSender(ctx: TurnContext): string;
+
+interface RunDaemonOpts {
+    /** THE identity home for the agent this daemon runs as. */
+    home: string;
+    /** How to spawn one headless turn of this integration's coding agent. */
+    adapter: RuntimeAdapter;
+    /** Scratch dir override; defaults to `<home>/daemon-workdir`. */
+    workdir?: string;
+}
+/**
+ * Run the always-on daemon. Resolves to a process exit code only on a failure
+ * that makes running pointless (no identity, another daemon already holds the
+ * lock, the runtime is not usable).
+ */
+declare function runDaemon(opts: RunDaemonOpts): Promise<number>;
+
+interface DaemonConfig {
+    apiKey: string;
+    handle: string;
+    apiBase: string;
+    wsUrl: string;
+    /** The identity home. Credentials, leader lock, and heartbeat all live here. */
+    home: string;
+    /** Scratch dir for the adapter (spawned-turn cwd, generated MCP config). */
+    workdir: string;
+}
+/** `https://api.agentchat.me` → `wss://api.agentchat.me/v1/ws`. */
+declare function wsUrlFor(apiBase: string): string;
+interface ResolveDaemonOpts {
+    /** THE identity home. Required — this module never derives one. */
+    home: string;
+    workdir?: string;
+}
+/**
+ * Resolve the identity the daemon runs as.
+ *
+ * Async because the handle is load-bearing at runtime — it filters this agent's
+ * own outbound echoed back by server fan-out, and decides whether a group
+ * mention names it. An env-only identity (`AGENTCHAT_API_KEY`, no credentials
+ * file) has no handle on disk, so we ask the server rather than starting up
+ * blind and replying to ourselves.
+ */
+declare function resolveDaemonConfig(opts: ResolveDaemonOpts): Promise<DaemonConfig>;
+
+declare class Daemon {
+    private readonly cfg;
+    private readonly adapter;
+    private readonly ws;
+    private readonly coord;
+    private readonly seen;
+    private readonly convChains;
+    private inFlight;
+    private readonly waiters;
+    private stopping;
+    private heartbeatTimer;
+    constructor(cfg: DaemonConfig, adapter: RuntimeAdapter, ws?: AgentWsClient);
+    start(): Promise<void>;
+    stop(): void;
+    private onInbound;
+    /** Serialize turns within a conversation; the global semaphore caps total. */
+    private enqueue;
+    private handle;
+    private acquireSlot;
+    private releaseSlot;
+}
+
+export { AgentWsClient, type CoordConfig, Daemon, type DaemonConfig, ReplyCoord, type ResolveDaemonOpts, type RunDaemonOpts, type RuntimeAdapter, type TurnContext, type TurnResult, type WsClientEvents, describeConversation, describeSender, parseInbound, resolveDaemonConfig, runDaemon, senderOf, wsUrlFor };

package/dist/daemon-entry.js

@@ -0,0 +1,472 @@
+import {
+  acquireLeaderLock,
+  beat,
+  external_exports,
+  getMeLite,
+  log,
+  resolveIdentity
+} from "./chunk-4UOOWYCI.js";
+
+// src/daemon/ws-client.ts
+import { WebSocket } from "ws";
+import { EventEmitter } from "events";
+
+// src/daemon/frames.ts
+var SyncRowSchema = external_exports.object({
+  id: external_exports.string(),
+  conversation_id: external_exports.string(),
+  // Present on REST /sync + reconnect-drain rows; ABSENT on real-time pushes.
+  delivery_id: external_exports.string().nullish(),
+  sender: external_exports.string().optional(),
+  sender_handle: external_exports.string().optional(),
+  type: external_exports.string().optional(),
+  content: external_exports.record(external_exports.unknown()).optional(),
+  created_at: external_exports.string().optional()
+}).passthrough();
+function parseInbound(payload) {
+  const parsed = SyncRowSchema.safeParse(payload);
+  return parsed.success ? parsed.data : null;
+}
+function senderOf(row) {
+  return row.sender ?? row.sender_handle ?? "unknown";
+}
+function contextOf(row) {
+  const raw = row.context;
+  const c = raw && typeof raw === "object" ? raw : {};
+  const sender = c.sender && typeof c.sender === "object" ? c.sender : {};
+  const conv = c.conversation && typeof c.conversation === "object" ? c.conversation : {};
+  return {
+    senderDisplayName: typeof sender.display_name === "string" ? sender.display_name : null,
+    senderKind: sender.kind === "system" ? "system" : "agent",
+    groupName: typeof conv.group_name === "string" ? conv.group_name : null,
+    memberCount: typeof conv.member_count === "number" ? conv.member_count : null,
+    mentions: Array.isArray(c.mentions) ? c.mentions.filter((m) => typeof m === "string").map((m) => m.toLowerCase()) : []
+  };
+}
+
+// src/daemon/ws-client.ts
+var BASE_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 6e4;
+var LIVENESS_MS = 1e5;
+var AgentWsClient = class extends EventEmitter {
+  constructor(url, apiKey) {
+    super();
+    this.url = url;
+    this.apiKey = apiKey;
+  }
+  url;
+  apiKey;
+  ws = null;
+  state = "closed";
+  attempt = 0;
+  reconnectTimer = null;
+  livenessTimer = null;
+  stopped = false;
+  ackMode = false;
+  /** True only while the socket is live and ready. The heartbeat writer keys
+   *  off this, so a reconnecting/terminal daemon lets its heartbeat go stale
+   *  and the next session detects that always-on is actually down. */
+  get connected() {
+    return this.state === "ready";
+  }
+  start() {
+    this.stopped = false;
+    this.open();
+  }
+  stop() {
+    this.stopped = true;
+    this.state = "closed";
+    this.clearTimers();
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "daemon shutdown");
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  /**
+   * Confirm a message as handled: `{"type":"ack","message_id":"msg_..."}`.
+   * Fire-and-forget by design — a dropped ack is loss-free (the delivery
+   * stays 'stored' and re-drains on the next reconnect, where dedup absorbs
+   * the replay). Acking by message id (not delivery id) is what lets a
+   * real-time push — which carries no delivery_id — be acked at all.
+   */
+  ack(messageId) {
+    if (this.state !== "ready" || !this.ws) return;
+    try {
+      this.ws.send(JSON.stringify({ type: "ack", message_id: messageId }));
+    } catch (err) {
+      log.debug(`ack send failed for ${messageId} (will re-drain): ${String(err)}`);
+    }
+  }
+  open() {
+    if (this.stopped) return;
+    this.state = this.attempt === 0 ? "connecting" : "reconnecting";
+    log.info(`ws ${this.state} (attempt ${this.attempt + 1}) \u2192 ${this.url}`);
+    const ws = new WebSocket(this.url, {
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        // Opt into the delivery-ack protocol: the server then leaves each
+        // delivery 'stored' until we ack it (by message id) instead of
+        // marking it delivered the instant it hits the socket. A crash
+        // mid-turn therefore re-drains on reconnect — at-least-once.
+        "x-agentchat-capabilities": "ack"
+      }
+    });
+    this.ws = ws;
+    ws.on("open", () => {
+      this.attempt = 0;
+      this.state = "ready";
+      this.armLiveness();
+      log.info("ws ready \u2014 draining + listening");
+      this.emit("ready");
+    });
+    ws.on("message", (data) => {
+      this.armLiveness();
+      let frame;
+      try {
+        frame = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      const f = frame;
+      if (f?.type === "message.new") {
+        const row = parseInbound(f.payload);
+        if (row) this.emit("inbound", row);
+        else log.warn(`message.new payload failed to parse: ${JSON.stringify(f.payload).slice(0, 300)}`);
+      } else if (f?.type === "hello.ok") {
+        const caps = Array.isArray(f.capabilities) ? f.capabilities : [];
+        this.ackMode = caps.includes("ack");
+        log.info(`ws hello.ok \u2014 ack-mode ${this.ackMode ? "ON" : "OFF (legacy)"}`);
+      } else {
+        log.debug(`ws frame: ${f?.type}`);
+      }
+    });
+    ws.on("ping", () => this.armLiveness());
+    ws.on("unexpected-response", (_req, res) => {
+      if (res.statusCode === 401 || res.statusCode === 403) {
+        this.state = "terminal";
+        this.clearTimers();
+        const reason = `auth rejected (${res.statusCode}) \u2014 check the agent's API key`;
+        log.error(`ws ${reason}`);
+        this.emit("terminal", reason);
+        return;
+      }
+      log.warn(`ws unexpected response ${res.statusCode} \u2014 will reconnect`);
+    });
+    ws.on("error", (err) => {
+      log.warn(`ws error: ${String(err)}`);
+    });
+    ws.on("close", (code) => {
+      if (this.state === "terminal" || this.stopped) return;
+      log.warn(`ws closed (${code}) \u2014 scheduling reconnect`);
+      this.scheduleReconnect();
+    });
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.state === "terminal") return;
+    this.state = "reconnecting";
+    this.clearTimers();
+    const backoff = Math.min(BASE_BACKOFF_MS * 2 ** this.attempt, MAX_BACKOFF_MS);
+    const jitter = backoff * (0.5 + Math.random() * 0.5);
+    this.attempt++;
+    this.reconnectTimer = setTimeout(() => this.open(), jitter);
+  }
+  armLiveness() {
+    if (this.livenessTimer) clearTimeout(this.livenessTimer);
+    this.livenessTimer = setTimeout(() => {
+      log.warn("ws liveness timeout \u2014 forcing reconnect");
+      try {
+        this.ws?.terminate();
+      } catch {
+      }
+      this.scheduleReconnect();
+    }, LIVENESS_MS);
+  }
+  clearTimers() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.livenessTimer) {
+      clearTimeout(this.livenessTimer);
+      this.livenessTimer = null;
+    }
+  }
+};
+
+// src/daemon/coord.ts
+var ReplyCoord = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  async req(method, pathname, body) {
+    const url = this.cfg.apiBase.replace(/\/+$/, "") + pathname;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.cfg.apiKey}`,
+        ...body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+      signal: AbortSignal.timeout(this.cfg.timeoutMs ?? 5e3)
+    });
+    if (!res.ok) throw new Error(`reply-coord ${res.status}`);
+    return res.json();
+  }
+  /** Is the agent's live coding session actively working? Fail-open → FALSE. */
+  async isSessionActive() {
+    try {
+      const d = await this.req("GET", "/v1/reply/active");
+      return d?.active === true;
+    } catch (err) {
+      log.debug(`coord isSessionActive failed (assuming inactive): ${String(err)}`);
+      return false;
+    }
+  }
+  /**
+   * Claim the sole right to reply to a message. Returns true if THIS daemon is
+   * the designated replier, false if a live session already owns it. Fail-open
+   * → TRUE (reply anyway rather than drop).
+   */
+  async claim(messageId) {
+    try {
+      const d = await this.req("POST", "/v1/reply/claim", {
+        message_id: messageId,
+        holder: this.cfg.holder
+      });
+      return d?.claimed !== false;
+    } catch (err) {
+      log.debug(`coord claim failed (proceeding): ${String(err)}`);
+      return true;
+    }
+  }
+};
+
+// src/daemon/format.ts
+function describeConversation(ctx) {
+  if (!ctx.conversationId.startsWith("grp_")) {
+    return `the direct conversation ${ctx.conversationId}`;
+  }
+  return ctx.groupName ? `the group "${ctx.groupName}" (${ctx.conversationId})` : `the group conversation ${ctx.conversationId}`;
+}
+function describeSender(ctx) {
+  const named = ctx.senderDisplayName ? `${ctx.senderDisplayName} (@${ctx.sender})` : `@${ctx.sender}`;
+  return ctx.senderKind === "system" ? `${named}, a system agent` : named;
+}
+
+// src/daemon/config.ts
+import * as path from "path";
+function wsUrlFor(apiBase) {
+  return apiBase.replace(/^http/, "ws").replace(/\/+$/, "") + "/v1/ws";
+}
+async function resolveDaemonConfig(opts) {
+  const home = path.resolve(opts.home);
+  const id = resolveIdentity(home);
+  if (id === null) {
+    throw new Error(`no AgentChat identity in ${home} \u2014 register this agent first`);
+  }
+  let handle = id.handle;
+  if (handle === null) {
+    const me = await getMeLite({ apiKey: id.apiKey, apiBase: id.apiBase });
+    if (me === null) {
+      throw new Error(
+        "could not determine this agent\u2019s handle (no credentials file, and /v1/agents/me did not answer)"
+      );
+    }
+    handle = me.handle;
+  }
+  return {
+    apiKey: id.apiKey,
+    handle,
+    apiBase: id.apiBase,
+    wsUrl: wsUrlFor(id.apiBase),
+    home,
+    workdir: opts.workdir ?? path.join(home, "daemon-workdir")
+  };
+}
+
+// src/daemon/loop.ts
+import * as os from "os";
+var MAX_CONCURRENT_TURNS = 3;
+var MAX_ATTEMPTS = 3;
+var HEARTBEAT_MS = 3e4;
+var YIELD_MS = Number(process.env["AGENTCHATD_YIELD_MS"] ?? 1e4);
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+var Daemon = class {
+  constructor(cfg, adapter, ws) {
+    this.cfg = cfg;
+    this.adapter = adapter;
+    this.coord = new ReplyCoord({
+      apiKey: cfg.apiKey,
+      apiBase: cfg.apiBase,
+      holder: `daemon:${os.hostname()}`
+    });
+    this.ws = ws ?? new AgentWsClient(cfg.wsUrl, cfg.apiKey);
+    this.ws.on("inbound", (row) => this.onInbound(row));
+    this.ws.on("ready", () => beat(this.cfg.home));
+    this.ws.on("terminal", (reason) => {
+      log.error(`daemon terminal: ${reason}`);
+      this.stop();
+      process.exitCode = 1;
+    });
+  }
+  cfg;
+  adapter;
+  ws;
+  coord;
+  seen = /* @__PURE__ */ new Map();
+  // message id → attempts
+  convChains = /* @__PURE__ */ new Map();
+  inFlight = 0;
+  waiters = [];
+  stopping = false;
+  heartbeatTimer = null;
+  async start() {
+    const pre = await this.adapter.preflight();
+    if (!pre.ok) {
+      throw new Error(`runtime (${this.adapter.name}) not ready: ${pre.detail}`);
+    }
+    log.info(`agentchat daemon up as @${this.cfg.handle} via ${this.adapter.name}; holding the wire`);
+    this.ws.start();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws.connected) beat(this.cfg.home);
+    }, HEARTBEAT_MS);
+    this.heartbeatTimer.unref();
+  }
+  stop() {
+    this.stopping = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.ws.stop();
+  }
+  onInbound(row) {
+    if (senderOf(row) === this.cfg.handle) return;
+    if (this.seen.has(row.id)) return;
+    this.seen.set(row.id, 0);
+    this.enqueue(row);
+  }
+  /** Serialize turns within a conversation; the global semaphore caps total. */
+  enqueue(row) {
+    const prev = this.convChains.get(row.conversation_id) ?? Promise.resolve();
+    const next = prev.then(() => this.handle(row)).catch((err) => {
+      log.warn(`unhandled in conv ${row.conversation_id}: ${String(err)}`);
+    });
+    this.convChains.set(row.conversation_id, next);
+    void next.then(() => {
+      if (this.convChains.get(row.conversation_id) === next) this.convChains.delete(row.conversation_id);
+    });
+  }
+  async handle(row) {
+    if (this.stopping) return;
+    if (await this.coord.isSessionActive()) {
+      log.info(`msg ${row.id}: live session active \u2014 yielding for ${YIELD_MS}ms`);
+      await delay(YIELD_MS);
+      if (this.stopping) return;
+    }
+    if (!await this.coord.claim(row.id)) {
+      log.info(`msg ${row.id}: claimed by the live session \u2014 standing down`);
+      return;
+    }
+    await this.acquireSlot();
+    try {
+      const attempts = (this.seen.get(row.id) ?? 0) + 1;
+      this.seen.set(row.id, attempts);
+      log.info(`turn for msg ${row.id} from @${senderOf(row)} (attempt ${attempts})`);
+      const ctx = contextOf(row);
+      const result = await this.adapter.runTurn({
+        conversationId: row.conversation_id,
+        sender: senderOf(row),
+        text: typeof row.content?.["text"] === "string" ? row.content["text"] : "",
+        createdAt: typeof row.created_at === "string" ? row.created_at : void 0,
+        type: typeof row.type === "string" ? row.type : void 0,
+        senderDisplayName: ctx.senderDisplayName,
+        senderKind: ctx.senderKind,
+        groupName: ctx.groupName,
+        mentioned: ctx.mentions.includes(this.cfg.handle.toLowerCase())
+      });
+      if (result.ok) {
+        this.ws.ack(row.id);
+      } else if (result.fatal) {
+        log.error(`fatal turn error: ${result.detail} \u2014 not acking (will re-drain)`);
+      } else if (attempts >= MAX_ATTEMPTS) {
+        log.warn(`msg ${row.id} failed ${attempts}\xD7 (${result.detail}); acking to drop (poison guard)`);
+        this.ws.ack(row.id);
+      } else {
+        log.warn(`turn failed for ${row.id}: ${result.detail}; leaving unacked for re-drain`);
+      }
+    } finally {
+      this.releaseSlot();
+    }
+  }
+  // ─── global concurrency semaphore ─────────────────────────────────────────
+  // A waiter inherits the releaser's slot directly (inFlight unchanged on
+  // hand-off) — no decrement-then-reincrement window that could momentarily
+  // exceed the cap.
+  acquireSlot() {
+    if (this.inFlight < MAX_CONCURRENT_TURNS) {
+      this.inFlight++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve2) => this.waiters.push(resolve2));
+  }
+  releaseSlot() {
+    const next = this.waiters.shift();
+    if (next) next();
+    else this.inFlight--;
+  }
+};
+
+// src/daemon/run.ts
+async function runDaemon(opts) {
+  let cfg;
+  try {
+    cfg = await resolveDaemonConfig({
+      home: opts.home,
+      ...opts.workdir !== void 0 ? { workdir: opts.workdir } : {}
+    });
+  } catch (err) {
+    console.error(String(err instanceof Error ? err.message : err));
+    return 1;
+  }
+  const lock = acquireLeaderLock(cfg.home);
+  if (lock === null) return 1;
+  const daemon = new Daemon(cfg, opts.adapter);
+  let releasing = false;
+  const shutdown = (sig) => {
+    if (releasing) return;
+    releasing = true;
+    log.info(`${sig} \u2014 shutting down`);
+    daemon.stop();
+    lock.release();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  try {
+    await daemon.start();
+  } catch (err) {
+    console.error(String(err instanceof Error ? err.message : err));
+    lock.release();
+    return 1;
+  }
+  return await new Promise(() => {
+  });
+}
+export {
+  AgentWsClient,
+  Daemon,
+  ReplyCoord,
+  describeConversation,
+  describeSender,
+  parseInbound,
+  resolveDaemonConfig,
+  runDaemon,
+  senderOf,
+  wsUrlFor
+};
+//# sourceMappingURL=daemon-entry.js.map