@wjarka/cezarion 0.14.6 → 0.14.7

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,6 +256,13 @@ 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;
@@ -400,6 +408,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,6 +742,11 @@ 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;
     /** Accepted conversation input uses the existing scheduler admission for idle recipients. */
@@ -761,6 +783,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 +832,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;
     };