@loompad/cli 0.1.0 → 1.1.1

package/dist/daemon/runtime/queue.d.ts

@@ -0,0 +1,94 @@
+import type { EventJournal } from "../../core/eventlog.js";
+import { OrchestraEngine } from "../../core/orchestra.js";
+import { PromptQueue, type QueueCondition, type QueueInput, type QueueItem, type QueueState, type QueueTarget } from "../../core/prompt-queue.js";
+import { type MergeOutcome } from "../../core/worktree-merge.js";
+import type { AnyAgent, ProjectConfig, RouteState, RouteStepSpec, RouterKind } from "../../types.js";
+import type { TurnOptions, TurnResult } from "./turns.js";
+/** Dependencies owned by the project coordinator, read live for each operation. */
+export interface RuntimeQueueHost {
+    queue: PromptQueue;
+    agents: ReadonlyMap<string, AnyAgent>;
+    routeState: () => RouteState | null;
+    validHolder: () => string | null;
+    orchestra: OrchestraEngine;
+    config: ProjectConfig;
+    busySince: Map<string, number>;
+    closed: boolean;
+    appendIfOpen: (event: Parameters<EventJournal["append"]>[0]) => void;
+    startRoute: (opts: {
+        task: string;
+        spec?: string | RouteStepSpec[];
+        router?: RouterKind;
+        maxHops?: number;
+    }) => Promise<RouteState>;
+    handoff: (to: string, opts?: {
+        source?: "user" | "route";
+    }) => Promise<{
+        from: string | null;
+        merge?: MergeOutcome;
+    }>;
+    sendMessage: (text: string, agentId?: string, opts?: TurnOptions) => Promise<TurnResult>;
+}
+/** Owns queue state for exactly one open project. */
+export declare class RuntimeQueue {
+    private readonly host;
+    constructor(host: RuntimeQueueHost);
+    queueListeners: Set<(s: QueueState) => void>;
+    draining: boolean;
+    /** When the project last went quiet, for a "after N quiet minutes" condition. */
+    quietSince: number;
+    clockTimer: ReturnType<typeof setInterval> | null;
+    /** Live queue changes, for the socket. Returns unsubscribe. */
+    onQueueChange(cb: (q: QueueState) => void): () => void;
+    /** Line a prompt up; it goes as soon as nothing ahead of it is in the way. */
+    enqueue(input: QueueInput): QueueItem;
+    /** Change a waiting prompt. A target this project can't run is refused now,
+     * not when the queue reaches it and has to stop. */
+    editQueued(itemId: string, patch: {
+        text?: string;
+        target?: QueueTarget;
+        plan?: boolean;
+        when?: QueueCondition | null;
+    }): QueueItem;
+    /** An agent in this project that can hold the baton, or the reason it can't. */
+    mustTakeTurns(agentId: string): void;
+    /** Why the head can't go yet, or null when it can. */
+    queueBlocker(item: QueueItem): string | null;
+    /**
+     * Is a queued prompt's condition still unmet? The reason, or null to go.
+     *
+     * Every branch reads a fact the daemon already has — the clock, a goal's
+     * landing state, its checks — so nothing here can be wrong in an interesting
+     * way. A condition about a goal that no longer exists releases the prompt
+     * rather than holding it for ever.
+     */
+    conditionUnmet(when: QueueCondition): string | null;
+    /**
+     * A prompt held for an hour needs something to notice the hour arriving.
+     *
+     * Only ticks while such a prompt exists — the queue's other conditions are
+     * woken by the events they wait on (a goal landing, checks going green), and
+     * a timer that runs when nothing needs it is a battery someone else pays for.
+     */
+    watchClockConditions(q: QueueState): void;
+    /**
+     * Hold the queue because `agentId` asked the human something — but only when
+     * the queue is actually pointed at that agent. An orchestra worker's question
+     * is the orchestrator's to answer (see core/orchestra.ts) and shouldn't
+     * freeze a queue lined up for someone else.
+     */
+    holdQueueFor(agentId: string): void;
+    /**
+     * You answered, so the hold is over.
+     *
+     * Only a hold this agent's own question put there: a queue you paused
+     * yourself stays paused, and so does one stopped mid-turn. Without this, the
+     * next thing you typed while the agent worked would queue behind the held
+     * prompt and sit there, in a queue nothing was going to resume.
+     */
+    releaseQuestionHold(agentId: string): void;
+    kickQueue(): void;
+    /** Send the head of the queue if it may go; then look again. */
+    drainPromptQueue(): Promise<void>;
+    dispatchQueued(item: QueueItem): Promise<void>;
+}

