@wjarka/cezarion 0.14.6 → 0.14.7-pr488.741

package/dist/workflows/run.d.ts

@@ -1,3 +1,4 @@
+import { type CiWait, type CiWaitRequest } from '../contract/index.js';
 import { type WorkerAccountBinding } from '../delegation/execution-identity.ts';
 import type { DelegationProvisioner } from '../delegation/provision.ts';
 import type { RunnerId } from '../core/agent-runner.ts';
@@ -255,10 +256,18 @@ export declare class RunManager {
     /** Durable monitoring subset. Only the configured number receives the waiting-slot exemption. */
     private readonly monitoring;
     /** Separate from human waiting: these resumes MUST reacquire scheduler capacity. */
+    private readonly ciWakeQueuedAt;
+    private readonly ciWakeAdmitted;
+    private readonly ciWatches;
+    private readonly ciRegistrations;
+    private readonly ciRetries;
+    private readonly ciResources;
+    private ciSupervisor;
     private readonly workerWaiting;
     private readonly workerWakeAdmitted;
     private readonly workerWakeQueuedAt;
     private readonly workerWaitTimers;
+    private readonly inboxClaimTimers;
     private reconcilingWorkers;
     private recovering;
     private disposed;
@@ -400,6 +409,15 @@ export declare class RunManager {
     private delegationProvisioner?;
     setDelegationProvisioner(provisioner: DelegationProvisioner): () => void;
     private provisionSession;
+    /** Provision the same capability and descriptor on every start, Continue and recovered launch. */
+    private provisionCiSession;
+    /** Trusted capability callbacks supply run identity; the model supplies only a PR and deadline. */
+    registerCiWait(runId: string, request: CiWaitRequest, generation: string, capabilitySignal?: AbortSignal): Promise<CiWait>;
+    private startCiWatch;
+    private retryCiAdmission;
+    private parkCiWait;
+    private queueCiWake;
+    private withdrawCiWait;
     /** Snapshot of the actual active session, never guessed from partial run settings. */
     delegationExecutionSettings(runId: string): DelegationExecutionSettings;
     /**
@@ -725,8 +743,26 @@ export declare class RunManager {
      * results retain attention. Human input starts a fresh completion cycle. */
     private deferParentCompletion;
     registerWorkerWait(parentId: string, request: WorkerWaitRequest): WorkerWait;
+    private assertCanRegisterWorkerWait;
+    /** An answer already executing in this generation is not an unanswered question.
+     * Keep the durable checkpoint at turn-end for crash recovery, and match its exact
+     * sequence so it can never hide a newer question. */
+    private hasUnansweredHumanAsk;
     /** Both roles can select their own requests without acquiring worker-management authority. */
     registerRequestWait(runId: string, request: RequestWaitRequest): WorkerWait;
+    /** A wait wake is only a pointer. Only provider submission/opening prompts own delivery. */
+    private providerOwnsInboxInput;
+    canClaimInboxInput(runId: string, id: string): boolean;
+    /** The service supplies authorized, bounded IDs; claim and flight reservations are synchronous. */
+    reserveInboxInputs(runId: string, generation: string, ids: readonly string[]): {
+        receiptId: string;
+        expiresAt: string;
+        inputIds: string[];
+    } | undefined;
+    acknowledgeInbox(runId: string, generation: string, receiptId: string): 'acknowledged' | 'already-acknowledged';
+    releaseInbox(runId: string, generation: string, receiptId: string): 'released';
+    /** Expiry is an independent wake source, including after the provider's last turn. */
+    private armInboxClaimExpiry;
     /** Accepted conversation input uses the existing scheduler admission for idle recipients. */
     deliverConversationInput(runId: string): void;
     /** Cancel only the wait; persist its settlement before ordinary wake admission. */
@@ -761,6 +797,8 @@ export declare class RunManager {
     private submitAgentInput;
     /** False leaves the durable entry untouched. No human-answer/slash-expansion fallback. */
     private flushAgentInputs;
+    private formatAgentInput;
+    private agentInputOutcomeText;
     /** Deliver anything `deferMessage` buffered, once the session is live. */
     private flushDeferred;
     /**
@@ -808,7 +846,7 @@ export declare class RunManager {
     }, 
     /** Restart recovery may discover several interrupted tasks at once. Those
      *  continuations are queued; an explicit user Continue remains immediate. */
-    deferForCapacity?: boolean): {
+    deferForCapacity?: boolean, conversation?: Parameters<RunStore['commitWorkerContinuation']>[3]): {
         ok: boolean;
         error?: string;
     };