@claudexor/daemon 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 joi-lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @claudexor/daemon
+
+Internal package of [Claudexor](https://github.com/razzant/claudexor) — Optional local daemon: Unix-socket JSON-RPC, token auth, task queue. Runner injected (no second scheduler).
+
+Published as part of the Claudexor toolchain; it follows the monorepo's
+lockstep version and has no separate semver contract. Use the `claudexor`
+CLI (or `@claudexor/cli`) as the supported entry point.

package/dist/client.d.ts

@@ -0,0 +1,40 @@
+/** Thin JSON-RPC client for the daemon over a Unix socket. */
+export declare class DaemonClient {
+    private readonly socketPath;
+    private readonly token;
+    constructor(socketPath: string, token: string);
+    call<T = unknown>(method: string, params?: unknown): Promise<T>;
+    health(): Promise<unknown>;
+    enqueue(params: unknown): Promise<{
+        id: string;
+        state: string;
+    }>;
+    status(id: string): Promise<{
+        id: string;
+        state: string;
+        params?: unknown;
+        runId?: string;
+        taskId?: string;
+        runDir?: string;
+        result?: unknown;
+        error?: string;
+        createdAt?: string;
+        startedAt?: string;
+        finishedAt?: string;
+    }>;
+    list(): Promise<{
+        id: string;
+        state: string;
+        params?: unknown;
+        runId?: string;
+        taskId?: string;
+        runDir?: string;
+        error?: string;
+        createdAt?: string;
+        startedAt?: string;
+        finishedAt?: string;
+    }[]>;
+    cancel(id: string): Promise<unknown>;
+    shutdown(): Promise<unknown>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,8DAA8D;AAC9D,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBADL,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM;IAGhC,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAwC/D,MAAM;IAGN,OAAO,CAAC,MAAM,EAAE,OAAO;YACE,MAAM;eAAS,MAAM;;IAE9C,MAAM,CAAC,EAAE,EAAE,MAAM;YAET,MAAM;eACH,MAAM;iBACJ,OAAO;gBACR,MAAM;iBACL,MAAM;iBACN,MAAM;iBACN,OAAO;gBACR,MAAM;oBACF,MAAM;oBACN,MAAM;qBACL,MAAM;;IAMvB,IAAI;YAGM,MAAM;eACH,MAAM;iBACJ,OAAO;gBACR,MAAM;iBACL,MAAM;iBACN,MAAM;gBACP,MAAM;oBACF,MAAM;oBACN,MAAM;qBACL,MAAM;;IAIzB,MAAM,CAAC,EAAE,EAAE,MAAM;IAGjB,QAAQ;CAGT"}

package/dist/client.js

@@ -0,0 +1,74 @@
+import { connect } from "node:net";
+import { createInterface } from "node:readline";
+/** Thin JSON-RPC client for the daemon over a Unix socket. */
+export class DaemonClient {
+    socketPath;
+    token;
+    constructor(socketPath, token) {
+        this.socketPath = socketPath;
+        this.token = token;
+    }
+    call(method, params) {
+        return new Promise((resolve, reject) => {
+            const sock = connect(this.socketPath);
+            const id = Math.floor(Math.random() * 1e9);
+            let settled = false;
+            let rl;
+            const finish = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                rl?.close();
+                sock.destroy();
+                fn();
+            };
+            // A socket that accepts but never replies must not hang the caller
+            // (`daemon status`) forever — fail loudly after a bounded wait.
+            const timer = setTimeout(() => finish(() => reject(new Error(`daemon RPC timeout (${method})`))), 10_000);
+            timer.unref?.();
+            // Attach the error handler first so connect failures (ENOENT/ECONNREFUSED)
+            // never become an unhandled 'error' event.
+            sock.on("error", (err) => finish(() => reject(err)));
+            sock.on("close", () => finish(() => reject(new Error("daemon connection closed"))));
+            rl = createInterface({ input: sock });
+            rl.on("error", (err) => finish(() => reject(err))); // readline re-emits input 'error'
+            sock.on("connect", () => {
+                sock.write(JSON.stringify({ id, method, params, token: this.token }) + "\n");
+            });
+            rl.on("line", (line) => {
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id !== id)
+                        return;
+                    if (msg.error)
+                        finish(() => reject(new Error(msg.error.message)));
+                    else
+                        finish(() => resolve(msg.result));
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+        });
+    }
+    health() {
+        return this.call("claudexor.health");
+    }
+    enqueue(params) {
+        return this.call("claudexor.enqueue", params);
+    }
+    status(id) {
+        return this.call("claudexor.status", { id });
+    }
+    list() {
+        return this.call("claudexor.list");
+    }
+    cancel(id) {
+        return this.call("claudexor.cancel", { id });
+    }
+    shutdown() {
+        return this.call("claudexor.shutdown");
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/events.d.ts

@@ -0,0 +1,15 @@
+import type { RunEvent } from "@claudexor/schema";
+export type RunEventListener = (event: RunEvent) => void;
+/**
+ * In-process run-event bus: the daemon's runner publishes every RunEvent the
+ * orchestrator emits (mirroring events.jsonl), and live observers (control-api
+ * SSE) subscribe for push delivery. The FILE stays the canonical log and the
+ * replay source; this bus only removes tail-polling latency. A throwing
+ * listener must never break a run.
+ */
+export declare class RunEventBus {
+    private readonly listeners;
+    publish(event: RunEvent): void;
+    subscribe(listener: RunEventListener): () => void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IAEzD,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAU9B,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;CAMlD"}

package/dist/events.js

@@ -0,0 +1,27 @@
+/**
+ * In-process run-event bus: the daemon's runner publishes every RunEvent the
+ * orchestrator emits (mirroring events.jsonl), and live observers (control-api
+ * SSE) subscribe for push delivery. The FILE stays the canonical log and the
+ * replay source; this bus only removes tail-polling latency. A throwing
+ * listener must never break a run.
+ */
+export class RunEventBus {
+    listeners = new Set();
+    publish(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                /* observer errors never break the run */
+            }
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,MAAM,OAAO,WAAW;IACL,SAAS,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEzD,OAAO,CAAC,KAAe;QACrB,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,IAAI,CAAC;gBACH,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YAAC,MAAM,CAAC;gBACP,yCAAyC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED,SAAS,CAAC,QAA0B;QAClC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC,CAAC;IACJ,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./token.js";
+export * from "./server.js";
+export * from "./client.js";
+export * from "./events.js";
+export * from "./interactions.js";
+export * from "./threads.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./token.js";
+export * from "./server.js";
+export * from "./client.js";
+export * from "./events.js";
+export * from "./interactions.js";
+export * from "./threads.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC"}

package/dist/interactions.d.ts

@@ -0,0 +1,44 @@
+import type { ControlPendingInteraction, InteractionAnswerSet, InteractionRequest } from "@claudexor/schema";
+/** Structural twin of the orchestrator's PendingInteractionContext. */
+export interface InteractionContext {
+    runId: string;
+    taskId: string;
+    attemptId: string;
+    harnessId: string;
+    request: InteractionRequest;
+    requestedAt: string;
+    timeoutAt: string;
+}
+export type InteractionAnswerStatus = "delivered" | "not_found" | "already_resolved" | "rejected";
+/**
+ * Daemon-side registry of questions waiting for the user (waiting_on_user).
+ *
+ * The orchestrator's RunInput.onInteraction is wired to `register()`, which
+ * parks the attempt's promise here; control-api lists pending entries for the
+ * UI and delivers answers via `answer()`. The orchestrator owns the timeout —
+ * entries self-expire here only as hygiene so a timed-out question cannot be
+ * answered into a session that already moved on.
+ */
+export declare class InteractionRegistry {
+    private readonly pending;
+    /**
+     * Entries are keyed by (runId, interactionId): interaction ids originate
+     * from the harness's native request ids, which only need to be unique
+     * within one session — two concurrent runs may legally collide.
+     */
+    private key;
+    register(ctx: InteractionContext): Promise<InteractionAnswerSet | null>;
+    answer(runId: string, interactionId: string, rawAnswers: unknown): {
+        status: InteractionAnswerStatus;
+        message?: string;
+    };
+    /** Resolve-and-drop every pending question of a run that reached a terminal
+     * (cancel/failed/succeeded): a dead run must not advertise waiting_on_user
+     * for up to the interaction timeout. Resolving null mirrors the
+     * orchestrator's own decline path. */
+    dropForRun(runId: string): void;
+    pendingForRun(runId: string): ControlPendingInteraction[];
+    /** Drop expired entries (the orchestrator already declined them). */
+    private prune;
+}
+//# sourceMappingURL=interactions.d.ts.map

package/dist/interactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactions.d.ts","sourceRoot":"","sources":["../src/interactions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG7G,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAQD,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG,WAAW,GAAG,kBAAkB,GAAG,UAAU,CAAC;AAElG;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAE3D;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAIX,QAAQ,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAWvE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG;QAAE,MAAM,EAAE,uBAAuB,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;IAWxH;;;0CAGsC;IACtC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAS/B,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB,EAAE;IAgBzD,qEAAqE;IACrE,OAAO,CAAC,KAAK;CASd"}

package/dist/interactions.js

@@ -0,0 +1,81 @@
+import { InteractionAnswerSet as InteractionAnswerSetSchema } from "@claudexor/schema";
+/**
+ * Daemon-side registry of questions waiting for the user (waiting_on_user).
+ *
+ * The orchestrator's RunInput.onInteraction is wired to `register()`, which
+ * parks the attempt's promise here; control-api lists pending entries for the
+ * UI and delivers answers via `answer()`. The orchestrator owns the timeout —
+ * entries self-expire here only as hygiene so a timed-out question cannot be
+ * answered into a session that already moved on.
+ */
+export class InteractionRegistry {
+    pending = new Map();
+    /**
+     * Entries are keyed by (runId, interactionId): interaction ids originate
+     * from the harness's native request ids, which only need to be unique
+     * within one session — two concurrent runs may legally collide.
+     */
+    key(runId, interactionId) {
+        return `${runId}\u0000${interactionId}`;
+    }
+    register(ctx) {
+        this.prune();
+        return new Promise((resolve) => {
+            this.pending.set(this.key(ctx.runId, ctx.request.interaction_id), {
+                ctx,
+                resolve,
+                expiresAtMs: Date.parse(ctx.timeoutAt) || Date.now() + 900_000,
+            });
+        });
+    }
+    answer(runId, interactionId, rawAnswers) {
+        this.prune();
+        const entry = this.pending.get(this.key(runId, interactionId));
+        if (!entry)
+            return { status: "not_found", message: `no pending interaction '${interactionId}' for run '${runId}'` };
+        const parsed = InteractionAnswerSetSchema.safeParse(rawAnswers);
+        if (!parsed.success)
+            return { status: "rejected", message: parsed.error.issues[0]?.message ?? "invalid answers" };
+        this.pending.delete(this.key(runId, interactionId));
+        entry.resolve(parsed.data);
+        return { status: "delivered" };
+    }
+    /** Resolve-and-drop every pending question of a run that reached a terminal
+     * (cancel/failed/succeeded): a dead run must not advertise waiting_on_user
+     * for up to the interaction timeout. Resolving null mirrors the
+     * orchestrator's own decline path. */
+    dropForRun(runId) {
+        for (const [id, entry] of this.pending) {
+            if (entry.ctx.runId === runId) {
+                this.pending.delete(id);
+                entry.resolve(null);
+            }
+        }
+    }
+    pendingForRun(runId) {
+        this.prune();
+        return [...this.pending.values()]
+            .filter((e) => e.ctx.runId === runId)
+            .map((e) => ({
+            interactionId: e.ctx.request.interaction_id,
+            runId: e.ctx.runId,
+            attemptId: e.ctx.attemptId,
+            harnessId: e.ctx.harnessId,
+            sourceTool: e.ctx.request.source_tool,
+            questions: e.ctx.request.questions,
+            requestedAt: e.ctx.requestedAt,
+            timeoutAt: e.ctx.timeoutAt,
+        }));
+    }
+    /** Drop expired entries (the orchestrator already declined them). */
+    prune() {
+        const now = Date.now();
+        for (const [id, entry] of this.pending) {
+            if (entry.expiresAtMs <= now) {
+                this.pending.delete(id);
+                entry.resolve(null);
+            }
+        }
+    }
+}
+//# sourceMappingURL=interactions.js.map

package/dist/interactions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactions.js","sourceRoot":"","sources":["../src/interactions.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,114 @@
+/** Context the daemon supplies to the runner so a job can be observed and cancelled. */
+export interface RunContext {
+    signal: AbortSignal;
+    /** Called by the runner once the run id/dir are known (lets a client tail events.jsonl). */
+    onRunStart: (info: {
+        runId: string;
+        taskId: string;
+        runDir: string;
+    }) => void;
+}
+export type RunnerFn = (params: unknown, ctx: RunContext) => Promise<unknown>;
+export interface DaemonOptions {
+    socketPath: string;
+    token: string;
+    runner: RunnerFn;
+    /** Max concurrently-running jobs (parallel projects/runs). Default 4. */
+    maxConcurrent?: number;
+    /** Optional JSON file to persist the job registry across restarts (durable run list). */
+    persistPath?: string;
+    /** Max retained terminal jobs (older ones are pruned to bound memory/disk). Default 500. */
+    maxHistory?: number;
+    /** Called when a job reaches a terminal state (any path) with its runId —
+     * used to drop pending interactions so a dead run never advertises
+     * waiting_on_user. */
+    onRunTerminal?: (runId: string) => void;
+    /** Called when a job that carried a pre-created thread turn (params.turnId)
+     * settles failure-shaped WITHOUT ever binding a run — i.e. the refusal
+     * happened before the run materialized (trust gate, preflight validation).
+     * The observer persists the reason on the turn so it is never a silent
+     * orphan bubble. `code` is the typed throw's machine code (null if none). */
+    onTurnEnqueueFailed?: (turnId: string, error: string, code: string | null) => void;
+}
+export declare const JOB_STATES: readonly ["queued", "running", "blocked", "succeeded", "no_op", "ungated", "review_not_run", "failed", "cancelled", "interrupted", "exhausted", "not_converged", "stuck_no_progress"];
+export type JobState = (typeof JOB_STATES)[number];
+export interface JobRecord {
+    id: string;
+    state: JobState;
+    params: unknown;
+    result?: unknown;
+    error?: string;
+    /** Machine-readable code carried by a typed throw (e.g. the trust gate's
+     * trust_full_access_required) — lets surfaces key remedies on the CODE,
+     * never on substring-matching the human message. */
+    errorCode?: string;
+    createdAt: string;
+    /** Surfaced as soon as the run starts so a client can tail .claudexor/runs/<runId>/events.jsonl. */
+    runId?: string;
+    taskId?: string;
+    runDir?: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+/**
+ * Local daemon: Unix-socket JSON-RPC with token auth + a bounded-concurrency
+ * worker pool (up to maxConcurrent jobs in parallel) backed by an optional
+ * durable, atomically-written job registry. It does NOT contain a second
+ * scheduler — it calls the injected runner (the same Orchestrator the CLI uses).
+ */
+export declare class DaemonServer {
+    private readonly opts;
+    private server?;
+    private readonly queue;
+    private readonly records;
+    private readonly cancelled;
+    private readonly controllers;
+    private active;
+    private readonly startedAt;
+    private onClosed?;
+    constructor(opts: DaemonOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Resolves when the daemon is shut down via RPC. */
+    waitForShutdown(): Promise<void>;
+    private onConnection;
+    private send;
+    private handle;
+    private dispatch;
+    private get maxConcurrent();
+    /**
+     * Best-effort durable persistence of the job registry. Writes atomically
+     * (temp file + rename) so a crash mid-write cannot corrupt/drop the registry.
+     * The raw run `result` is intentionally NOT persisted: canonical output lives
+     * in .claudexor/runs (redacted), and result.summary can contain raw model text —
+     * keeping it out of jobs.json upholds the redaction-at-persistence invariant.
+     */
+    private persist;
+    /** Bound memory/disk: prune the oldest terminal jobs beyond maxHistory.
+     * `blocked` runs are NEVER pruned — they are the needs-human inbox awaiting an
+     * operator decision; dropping one would silently lose a pending action. */
+    private pruneHistory;
+    /** Reload the registry on startup; a fresh process cannot resume in-memory runs. */
+    private load;
+    /** Preserve the raw bytes of a damaged registry and report the loss loudly. */
+    private backupCorruptRegistry;
+    private threadIdOf;
+    /**
+     * Schedule queued jobs up to the concurrency limit (non-blocking).
+     *
+     * One active run per thread: a thread is a linear conversation and an in-place
+     * turn mutates the live tree, so two concurrent turns on the same thread would
+     * race the same files. We pick the first queued job whose thread is idle rather
+     * than always taking the head; thread-less jobs (CLI/MCP) keep running in
+     * parallel as before. drain() re-runs on every completion, so a thread's next
+     * turn starts as soon as its previous one settles.
+     */
+    private drain;
+    private runJob;
+}
+/** True when something is actively accepting connections on the socket path. */
+/** Is a daemon already listening on this socket? Exported so the claudexord
+ * entrypoint can refuse BEFORE running crash GC — a second daemon must never
+ * reap the live daemon's children or sweep envelopes its jobs still own. */
+export declare function socketAlive(socketPath: string): Promise<boolean>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}