package/dist/daemon/runtime/queue.js

@@ -0,0 +1,222 @@
+import { blockedBy } from "../../core/goal-lanes.js";
+import { describeCondition, } from "../../core/prompt-queue.js";
+import { isAdapter } from "../../types.js";
+import { CLOCK_TICK_MS, questionHold } from '../runtime-support.js';
+/** Owns queue state for exactly one open project. */
+export class RuntimeQueue {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    queueListeners = new Set();
+    draining = false;
+    /** When the project last went quiet, for a "after N quiet minutes" condition. */
+    quietSince = 0;
+    clockTimer = null;
+    /** Live queue changes, for the socket. Returns unsubscribe. */
+    onQueueChange(cb) {
+        this.queueListeners.add(cb);
+        return () => this.queueListeners.delete(cb);
+    }
+    /** Line a prompt up; it goes as soon as nothing ahead of it is in the way. */
+    enqueue(input) {
+        const t = input.target ?? { kind: "auto" };
+        if (t.kind === "agent")
+            this.mustTakeTurns(t.agentId);
+        const item = this.host.queue.add(input);
+        this.kickQueue();
+        return item;
+    }
+    /** Change a waiting prompt. A target this project can't run is refused now,
+     * not when the queue reaches it and has to stop. */
+    editQueued(itemId, patch) {
+        if (patch.target?.kind === "agent")
+            this.mustTakeTurns(patch.target.agentId);
+        const item = this.host.queue.edit(itemId, patch);
+        this.kickQueue();
+        return item;
+    }
+    /** An agent in this project that can hold the baton, or the reason it can't. */
+    mustTakeTurns(agentId) {
+        const agent = this.host.agents.get(agentId);
+        if (!agent)
+            throw new Error(`no agent "${agentId}" in this project`);
+        if (!isAdapter(agent))
+            throw new Error(`agent "${agentId}" is a bridge (read-only) — it cannot take turns`);
+    }
+    /** Why the head can't go yet, or null when it can. */
+    queueBlocker(item) {
+        // A condition comes first: a prompt held for 3am isn't waiting on an agent.
+        if (this.host.config.brain?.continuity && this.host.busySince.size)
+            return "waiting for the foreground native turn";
+        const held = item.when ? this.conditionUnmet(item.when) : null;
+        if (held)
+            return held;
+        const route = this.host.routeState();
+        const routing = route && (route.status === "running" || route.status === "waiting_human");
+        const holder = this.host.validHolder();
+        if (item.target.kind === "orchestra") {
+            const running = this.host.orchestra.runningScopes();
+            if (!running.length)
+                return null;
+            const allowed = Math.max(1, this.host.config.maxConcurrentGoals ?? 1);
+            // With lanes on, a queued goal that can't collide with what's running
+            // starts beside it; the rest wait, with the overlap named.
+            return blockedBy({ runId: "queued", goal: item.text, paths: [] }, running, allowed)
+                ?? null;
+        }
+        if (routing)
+            return "waiting for the running route";
+        if (item.target.kind === "agent" && this.host.busySince.has(item.target.agentId))
+            return `waiting for ${item.target.agentId} to finish its turn`;
+        if (holder && this.host.busySince.has(holder))
+            return `waiting for ${holder} to finish its turn`;
+        return null;
+    }
+    /**
+     * Is a queued prompt's condition still unmet? The reason, or null to go.
+     *
+     * Every branch reads a fact the daemon already has — the clock, a goal's
+     * landing state, its checks — so nothing here can be wrong in an interesting
+     * way. A condition about a goal that no longer exists releases the prompt
+     * rather than holding it for ever.
+     */
+    conditionUnmet(when) {
+        if (when.kind === "at") {
+            return Date.now() >= when.at ? null : describeCondition(when);
+        }
+        if (when.kind === "quiet") {
+            const busy = this.host.busySince.size > 0 || Boolean(this.host.orchestra.active());
+            if (busy) {
+                this.quietSince = 0;
+                return describeCondition(when);
+            }
+            if (!this.quietSince)
+                this.quietSince = Date.now();
+            return Date.now() - this.quietSince >= when.ms ? null : describeCondition(when);
+        }
+        const run = this.host.orchestra.get(when.runId);
+        if (!run)
+            return null; // the goal is gone: holding for it for ever helps nobody
+        if (when.kind === "landed") {
+            return run.landing?.state === "merged" ? null : describeCondition(when);
+        }
+        const checks = run.landing?.checks;
+        const green = Boolean(checks && !checks.failing.length && !checks.pending.length && checks.passing > 0);
+        return green ? null : describeCondition(when);
+    }
+    /**
+     * A prompt held for an hour needs something to notice the hour arriving.
+     *
+     * Only ticks while such a prompt exists — the queue's other conditions are
+     * woken by the events they wait on (a goal landing, checks going green), and
+     * a timer that runs when nothing needs it is a battery someone else pays for.
+     */
+    watchClockConditions(q) {
+        const needsClock = q.items.some((i) => i.when && (i.when.kind === "at" || i.when.kind === "quiet"));
+        if (needsClock && !this.clockTimer) {
+            this.clockTimer = setInterval(() => this.kickQueue(), CLOCK_TICK_MS);
+            this.clockTimer.unref?.();
+        }
+        else if (!needsClock && this.clockTimer) {
+            clearInterval(this.clockTimer);
+            this.clockTimer = null;
+        }
+    }
+    /**
+     * Hold the queue because `agentId` asked the human something — but only when
+     * the queue is actually pointed at that agent. An orchestra worker's question
+     * is the orchestrator's to answer (see core/orchestra.ts) and shouldn't
+     * freeze a queue lined up for someone else.
+     */
+    holdQueueFor(agentId) {
+        const head = this.host.queue.peek();
+        if (!head || this.host.queue.paused)
+            return;
+        const mine = head.target.kind === "agent" ? head.target.agentId === agentId : head.target.kind === "auto";
+        if (!mine)
+            return;
+        this.host.queue.setPaused(true, questionHold(agentId));
+    }
+    /**
+     * You answered, so the hold is over.
+     *
+     * Only a hold this agent's own question put there: a queue you paused
+     * yourself stays paused, and so does one stopped mid-turn. Without this, the
+     * next thing you typed while the agent worked would queue behind the held
+     * prompt and sit there, in a queue nothing was going to resume.
+     */
+    releaseQuestionHold(agentId) {
+        if (!this.host.queue.paused || this.host.queue.snapshot().reason !== questionHold(agentId))
+            return;
+        this.host.queue.setPaused(false);
+    }
+    kickQueue() {
+        if (this.host.closed || this.draining || this.host.queue.paused || !this.host.queue.length)
+            return;
+        queueMicrotask(() => void this.drainPromptQueue());
+    }
+    /** Send the head of the queue if it may go; then look again. */
+    async drainPromptQueue() {
+        if (this.host.closed || this.draining || this.host.queue.paused)
+            return;
+        const head = this.host.queue.peek();
+        if (!head || this.queueBlocker(head))
+            return;
+        this.draining = true;
+        // Out of the queue, then sent: what you can still see is what hasn't gone.
+        // (Leaving it in place until the send returns would survive a crash
+        // mid-dispatch, at the price of a prompt you can edit or remove after it
+        // has already reached the agent — a worse thing to be wrong about.)
+        const item = this.host.queue.shift();
+        try {
+            await this.dispatchQueued(item);
+        }
+        catch (err) {
+            // refused (budget, quarantine, policy, a missing agent): keep it where it
+            // was and stop, so you can edit it or send it elsewhere — never drop it
+            const message = err instanceof Error ? err.message : String(err);
+            if (!this.host.closed) {
+                this.host.queue.unshift(item);
+                this.host.queue.setPaused(true, `the next prompt wasn't sent: ${message}`);
+                this.host.appendIfOpen({ kind: "error", chat: item.chat, payload: { message: `queued prompt not sent: ${message}` } });
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+        this.kickQueue();
+    }
+    async dispatchQueued(item) {
+        const t = item.target;
+        if (t.kind === "orchestra") {
+            await this.host.orchestra.start({
+                goal: item.text,
+                // A queued goal remembers the thread it was typed in. sendMessage
+                // below always honoured that; this branch dropped it (#100).
+                ...(item.chat ? { chat: item.chat } : {}),
+                ...(t.orchestrator ? { orchestrator: t.orchestrator } : {}),
+                ...(t.workers?.length ? { workers: t.workers } : {}),
+                ...(t.maxParallel ? { maxParallel: t.maxParallel } : {}),
+                ...(t.maxUsd ? { maxUsd: t.maxUsd } : {}),
+                ...(item.plan ? { plan: true } : {}),
+            });
+            return;
+        }
+        if (t.kind === "auto" && !item.plan) {
+            await this.host.startRoute({ task: item.text, spec: "auto" });
+            return;
+        }
+        // one agent: the baton moves to it first, as when you pick it and send
+        const to = t.kind === "agent" ? t.agentId : undefined;
+        const holder = this.host.validHolder();
+        if (to && holder && holder !== to)
+            await this.host.handoff(to, { source: item.source });
+        await this.host.sendMessage(item.text, to, { source: item.source, chat: item.chat, fromQueue: true,
+            requestId: item.continuity?.requestId ?? (item.editedAt ? `queue:${item.id}:edit:${item.editedAt}` : `queue:${item.id}`),
+            ...(item.continuity ? { capturedModel: item.continuity.model } : {}),
+            ...(item.plan ? { plan: true } : {}),
+            ...(item.length ? { length: item.length } : {}) });
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/daemon/runtime/queue.js.map

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

package/dist/daemon/runtime/relay.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Quota Relay: when an agent runs out of quota mid-task, the next one carries
+ * on, with the context, and the first takes the chat back when it resets.
+ *
+ * Recognising the limit is core/quota.ts. Here: which agent picks up (the
+ * project's `relay.to` order, or the other CLI agents in roster order — never
+ * a paid API model unless you list it), stopping the parked turn, handing the
+ * baton over with a briefing that says what happened, re-sending the request
+ * in the same chat, and — when nobody is left — queueing it for the moment the
+ * first agent's limit lifts. Everything it does is a `status` event in the
+ * thread, so the record says who did what and why.
+ */
+import type { AgentConfig, EventKind, LoomEvent } from "../../types.js";
+import type { QueueInput } from "../../core/prompt-queue.js";
+export interface RelayConfig {
+    /** Off: a limit is reported, the work waits (default on). */
+    auto?: boolean;
+    /** Who picks up, in order (agent ids). Default: every other CLI agent in roster order. */
+    to?: string[];
+    /** Give the chat back to the first agent when its limit resets (default on). */
+    handBack?: boolean;
+}
+export interface RelayHost {
+    config(): {
+        relay?: RelayConfig;
+        agents: AgentConfig[];
+    };
+    busy(agentId: string): boolean;
+    /** The chat an agent's current turn is in. */
+    turnChat(agentId: string): string | undefined;
+    available(agentId: string): Promise<boolean>;
+    interrupt(chat: string): Promise<unknown>;
+    handoff(to: string): Promise<unknown>;
+    holder(): string | null;
+    setBriefing(agentId: string, text: string): void;
+    send(text: string, agentId: string, chat: string): Promise<unknown>;
+    enqueue(input: QueueInput): unknown;
+    list(opts: {
+        chat?: string;
+        limit?: number;
+        kinds?: EventKind[];
+    }): LoomEvent[];
+    append(e: {
+        kind: EventKind;
+        agentId?: string;
+        chat?: string;
+        payload: Record<string, unknown>;
+    }): LoomEvent;
+    warn(message: string, detail?: unknown): void;
+}
+export declare class QuotaRelay {
+    private readonly host;
+    /** agentId → when its limit lifts. */
+    private capped;
+    /** One relay per request: `${chat}:${requestEventId}`. */
+    private relayed;
+    constructor(host: RelayHost);
+    /** Is this agent out of quota right now? */
+    cappedUntil(agentId: string, now?: number): number | null;
+    /** Every agent out of quota, and until when — for status and the UI. */
+    caps(now?: number): Record<string, number>;
+    /**
+     * Where a new prompt for `agentId` should go: itself, or — while it's out of
+     * quota and relaying is on — whoever would pick up its work.
+     */
+    route(agentId: string, chat?: string): Promise<string>;
+    /** Every agent event passes through: a limit starts a relay. */
+    observe(event: LoomEvent): void;
+    private onLimit;
+    /** Who picks up from `from`: the configured order, else the other CLI agents; available, not capped, not busy. */
+    private next;
+    private cap;
+    /** Hand-backs under way, so a prompt that arrives mid-way waits for the baton instead of missing it. */
+    private lifting;
+    /** Reset, but its stand-in was mid-turn: the baton goes back when that turn ends (agent → stand-in). */
+    private waitingBack;
+    /** Is the relay still holding this agent's work — out of quota, or not yet handed back? */
+    holds(agentId: string): boolean;
+    private backTimers;
+    /**
+     * Give the baton back once the stand-in is idle. Its run_complete usually says when (observe), but
+     * a turn winds down a moment after that event — a reset landing in between saw it "busy" with no
+     * run_complete left to come — so it is also looked at twice a second until then.
+     */
+    private waitBack;
+    private stopWaitingBack;
+    private giveBack;
+    /** The limit lifted: say so, and (by default) give the chat back — now if the stand-in is idle, else when its turn ends. */
+    private lift;
+    /** The request the turn was answering: the last message in the chat from a person (or a route), before `at`. */
+    private lastRequest;
+    stop(): void;
+}

package/dist/daemon/runtime/relay.js

@@ -0,0 +1,240 @@
+/**
+ * Quota Relay: when an agent runs out of quota mid-task, the next one carries
+ * on, with the context, and the first takes the chat back when it resets.
+ *
+ * Recognising the limit is core/quota.ts. Here: which agent picks up (the
+ * project's `relay.to` order, or the other CLI agents in roster order — never
+ * a paid API model unless you list it), stopping the parked turn, handing the
+ * baton over with a briefing that says what happened, re-sending the request
+ * in the same chat, and — when nobody is left — queueing it for the moment the
+ * first agent's limit lifts. Everything it does is a `status` event in the
+ * thread, so the record says who did what and why.
+ */
+import { backAt, quotaHit } from "../../core/quota.js";
+import { MAIN_CHAT } from "../../types.js";
+/** Kinds that are subscriptions with windows, not metered APIs — safe to hand work to by default. */
+const CLI_KINDS = new Set(["claude-code", "codex", "opencode", "grok-code", "antigravity-cli", "agy"]);
+export class QuotaRelay {
+    host;
+    /** agentId → when its limit lifts. */
+    capped = new Map();
+    /** One relay per request: `${chat}:${requestEventId}`. */
+    relayed = new Set();
+    constructor(host) {
+        this.host = host;
+    }
+    /** Is this agent out of quota right now? */
+    cappedUntil(agentId, now = Date.now()) {
+        const c = this.capped.get(agentId);
+        return c && c.resetAt > now ? c.resetAt : null;
+    }
+    /** Every agent out of quota, and until when — for status and the UI. */
+    caps(now = Date.now()) {
+        return Object.fromEntries([...this.capped].filter(([, c]) => c.resetAt > now).map(([id, c]) => [id, c.resetAt]));
+    }
+    /**
+     * Where a new prompt for `agentId` should go: itself, or — while it's out of
+     * quota and relaying is on — whoever would pick up its work.
+     */
+    async route(agentId, chat = MAIN_CHAT) {
+        // the window reset but the baton isn't back yet (its timer hasn't fired, or the hand-back is
+        // mid-flight): finish giving it back first, so the prompt goes to the agent it was meant for
+        const c = this.capped.get(agentId);
+        if (c && !this.cappedUntil(agentId)) {
+            if (c.timer)
+                clearTimeout(c.timer);
+            await this.lift(agentId);
+        }
+        // its stand-in was mid-turn at the reset, so the baton was going back when that turn ended;
+        // a prompt for this agent now is you choosing it — give it back now, as picking it and sending does
+        const standIn = this.waitingBack.get(agentId);
+        if (standIn) {
+            this.waitingBack.delete(agentId);
+            if (this.host.holder() === standIn)
+                await this.giveBack(agentId);
+        }
+        const lifting = this.lifting.get(agentId);
+        if (lifting)
+            await lifting;
+        if (!this.cappedUntil(agentId) || this.host.config().relay?.auto === false)
+            return agentId;
+        const next = await this.next(agentId);
+        if (!next)
+            return agentId;
+        this.host.append({ kind: "status", chat: chat === MAIN_CHAT ? undefined : chat, payload: {
+                state: "quota_redirect", from: agentId, to: next, resetAt: this.cappedUntil(agentId),
+                text: `${agentId} is out of quota until ${backAt(this.cappedUntil(agentId))} — ${next} takes this one`
+            } });
+        return next;
+    }
+    /** Every agent event passes through: a limit starts a relay. */
+    observe(event) {
+        if (!event.agentId)
+            return;
+        if (event.kind === "run_complete")
+            for (const [agentId, standIn] of [...this.waitingBack]) {
+                if (standIn !== event.agentId)
+                    continue;
+                this.waitingBack.delete(agentId);
+                if (this.host.holder() === standIn)
+                    this.giveBack(agentId);
+            }
+        const hit = quotaHit(event);
+        if (hit)
+            void this.onLimit(event.agentId, event, hit).catch((err) => this.host.warn("quota relay failed", err));
+    }
+    async onLimit(agentId, event, hit) {
+        const chat = event.chat ?? this.host.turnChat(agentId) ?? MAIN_CHAT;
+        const already = this.capped.get(agentId);
+        if (!already || already.resetAt < hit.resetAt)
+            this.cap(agentId, hit.resetAt, chat);
+        const request = this.lastRequest(chat, event.id);
+        const key = `${chat}:${request?.id ?? event.id}`;
+        if (this.relayed.has(key))
+            return;
+        this.relayed.add(key);
+        if (this.relayed.size > 500)
+            this.relayed.delete(this.relayed.values().next().value);
+        const where = chat === MAIN_CHAT ? undefined : chat;
+        const back = backAt(hit.resetAt);
+        if (this.host.config().relay?.auto === false || !request) {
+            this.host.append({ kind: "status", agentId, chat: where, payload: { state: "quota_limit", resetAt: hit.resetAt, known: hit.known,
+                    reason: hit.reason, text: `${agentId} is out of quota${hit.known ? ` until ${back}` : ""}; the work waits${request ? " (relay is off)" : ""}` } });
+            return;
+        }
+        // a parked turn (Claude waits inside the CLI until the reset) is stopped, so it can be handed on
+        if (this.host.busy(agentId))
+            await this.host.interrupt(chat).catch(() => { });
+        const next = await this.next(agentId);
+        const prompt = String(request.payload.text ?? "");
+        if (!next) {
+            // nobody left: the request waits in the queue for the first agent's reset
+            this.host.enqueue({ text: prompt, target: { kind: "agent", agentId }, chat, source: "route", when: { kind: "at", at: hit.resetAt } });
+            this.host.append({ kind: "status", agentId, chat: where, payload: { state: "quota_relay", from: agentId, to: null, resetAt: hit.resetAt,
+                    reason: hit.reason, text: `${agentId} is out of quota and no other agent can take over — queued for ${back}, when it resets` } });
+            return;
+        }
+        const c = this.capped.get(agentId);
+        if (c) {
+            c.handedTo = next;
+            c.chat = chat;
+        }
+        this.host.append({ kind: "status", agentId, chat: where, payload: { state: "quota_relay", from: agentId, to: next, resetAt: hit.resetAt,
+                known: hit.known, reason: hit.reason, text: `${agentId} hit its usage limit — ${next} carries on${hit.known ? `; ${agentId} is back around ${back}` : ""}` } });
+        await this.host.handoff(next);
+        this.host.setBriefing(next, [
+            `[Loom quota relay] "${agentId}" was working on this request and ran out of usage quota (${hit.reason}).`,
+            "Its changes so far are in the working tree — read them before you change anything, then continue the task from where it stopped.",
+            "Don't start over unless what it did is wrong; say what you kept.",
+        ].join("\n"));
+        await this.host.send(prompt, next, chat);
+    }
+    /** Who picks up from `from`: the configured order, else the other CLI agents; available, not capped, not busy. */
+    async next(from) {
+        const cfg = this.host.config();
+        const enabled = cfg.agents.filter((a) => a.enabled !== false && a.id !== from);
+        const order = cfg.relay?.to?.length
+            ? cfg.relay.to.map((id) => enabled.find((a) => a.id === id)).filter((a) => Boolean(a))
+            : enabled.filter((a) => CLI_KINDS.has(a.kind) || a.kind === "echo");
+        for (const a of order) {
+            if (this.cappedUntil(a.id) || this.host.busy(a.id))
+                continue;
+            if (await this.host.available(a.id).catch(() => false))
+                return a.id;
+        }
+        return null;
+    }
+    cap(agentId, resetAt, chat) {
+        const prev = this.capped.get(agentId);
+        if (prev?.timer)
+            clearTimeout(prev.timer);
+        const delay = Math.max(0, Math.min(resetAt - Date.now(), 2 ** 31 - 1));
+        const timer = setTimeout(() => void this.lift(agentId), delay);
+        timer.unref?.();
+        this.capped.set(agentId, { resetAt, timer, ...(prev?.handedTo ? { handedTo: prev.handedTo } : {}), chat: prev?.chat ?? chat });
+    }
+    /** Hand-backs under way, so a prompt that arrives mid-way waits for the baton instead of missing it. */
+    lifting = new Map();
+    /** Reset, but its stand-in was mid-turn: the baton goes back when that turn ends (agent → stand-in). */
+    waitingBack = new Map();
+    /** Is the relay still holding this agent's work — out of quota, or not yet handed back? */
+    holds(agentId) { return this.capped.has(agentId) || this.lifting.has(agentId) || this.waitingBack.has(agentId); }
+    backTimers = new Map();
+    /**
+     * Give the baton back once the stand-in is idle. Its run_complete usually says when (observe), but
+     * a turn winds down a moment after that event — a reset landing in between saw it "busy" with no
+     * run_complete left to come — so it is also looked at twice a second until then.
+     */
+    waitBack(agentId, standIn) {
+        this.waitingBack.set(agentId, standIn);
+        if (this.backTimers.has(agentId))
+            return;
+        const t = setInterval(() => {
+            if (this.waitingBack.get(agentId) !== standIn)
+                return this.stopWaitingBack(agentId);
+            if (this.host.busy(standIn))
+                return;
+            this.stopWaitingBack(agentId);
+            this.waitingBack.delete(agentId);
+            if (this.host.holder() === standIn)
+                void this.giveBack(agentId);
+        }, 500);
+        t.unref?.();
+        this.backTimers.set(agentId, t);
+    }
+    stopWaitingBack(agentId) {
+        const t = this.backTimers.get(agentId);
+        if (t)
+            clearInterval(t);
+        this.backTimers.delete(agentId);
+    }
+    giveBack(agentId) {
+        this.stopWaitingBack(agentId);
+        const back = this.host.handoff(agentId).then(() => { }, () => { }).finally(() => this.lifting.delete(agentId));
+        this.lifting.set(agentId, back);
+        return back;
+    }
+    /** The limit lifted: say so, and (by default) give the chat back — now if the stand-in is idle, else when its turn ends. */
+    lift(agentId) {
+        const c = this.capped.get(agentId);
+        this.capped.delete(agentId);
+        if (!c)
+            return this.lifting.get(agentId) ?? Promise.resolve();
+        const chat = c.chat && c.chat !== MAIN_CHAT ? c.chat : undefined;
+        const wants = this.host.config().relay?.handBack !== false && c.handedTo && this.host.holder() === c.handedTo;
+        const busy = Boolean(wants && this.host.busy(c.handedTo));
+        this.host.append({ kind: "status", agentId, chat, payload: { state: "quota_reset", agentId,
+                text: `${agentId}'s usage limit reset${wants ? busy ? ` — the baton goes back to ${agentId} when ${c.handedTo} finishes` : ` — the baton is back with ${agentId}` : ""}` } });
+        if (!wants)
+            return Promise.resolve();
+        // the stand-in is mid-turn: don't cut it off — hand back when that turn ends (observe), or sooner if you ask for this agent
+        if (busy) {
+            this.waitBack(agentId, c.handedTo);
+            return Promise.resolve();
+        }
+        return this.giveBack(agentId);
+    }
+    /** The request the turn was answering: the last message in the chat from a person (or a route), before `at`. */
+    lastRequest(chat, at) {
+        const recent = this.host.list({ chat, limit: 200 });
+        for (let i = recent.length - 1; i >= 0; i--) {
+            const e = recent[i];
+            if (e.id > at)
+                continue;
+            if (e.kind === "message" && !e.agentId && String(e.payload.text ?? "").trim())
+                return e;
+        }
+        return null;
+    }
+    stop() {
+        for (const c of this.capped.values())
+            if (c.timer)
+                clearTimeout(c.timer);
+        this.capped.clear();
+        this.waitingBack.clear();
+        for (const t of this.backTimers.values())
+            clearInterval(t);
+        this.backTimers.clear();
+    }
+}
+//# sourceMappingURL=relay.js.map