@tokenfactory/acc-runner 0.38.2 → 0.39.0

package/dist/chat-companion.d.ts

@@ -0,0 +1,101 @@
+/**
+ * CC-1B (TURN-LANE): the companion claim loop.
+ *
+ * A COMPANION is a runner attached to one or more operator chats that serves
+ * their queued turns, distinct from a fleet runner draining the task lane
+ * (WORKSPACE_COMMAND_CHAT_CONTRACTS §2). This module is the chat-lane analogue of
+ * the batch `pump()` in watch.ts: it repeatedly claims queued turns across its
+ * conversations and drives each with `driveChatTurn`, subject to two guards that
+ * keep it from ever starving the code/review lanes:
+ *
+ *   1. MAX-SHARE — `computeChatClaimBudget` caps how many concurrency slots chat
+ *      may hold (always leaving ≥1 for code/review), reading the batch lane's
+ *      live in-flight count via the injected `activeCodeTasks()`.
+ *   2. CIRCUIT BREAKER — while the chat circuit is open (a `claude_exit_1`-class
+ *      fault tripped it), the budget is 0 so no chat turn is claimed; the code
+ *      lane is untouched.
+ *
+ * The loop owns per-turn `AbortController`s so an operator cancel (or runner
+ * shutdown) SIGTERMs the in-flight engine child and the driver requeues the turn
+ * cleanly — no duplicate completion. Everything (transport, engine, clock,
+ * active-task count, delegation minting) is injected, so the loop is exercised
+ * deterministically without a network or a `claude` binary.
+ */
+import { type ChatLaneTransport, type ChatTurnDriveResult, type ClaimedChatTurn } from "./chat-lane.js";
+import type { ChatCircuitBreaker } from "./runtime/chat-circuit-breaker.js";
+import type { ConformantAgentEngine } from "./engines/types.js";
+export interface ChatCompanionOptions {
+    /** This runner's id (claimant of turns). */
+    runnerId: string;
+    /** The chat-conformant engine driving replies. */
+    engine: ConformantAgentEngine;
+    /** The wire seam for claim/stream/complete/requeue. */
+    transport: ChatLaneTransport;
+    /** The chat-capability circuit breaker (shared with `doctor` / boot hydration). */
+    breaker: ChatCircuitBreaker;
+    /** Runner concurrency ceiling (shared with the batch lane). */
+    concurrencyLimit: number;
+    /** Chat-lane max share of that ceiling (0..1); ≥1 still reserves 1 code slot. */
+    maxShare: number;
+    /** Requested lease per claim (server clamps). */
+    leaseMs: number;
+    /** Conversations this companion currently serves (registration list). */
+    conversations: () => string[];
+    /** Live count of code/review tasks in flight on this runner (from watch.ts pump). */
+    activeCodeTasks: () => number;
+    /** Working directory forwarded to the engine per turn. */
+    cwd?: string;
+    /** Mint a per-turn delegation token (narrowly-scoped identity) — optional. */
+    mintDelegation?: (turn: ClaimedChatTurn) => Promise<string | undefined>;
+    /** Clock (test seam). */
+    now?: () => number;
+    /** Best-effort observability sink for terminal turn results. */
+    onResult?: (result: ChatTurnDriveResult) => void;
+    /** Best-effort log sink. */
+    onLog?: (line: string) => void;
+}
+/**
+ * The companion claim loop. Call `pumpOnce()` to claim + drive as many turns as
+ * the max-share budget currently allows (returns the turns launched this pump);
+ * `start()` schedules `pumpOnce` on an interval; `cancel(turnId)` aborts an
+ * in-flight turn (clean requeue); `stop()` aborts all in-flight turns.
+ */
+export declare class ChatCompanion {
+    private readonly opts;
+    private readonly running;
+    private timer;
+    private stopped;
+    private rrCursor;
+    constructor(opts: ChatCompanionOptions);
+    /** Number of chat turns currently in flight on this companion. */
+    activeChatTurns(): number;
+    /** Turn ids currently in flight (stable snapshot). */
+    inFlightTurnIds(): string[];
+    /**
+     * The chat-lane claim budget right now: how many NEW turns may be claimed
+     * given concurrency, max-share, in-flight chat + code load, and the breaker.
+     */
+    budget(): number;
+    /**
+     * Claim + launch up to `budget()` turns across the served conversations,
+     * round-robin so no single busy conversation monopolises the budget. Returns
+     * the turns launched this pump (empty when the budget is 0 or every
+     * conversation's queue is empty).
+     */
+    pumpOnce(): Promise<ClaimedChatTurn[]>;
+    /** Start the periodic pump. `intervalMs` is the poll cadence between pumps. */
+    start(intervalMs?: number): void;
+    /**
+     * Abort one in-flight turn (operator cancel). The driver observes the signal,
+     * stops streaming, and requeues the turn — the "kill mid-stream ⇒ clean
+     * requeue, no dup side effects" path. Returns the settled result, or null when
+     * the turn is not in flight here.
+     */
+    cancel(turnId: string): Promise<ChatTurnDriveResult | null>;
+    /** Stop the loop: cancel the timer and abort every in-flight turn (requeue). */
+    stop(): Promise<ChatTurnDriveResult[]>;
+    private claim;
+    private launch;
+    private drive;
+}
+//# sourceMappingURL=chat-companion.d.ts.map

