@wjarka/cezarion 0.14.7-pr488.741 → 0.14.8-dev.817

package/dist/workflows/run.d.ts

@@ -44,6 +44,10 @@ export type DelegationExecutionSettings = {
     allowedTools?: string[];
     bashAllowlist?: string[];
 };
+/** Safety cap on autonomous auto-continues per run — stops a stuck agent from nudging forever. */
+/** #505: a real steer is read at the harness's next model step; a quiet boundary this long
+ * with input still unread means the harness will not read it without help. */
+export declare const UNREAD_INPUT_GRACE_MS = 30000;
 /**
  * Auto-resume after a provider usage limit (spec 2026-08-03-auto-resume-after-usage-limit).
  *
@@ -270,6 +274,8 @@ export declare class RunManager {
     private readonly inboxClaimTimers;
     private reconcilingWorkers;
     private recovering;
+    /** Quiet window before unread input is resubmitted or left unconfirmed (#505). */
+    private readonly unreadInputGraceMs;
     private disposed;
     private readonly onDelegationRun;
     private readonly pendingJobs;
@@ -329,6 +335,7 @@ export declare class RunManager {
     private readonly offSemaphore;
     constructor(store: RunStore, repoRoot: string, options?: {
         semaphore?: WorkspaceSemaphore;
+        unreadInputGraceMs?: number;
     });
     /**
      * Release everything this manager owns without touching run records
@@ -434,9 +441,26 @@ export declare class RunManager {
         effort?: string;
         agentProfile?: string;
     }): Promise<DelegationExecutionSettings>;
+    /**
+     * Idempotent start (#504, spec 2026-09-24-cez-task-cli). Lookup and create share one
+     * synchronous path, so the event loop serialises concurrent retries: the first creates, every
+     * later one with the same hash gets that run back, and a different hash is a conflict.
+     */
+    startRunIdempotent(workflow: WorkflowDef, input: StartRunInput, request: {
+        id: string;
+        hash: string;
+    }): {
+        run: RunRecord;
+        created: boolean;
+    } | {
+        conflict: true;
+    };
     startRun(workflow: WorkflowDef, input: StartRunInput, group?: {
         groupId: string;
         variant: string;
+    }, clientRequest?: {
+        id: string;
+        hash: string;
     }): RunRecord;
     /** Accept only the store's already-durable owned creation, never caller-supplied paths/workflows. */
     enqueueOwnedRun(runId: string): void;
@@ -765,6 +789,28 @@ export declare class RunManager {
     private armInboxClaimExpiry;
     /** Accepted conversation input uses the existing scheduler admission for idle recipients. */
     deliverConversationInput(runId: string): void;
+    /** A worker's pending question goes to its owning parent as a conversation request
+     * (#505). The worker still parks on its ask; only the parent's reply, or a human after
+     * fallback, answers it. Routing is idempotent: the message ID derives from the ask seq. */
+    private routeWorkerQuestion;
+    /** A human answering a worker question its parent handed back (#505): the reviewing parent
+     * can no longer answer it, so it must not also block the human. */
+    private answersFallenBackAsk;
+    /** The worker's pending ask when it went to the parent and has not fallen back to a human. */
+    private routedAsk;
+    /** The parent's reply answers the routed question like a human answer would: through the
+     * live session's native answer seam, or by reopening a session that is gone (#505). */
+    private answerRoutedQuestion;
+    /** A routed question settled without a reply (its worker stopped, a deadline, fallback) can
+     * never be answered by the parent any more: hand it to the human on the worker (#505). */
+    private retireSettledQuestions;
+    /** Routed questions this parent has not answered yet, by asking worker. */
+    private unansweredQuestions;
+    /** The parent can no longer answer: its workers' routed questions go back to the human
+     * (#505). The outcome lands first, so a crash before the worker's event repeats this. */
+    private fallbackRoutedQuestions;
+    /** The parent can still read and answer a routed question; answering needs its steer grant. */
+    private parentCanReceive;
     /** Cancel only the wait; persist its settlement before ordinary wake admission. */
     cancelWorkerWait(parentId: string, waitId: string): WorkerWait;
     private workerWait;
@@ -791,6 +837,37 @@ export declare class RunManager {
     /** Accepted input may be temporarily refused while a backend HTTP ack is
      * outstanding. That is not an empty queue and must not trigger automatic DONE. */
     private hasQueuedAgentInputs;
+    /** Only the current session's observation writes consumedAt (#505). An ID reported
+     * before its acceptance checkpoint lands is applied when that checkpoint commits. */
+    private handleAgentInputConsumed;
+    /** #505: input the harness accepted but will never read returns to the queue, so
+     * DONE, auto-end and park see queued work. Out of a turn (an OpenCode lost wake)
+     * it is submitted right away; at a turn-end the handler's own flush submits it. */
+    private retireUnreadInputs;
+    /** #505: the harness started the opening turn, so the opening input was accepted.
+     * Its replay-prompt retirement still waits for that turn's successful end. */
+    private recordOpeningAccepted;
+    /** The conversation messages the next submission would carry, if nothing but
+     * conversation input leads the queue (lifecycle input stays a barrier). */
+    private pendingConversationBatch;
+    /** Bundled messages rode the answer's own write: delivered now, read when that turn ends. */
+    private commitBundledDelivery;
+    /** The turn that carried bundled messages has ended: the model read them. */
+    private readBundledInputs;
+    /** #505: the session closed without reporting it read (failure, stop, exit): the input
+     * goes back to the queue so a later session delivers it; never shown as delivered. */
+    private requeueUnreadAtClose;
+    /** An idle, open boundary with nothing left to deliver: DONE closes, otherwise the
+     * run parks as waiting or monitoring. Shared by acknowledgements that land after a
+     * turn ended and by the unread-input grace timer (#505). */
+    private settleIdleBoundary;
+    /** #505 liveness bound: a harness that accepted input and then neither read it nor ran
+     * another turn must not hold the run and its slot forever. After a quiet grace window the
+     * input is resubmitted once; after a second it is left delivered but unconfirmed. */
+    private armUnreadInputTimer;
+    private clearUnreadInputTimer;
+    /** #505: the harness accepted input this session has not reported reading yet. */
+    private harnessOwesInput;
     /** A callback from an old/replaced/disposed session carries no authority. */
     private handleAgentInputReady;
     /** Reservation is synchronous; only an acknowledged transport may checkpoint delivery. */
@@ -843,6 +920,8 @@ export declare class RunManager {
         /** Agent account for the reopened session (spec 2026-07-29-agent-profiles). Omitted = the
          *  account the run is already on. */
         agentProfile?: string;
+        /** #505: the parent reply this continuation delivers as the answer to a routed question. */
+        answerInputId?: string;
     }, 
     /** Restart recovery may discover several interrupted tasks at once. Those
      *  continuations are queued; an explicit user Continue remains immediate. */