@bridge4dev/runner 0.13.1 → 0.26.0

package/dist/supervisor.d.ts

@@ -1,4 +1,5 @@
 import { JournalStore } from './journal.js';
+import { proposeCommitMessage } from './commit-message.js';
 import { selfUpdate, type SelfUpdateOutcome } from './self-update.js';
 import type { RunnerWsClient } from './ws-client.js';
 import type { SessionDescriptor } from './protocol.js';
@@ -30,6 +31,14 @@ export interface SupervisorOptions {
      * machine's owner decides how much of their machine an agent fleet may take.
      */
     maxSessionsLimit?: number;
+    /**
+     * `[verify] enabled` from the runner's own config (session 14). The machine's
+     * owner has the last word on whether project recipes run here at all;
+     * `false` means the capability is not announced and no run can be started.
+     */
+    verifyEnabled?: boolean;
+    /** Test seam for the one-shot commit-message run. */
+    proposeCommitMessage?: typeof proposeCommitMessage;
 }
 export declare class Supervisor {
     private readonly ws;
@@ -54,10 +63,32 @@ export declare class Supervisor {
     private readonly repoLocks;
     /** An update is installing right now — a second one would fight it. */
     private selfUpdateInFlight;
+    /** Session 14: one project-recipe run per machine, and its verdict queue. */
+    private readonly verify;
+    private readonly verifyReports;
     constructor(ws: RunnerWsClient, opts: SupervisorOptions);
+    /**
+     * Push every unacked verdict at the API.
+     *
+     * Called on each reconnect and whenever a run finishes. Sending a report the
+     * API already has is harmless — it is keyed by `runId` and stored idempotently
+     * — while not sending one is a verdict that never existed.
+     */
+    private flushVerifyReports;
     get activeSessionIds(): string[];
     private onFrame;
     private startSession;
+    /**
+     * Where this session is going to work — a worktree of its own, or the project
+     * folder itself (session 16).
+     *
+     * The BRANCH path takes the repo lock because `worktree add` writes into the
+     * shared `.git` (registration + prune), exactly like commit/apply/revert. The
+     * DIRECT path takes none: it only READS which branch a folder is on, and
+     * queueing every session start behind whatever merge happens to be running
+     * would be a lock bought for nothing.
+     */
+    private prepareWorkspace;
     /**
      * Spin the adapter up — for a fresh session, a resume-on-next-message, or a
      * free CHAT session with no prompt at all (the agent boots, reports its
@@ -100,6 +131,23 @@ export declare class Supervisor {
      */
     private pauseForBudget;
     private pumpEvents;
+    /**
+     * "…and N of them are waiting for an answer from you."
+     *
+     * An open question pins its slot deliberately (`isParkable`), so a message
+     * that blames a running turn sends the user to wait for something that will
+     * never happen. Empty when nothing is waiting.
+     */
+    private waitingForAnswerSuffix;
+    /**
+     * Close out every ask this session still has open, with a stated cause.
+     *
+     * Idempotent: the adapter reports its own `question_resolved` when it can, and
+     * `forwardEvent` clears the id — so by the time this runs the set is usually
+     * already empty. What it catches is the path where the adapter never got the
+     * chance, and the alternative there is a card that stays clickable forever.
+     */
+    private withdrawOpenQuestions;
     /**
      * Deliver messages that were held because every slot was taken.
      *
@@ -140,10 +188,27 @@ export declare class Supervisor {
      * returns false and the caller tells the user rather than thrashing.
      */
     private ensureCapacity;
-    /** Idle after a finished turn — safe to kill the process and resume later. */
+    /**
+     * Idle after a finished turn — safe to kill the process and resume later.
+     *
+     * An open question is the exception (session 12): WAITING_INPUT there does
+     * NOT mean "the turn is over", it means the agent's tool call is parked on a
+     * human. Parking such a session killed a live turn — and, worse, killed the
+     * card the user was about to answer — the moment another session wanted a
+     * slot.
+     */
     private isParkable;
     private park;
     private forwardEvent;
+    /**
+     * The dashboard's answer to a parked question (session 12).
+     *
+     * A miss is reported in the feed rather than swallowed: the three cases that
+     * get here — a card from a previous life of the session, a second click, an
+     * ask the runner already withdrew — all look identical to the user unless
+     * somebody says so.
+     */
+    private onQuestionAnswer;
     private onUserMessage;
     /**
      * Run delivery work for one session, strictly after whatever is already
@@ -212,5 +277,47 @@ export declare class Supervisor {
     /** Graceful daemon shutdown: kill agents, keep sessions resumable server-side. */
     shutdown(): void;
 }
+/**
+ * The first message the agent gets.
+ *
+ * Two shapes, and the difference is whether tickets were handed over
+ * (session 16, owner's decision):
+ *
+ *  - **No tickets** — exactly what the human typed, and an empty prompt stays
+ *    empty. That is how you get a session that boots and waits for you to talk
+ *    first; it is a feature, not an oversight.
+ *  - **Tickets handed to a TICKET session** — the assignment is always sent and
+ *    cannot be removed: «Implement ticket #28.» Handing a ticket over IS the
+ *    instruction, so making the human retype it was ceremony. Anything they
+ *    typed follows underneath.
+ *
+ * What is NOT here any more: eight lines about which MCP tools to call and
+ * which statuses to move through. That is a standing convention of the project,
+ * true on the twentieth turn as much as the first, so it moved to the system
+ * prompt beside `CLAUDE.md` — which is read last and therefore overrides ours.
+ */
 export declare function composeInitialPrompt(descriptor: SessionDescriptor): string;
+/**
+ * Extra system-prompt material: where this session is in git, and how tickets
+ * are meant to move (session 13).
+ *
+ * Facts about THIS SESSION, and nothing else. They exist in no file on disk —
+ * which branch the agent is on, that it must not push, where a plan belongs,
+ * what to do with the tickets it was given — so somebody has to say them, and
+ * that somebody is us.
+ *
+ * The project's own documentation is deliberately NOT here. Both agents read
+ * their own file natively, verified live: Claude picks up `CLAUDE.md` through
+ * its memory mechanism (since `settingSources` includes `'project'`), and Codex
+ * picks up `AGENTS.md` even under the runner's isolated `CODEX_HOME`. Pasting a
+ * copy on top of that was work we were doing for no one — and when it was
+ * switched off for Claude alone it briefly left repositories that carry only
+ * `AGENTS.md` with nothing at all, which is precisely the kind of hole a
+ * half-measure digs.
+ *
+ * A repository that wants both agents equipped ships both files, or symlinks
+ * one to the other. That is a repository convention and not something a runner
+ * should paper over.
+ */
+export declare function composeWorkspaceContext(descriptor: SessionDescriptor): string;
 //# sourceMappingURL=supervisor.d.ts.map