package/dist/chat-companion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-companion.d.ts","sourceRoot":"","sources":["../src/chat-companion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,MAAM,EAAE,qBAAqB,CAAC;IAC9B,uDAAuD;IACvD,SAAS,EAAE,iBAAiB,CAAC;IAC7B,mFAAmF;IACnF,OAAO,EAAE,kBAAkB,CAAC;IAC5B,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,qFAAqF;IACrF,eAAe,EAAE,MAAM,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACxE,yBAAyB;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACjD,4BAA4B;IAC5B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAQD;;;;;GAKG;AACH,qBAAa,aAAa;IAMZ,OAAO,CAAC,QAAQ,CAAC,IAAI;IALjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAK;gBAEQ,IAAI,EAAE,oBAAoB;IAEvD,kEAAkE;IAClE,eAAe,IAAI,MAAM;IAIzB,sDAAsD;IACtD,eAAe,IAAI,MAAM,EAAE;IAI3B;;;OAGG;IACH,MAAM,IAAI,MAAM;IAUhB;;;;;OAKG;IACG,QAAQ,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IA8B5C,+EAA+E;IAC/E,KAAK,CAAC,UAAU,SAAQ,GAAG,IAAI;IAS/B;;;;;OAKG;IACG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAOjE,gFAAgF;IAC1E,IAAI,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;YAW9B,KAAK;IAiBnB,OAAO,CAAC,MAAM;YAWA,KAAK;CAwBpB"}

package/dist/chat-companion.js

@@ -0,0 +1,183 @@
+/**
+ * CC-1B (TURN-LANE): the companion claim loop.
+ *
+ * A COMPANION is a runner attached to one or more operator chats that serves
+ * their queued turns, distinct from a fleet runner draining the task lane
+ * (WORKSPACE_COMMAND_CHAT_CONTRACTS §2). This module is the chat-lane analogue of
+ * the batch `pump()` in watch.ts: it repeatedly claims queued turns across its
+ * conversations and drives each with `driveChatTurn`, subject to two guards that
+ * keep it from ever starving the code/review lanes:
+ *
+ *   1. MAX-SHARE — `computeChatClaimBudget` caps how many concurrency slots chat
+ *      may hold (always leaving ≥1 for code/review), reading the batch lane's
+ *      live in-flight count via the injected `activeCodeTasks()`.
+ *   2. CIRCUIT BREAKER — while the chat circuit is open (a `claude_exit_1`-class
+ *      fault tripped it), the budget is 0 so no chat turn is claimed; the code
+ *      lane is untouched.
+ *
+ * The loop owns per-turn `AbortController`s so an operator cancel (or runner
+ * shutdown) SIGTERMs the in-flight engine child and the driver requeues the turn
+ * cleanly — no duplicate completion. Everything (transport, engine, clock,
+ * active-task count, delegation minting) is injected, so the loop is exercised
+ * deterministically without a network or a `claude` binary.
+ */
+import { computeChatClaimBudget, driveChatTurn, } from "./chat-lane.js";
+/**
+ * The companion claim loop. Call `pumpOnce()` to claim + drive as many turns as
+ * the max-share budget currently allows (returns the turns launched this pump);
+ * `start()` schedules `pumpOnce` on an interval; `cancel(turnId)` aborts an
+ * in-flight turn (clean requeue); `stop()` aborts all in-flight turns.
+ */
+export class ChatCompanion {
+    opts;
+    running = new Map();
+    timer = null;
+    stopped = false;
+    rrCursor = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Number of chat turns currently in flight on this companion. */
+    activeChatTurns() {
+        return this.running.size;
+    }
+    /** Turn ids currently in flight (stable snapshot). */
+    inFlightTurnIds() {
+        return [...this.running.keys()];
+    }
+    /**
+     * The chat-lane claim budget right now: how many NEW turns may be claimed
+     * given concurrency, max-share, in-flight chat + code load, and the breaker.
+     */
+    budget() {
+        return computeChatClaimBudget({
+            concurrencyLimit: this.opts.concurrencyLimit,
+            maxShare: this.opts.maxShare,
+            activeChatTurns: this.running.size,
+            activeCodeTasks: this.opts.activeCodeTasks(),
+            circuitOpen: this.opts.breaker.isOpen(),
+        });
+    }
+    /**
+     * Claim + launch up to `budget()` turns across the served conversations,
+     * round-robin so no single busy conversation monopolises the budget. Returns
+     * the turns launched this pump (empty when the budget is 0 or every
+     * conversation's queue is empty).
+     */
+    async pumpOnce() {
+        if (this.stopped)
+            return [];
+        const launched = [];
+        let budget = this.budget();
+        if (budget <= 0)
+            return launched;
+        const convos = this.opts.conversations();
+        if (convos.length === 0)
+            return launched;
+        // Round-robin start point rotates each pump so a claim-empty conversation
+        // does not always shadow the ones after it.
+        let attemptsWithoutClaim = 0;
+        let idx = this.rrCursor % convos.length;
+        while (budget > 0 && attemptsWithoutClaim < convos.length) {
+            const conversationId = convos[idx % convos.length];
+            idx += 1;
+            const turn = await this.claim(conversationId);
+            if (!turn) {
+                attemptsWithoutClaim += 1;
+                continue;
+            }
+            attemptsWithoutClaim = 0;
+            budget -= 1;
+            launched.push(turn);
+            this.launch(turn);
+        }
+        this.rrCursor = idx % Math.max(1, convos.length);
+        return launched;
+    }
+    /** Start the periodic pump. `intervalMs` is the poll cadence between pumps. */
+    start(intervalMs = 1_000) {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.pumpOnce();
+        }, intervalMs);
+        this.timer.unref?.();
+        void this.pumpOnce();
+    }
+    /**
+     * Abort one in-flight turn (operator cancel). The driver observes the signal,
+     * stops streaming, and requeues the turn — the "kill mid-stream ⇒ clean
+     * requeue, no dup side effects" path. Returns the settled result, or null when
+     * the turn is not in flight here.
+     */
+    async cancel(turnId) {
+        const rt = this.running.get(turnId);
+        if (!rt)
+            return null;
+        rt.controller.abort();
+        return rt.done;
+    }
+    /** Stop the loop: cancel the timer and abort every in-flight turn (requeue). */
+    async stop() {
+        this.stopped = true;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const pending = [...this.running.values()];
+        for (const rt of pending)
+            rt.controller.abort();
+        return Promise.all(pending.map((rt) => rt.done));
+    }
+    async claim(conversationId) {
+        try {
+            return await this.opts.transport.claim({
+                conversationId,
+                runnerId: this.opts.runnerId,
+                engineId: this.opts.engine.id,
+                tier: this.opts.engine.capabilities.tier,
+                leaseMs: this.opts.leaseMs,
+            });
+        }
+        catch (err) {
+            this.opts.onLog?.(`[acc-runner] chat claim(${conversationId}) failed: ${err.message}`);
+            return null;
+        }
+    }
+    launch(turn) {
+        const controller = new AbortController();
+        const done = this.drive(turn, controller.signal).finally(() => {
+            this.running.delete(turn.id);
+            // Freed a slot — re-pump so a queued turn (or a requeued one) is picked up
+            // immediately rather than waiting for the next interval tick.
+            if (!this.stopped)
+                void this.pumpOnce();
+        });
+        this.running.set(turn.id, { turn, controller, done });
+    }
+    async drive(turn, signal) {
+        const delegationToken = this.opts.mintDelegation
+            ? await this.opts.mintDelegation(turn).catch(() => undefined)
+            : undefined;
+        const result = await driveChatTurn(turn, {
+            engine: this.opts.engine,
+            transport: this.opts.transport,
+            signal,
+            ...(this.opts.cwd !== undefined ? { cwd: this.opts.cwd } : {}),
+            ...(delegationToken !== undefined ? { delegationToken } : {}),
+            ...(this.opts.now ? { now: this.opts.now } : {}),
+            onCircuitTrip: async (info) => {
+                await this.opts.breaker.trip({
+                    cause: info.cause,
+                    turnId: turn.id,
+                    conversationId: turn.conversation_id,
+                    detail: info.detail,
+                    ...(this.opts.now ? { now: this.opts.now } : {}),
+                });
+            },
+        });
+        this.opts.onResult?.(result);
+        return result;
+    }
+}
+//# sourceMappingURL=chat-companion.js.map

package/dist/chat-companion.js.map

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

package/dist/chat-lane.d.ts

@@ -0,0 +1,286 @@
+/**
+ * CC-1B (TURN-LANE): the runner-side chat claim lane + turn lifecycle.
+ *
+ * The chat lane is a SECOND lane beside the batch task/review lanes
+ * (docs/acc/WORKSPACE_COMMAND_CHAT_CONTRACTS.md §1). A *turn* is one operator
+ * prompt → one streamed agent reply. Turns are queued server-side; a companion
+ * runner CLAIMS a queued turn under a time-boxed lease (acc.claim_chat_turn,
+ * advisory-lock per conversation — migration 0254), STREAMS the reply as deltas,
+ * and COMPLETES it — or REQUEUES it when it loses the lease/capacity, so another
+ * companion finishes the turn without burning an operator turn.
+ *
+ * This module owns:
+ *   1. The turn LIFECYCLE state machine (queued → claimed → streaming →
+ *      awaiting_confirmation → done | capacity_paused | failed | cancelled),
+ *      with a transition validator.
+ *   2. The failure → disposition mapping: infra failures REQUEUE (never burn a
+ *      turn); `claude_exit_1`-class failures open the chat circuit breaker AND
+ *      requeue; a genuine agent error COMPLETES the turn as `error`.
+ *   3. `driveChatTurn` — the per-turn driver, an engine-agnostic loop over a
+ *      `ConformantAgentEngine.streamTurn` that emits exactly ONE terminal
+ *      transport call (complete OR requeue) so an abort mid-stream produces a
+ *      clean requeue with no duplicate side effects.
+ *   4. `computeChatClaimBudget` — the chat-lane max-share knob so chat turns can
+ *      never starve the code/review lanes of concurrency slots.
+ *
+ * Every side effect is behind the injectable `ChatLaneTransport` + the engine +
+ * an optional abort signal, so the whole lifecycle is exercised deterministically
+ * (tests/unit/chat-lane*.test.ts) with no `claude` binary and no network.
+ */
+import { type ClaudeExitClass, type ClassifiedExit } from "./failure-classifier.js";
+import type { ConformantAgentEngine, EngineCapabilityTier } from "./engines/types.js";
+/** Chat-lane protocol version (mirrors the web-app constant of the same name). */
+export declare const CHAT_LANE_PROTOCOL_VERSION: 1;
+/** Terminal disposition of a completed turn (mirror of ChatTurnOutcome). */
+export type ChatTurnOutcome = "ok" | "error" | "cancelled";
+/** Why a turn was returned to the queue instead of completed. */
+export type ChatTurnRequeueReason = "lease_expired" | "capacity_lost" | "engine_unavailable" | "credential_lost" | "operator_cancelled" | "runner_shutdown";
+/** runner → server: one streamed delta of the assistant turn's output. */
+export interface ChatTurnStreamPayload {
+    seq: number;
+    delta: string;
+    done: boolean;
+}
+/** runner → server: the turn reached a terminal state. */
+export interface ChatTurnCompletePayload {
+    outcome: ChatTurnOutcome;
+    total_seq: number;
+    error?: string;
+    /**
+     * Additive to the wire complete payload: true when the reply proposes an
+     * action the operator must confirm before it applies. The turn still
+     * completes `ok` (the reply streamed fine); the pending confirmation lives in
+     * acc.proposed_actions. A pre-CC-1B consumer ignores this field.
+     */
+    awaiting_confirmation?: boolean;
+}
+/** server ↔ runner: return the turn to the queue for another claimant. */
+export interface ChatTurnRequeuePayload {
+    reason: ChatTurnRequeueReason;
+    requeue_count: number;
+}
+/**
+ * A turn as claimed from acc.claim_chat_turn (the columns the driver needs).
+ * Mirrors the acc.chat_turns row the RPC returns.
+ */
+export interface ClaimedChatTurn {
+    id: string;
+    conversation_id: string;
+    org_id: string;
+    turn_ordinal: number | null;
+    prompt: string;
+    tier: EngineCapabilityTier;
+    engine_id: string;
+    runner_id: string;
+    requeue_count: number;
+    lease_expires_at: string | null;
+}
+/**
+ * The runner-side turn lifecycle. A superset of the acc.chat_turns DB status
+ * enum: `awaiting_confirmation` and `capacity_paused` are RUNNER phases (the DB
+ * has no such status — a confirmation-pending turn is still `done` at the DB
+ * with a proposed_actions row; a capacity-paused turn is `requeued`). Modeling
+ * them here lets the driver + companion report the full operator-visible
+ * lifecycle without a migration.
+ */
+export type ChatTurnLifecycle = "queued" | "claimed" | "streaming" | "awaiting_confirmation" | "done" | "capacity_paused" | "failed" | "cancelled" | "requeued";
+/** Terminal lifecycle states — no further transition is valid from these. */
+export declare const TERMINAL_CHAT_LIFECYCLE: readonly ChatTurnLifecycle[];
+/** True when `to` is a legal next lifecycle state from `from`. */
+export declare function isValidChatTransition(from: ChatTurnLifecycle, to: ChatTurnLifecycle): boolean;
+/** True when the lifecycle state is terminal (the turn is settled). */
+export declare function isTerminalChatLifecycle(state: ChatTurnLifecycle): boolean;
+/**
+ * What the driver does with a failed turn:
+ *   - `requeue`            — an infra failure (recoverable capacity / transient
+ *                            engine unavailability). The turn goes back to the
+ *                            queue; NO operator turn is burned, the chat circuit
+ *                            stays closed.
+ *   - `quarantine_requeue` — a `claude_exit_1`-class fault (broken credential /
+ *                            host / hard billing wall). OPEN the chat circuit
+ *                            breaker AND requeue the turn (survives on another
+ *                            companion) — but this runner stops claiming chat.
+ *   - `error`              — a genuine agent/task error. COMPLETE the turn as
+ *                            `error`; the operator turn IS spent (a real reply
+ *                            failure, not infra), so it must not silently loop.
+ */
+export type ChatFailureDisposition = {
+    action: "requeue";
+    reason: ChatTurnRequeueReason;
+    quarantine: false;
+    detail: string;
+} | {
+    action: "quarantine_requeue";
+    reason: ChatTurnRequeueReason;
+    cause: ClaudeExitClass;
+    detail: string;
+} | {
+    action: "error";
+    detail: string;
+};
+/**
+ * Map a shared-taxonomy `ClassifiedExit` onto a chat-lane disposition. The split
+ * mirrors the batch lane's machine-vs-task rule but reroutes the terminal action
+ * to the chat lane's requeue/circuit model:
+ *
+ *   capacity_exhausted | subscription_exhausted → requeue (capacity_lost)     [infra]
+ *   claude_unavailable (transient)              → requeue (engine_unavailable) [infra]
+ *   auth_expired                                → quarantine_requeue (credential_lost)
+ *   env_broken                                  → quarantine_requeue (engine_unavailable)
+ *   usage_limit (hard wall)                     → quarantine_requeue (capacity_lost)
+ *   task_error                                  → error (turn completes 'error')
+ */
+export declare function classifyChatDisposition(classified: ClassifiedExit): ChatFailureDisposition;
+/**
+ * The chat-lane wire seam. Claim goes through the service-role acc.claim_chat_turn
+ * RPC (advisory-lock per conversation); stream/complete/requeue carry the
+ * lifecycle messages. Behind this interface a production adapter broadcasts on
+ * `chat:<conversation_id>` and/or posts to the control-plane API; the driver
+ * neither knows nor cares, so tests inject a recording fake.
+ */
+export interface ChatLaneTransport {
+    /** Claim the oldest queued turn on a conversation, or null when the queue is empty. */
+    claim(args: {
+        conversationId: string;
+        runnerId: string;
+        engineId: string;
+        tier: EngineCapabilityTier;
+        leaseMs: number;
+    }): Promise<ClaimedChatTurn | null>;
+    /** Mark a claimed turn as streaming (claimed → streaming). */
+    markStreaming?(turn: ClaimedChatTurn): Promise<void>;
+    /** Emit one streamed delta for a turn. */
+    stream(turn: ClaimedChatTurn, payload: ChatTurnStreamPayload): Promise<void>;
+    /** Terminally complete a turn (ok | error | cancelled). */
+    complete(turn: ClaimedChatTurn, payload: ChatTurnCompletePayload): Promise<void>;
+    /** Return a turn to the queue for another claimant. */
+    requeue(turn: ClaimedChatTurn, payload: ChatTurnRequeuePayload): Promise<void>;
+}
+export interface DriveChatTurnDeps {
+    /** The chat-conformant engine that streams the reply. */
+    engine: ConformantAgentEngine;
+    /** The wire seam for stream/complete/requeue. */
+    transport: ChatLaneTransport;
+    /** Working directory forwarded to the engine (repo checkout for the turn). */
+    cwd?: string;
+    /** Per-turn delegation Bearer token forwarded to the acc-mcp bus. */
+    delegationToken?: string;
+    /** Abort signal; aborting mid-stream produces a clean requeue (no dup complete). */
+    signal?: AbortSignal;
+    /** Requeue reason to use when the turn is aborted (default operator_cancelled). */
+    abortReason?: ChatTurnRequeueReason;
+    /**
+     * Decide whether the fully-streamed reply proposes an action needing operator
+     * confirmation (→ awaiting_confirmation). Default: never (no confirmation).
+     */
+    requiresConfirmation?: (fullText: string, turn: ClaimedChatTurn) => boolean;
+    /**
+     * Detect a SILENT engine failure: a clean stream that produced zero visible
+     * text. Mirrors the batch lane's `claude_unavailable → health probe` rule —
+     * if the probe says the host/binary is broken, the empty turn is really an
+     * env_broken fault (→ quarantine_requeue) rather than a genuine empty reply.
+     * Default: treat an empty reply as a real (`ok`) empty reply.
+     */
+    silentFailureProbe?: () => Promise<ClassifiedExit | null>;
+    /** Clock (test seam). */
+    now?: () => number;
+    /** Called when the driver opens the chat circuit (companion trips its breaker). */
+    onCircuitTrip?: (info: {
+        cause: ClaudeExitClass;
+        detail: string;
+    }) => Promise<void> | void;
+    /** Best-effort structured log sink. */
+    onEvent?: (event: ChatTurnDriveEvent) => void;
+}
+/** A structured lifecycle event emitted by the driver (observability seam). */
+export interface ChatTurnDriveEvent {
+    turnId: string;
+    conversationId: string;
+    lifecycle: ChatTurnLifecycle;
+    detail?: string;
+}
+/** The terminal result of driving one turn. */
+export interface ChatTurnDriveResult {
+    turnId: string;
+    conversationId: string;
+    /** The terminal lifecycle state the turn settled in. */
+    lifecycle: Extract<ChatTurnLifecycle, "done" | "awaiting_confirmation" | "failed" | "cancelled" | "requeued" | "capacity_paused">;
+    /** Present when the turn was completed (done/awaiting_confirmation/failed). */
+    outcome?: ChatTurnOutcome;
+    /** Present when the turn was requeued. */
+    requeueReason?: ChatTurnRequeueReason;
+    /** Total deltas emitted (for consumer gap detection). */
+    totalSeq: number;
+    /** True when driving this turn opened the chat circuit breaker. */
+    quarantined: boolean;
+    /** Human-readable detail (error/requeue reason). */
+    detail?: string;
+}
+/**
+ * Drive one claimed turn to a terminal state. Emits EXACTLY ONE terminal
+ * transport call (complete OR requeue), guarded by `settled`, so a mid-stream
+ * abort/failure can never both requeue AND complete the same turn — the
+ * "kill mid-stream ⇒ clean requeue, no dup side effects" invariant.
+ */
+export declare function driveChatTurn(turn: ClaimedChatTurn, deps: DriveChatTurnDeps): Promise<ChatTurnDriveResult>;
+/** Env var carrying the chat-lane max-share fraction (0..1). */
+export declare const CHAT_MAX_SHARE_ENV = "ACC_RUNNER_CHAT_MAX_SHARE";
+/** Default chat-lane max share of runner concurrency. */
+export declare const DEFAULT_CHAT_MAX_SHARE = 0.5;
+/**
+ * Resolve the chat-lane max-share fraction from a raw env value. Blank/absent ⇒
+ * default; a value ≤0 disables chat claiming; a value ≥1 is clamped so at least
+ * one slot always remains for the code/review lanes (chat can never take the
+ * whole runner). Non-numeric ⇒ default (a typo must not starve either lane).
+ */
+export declare function resolveChatMaxShare(raw: string | undefined | null): number;
+/**
+ * Compute how many NEW chat turns the runner may claim right now, given its
+ * concurrency ceiling and current mixed load. The max-share invariant guarantees
+ * the code/review lanes never starve:
+ *
+ *   chatCeiling = clamp(floor(concurrency * maxShare), 0, concurrency - 1)
+ *
+ * i.e. chat may occupy at most `chatCeiling` slots, and that ceiling is capped at
+ * `concurrency - 1` so at least one slot is ALWAYS reservable for a code/review
+ * task even at maxShare = 1. The live budget then subtracts the chat turns
+ * already in flight and is further bounded by the runner's actual free capacity
+ * (concurrency − everything running). Returns 0 while the chat circuit is open or
+ * chat is disabled (maxShare ≤ 0).
+ */
+export declare function computeChatClaimBudget(opts: {
+    concurrencyLimit: number;
+    maxShare: number;
+    activeChatTurns: number;
+    activeCodeTasks: number;
+    circuitOpen?: boolean;
+}): number;
+/** Env var that opts the runner into the chat lane (a companion). */
+export declare const CHAT_LANE_ENABLED_ENV = "ACC_RUNNER_CHAT_LANE";
+/** Env var carrying the requested per-turn lease (ms). */
+export declare const CHAT_LEASE_MS_ENV = "ACC_RUNNER_CHAT_LEASE_MS";
+/** Default per-turn lease; mirrors acc.claim_chat_turn's default (60s). */
+export declare const DEFAULT_CHAT_LEASE_MS = 60000;
+/**
+ * Resolve the requested per-turn lease. Blank/absent/non-numeric ⇒ default;
+ * numeric values clamp to the RPC's own accepted window (1s..10m) so the runner
+ * never asks for a lease the server would silently clamp anyway.
+ */
+export declare function resolveChatLeaseMs(raw: string | undefined | null): number;
+/** The resolved chat-lane knobs (companion enablement + share + lease). */
+export interface ChatLaneRunnerConfig {
+    /** Whether this runner serves the chat lane at all. */
+    enabled: boolean;
+    /** Chat-lane max share of runner concurrency (0..1). */
+    maxShare: number;
+    /** Requested per-turn lease (ms). */
+    leaseMs: number;
+}
+/**
+ * Resolve the chat-lane knobs from the environment in ONE place so the companion
+ * loop and any caps/telemetry read the same values. A share of 0 (or the flag
+ * absent) means the runner does not claim chat turns even when enabled — the
+ * code/review lanes keep the whole runner.
+ */
+export declare function resolveChatLaneConfig(env?: NodeJS.ProcessEnv): ChatLaneRunnerConfig;
+//# sourceMappingURL=chat-lane.d.ts.map

package/dist/chat-lane.d.ts.map

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