stageflow 0.1.0

package/dist/runtime/runManager.d.ts

@@ -0,0 +1,129 @@
+import type { AgentPort, OpaqueAnswer } from "../agent/port.js";
+import type { RunStore } from "../runstore/port.js";
+import type { TaskFile } from "../types/task.js";
+import { type PipelineRunResult } from "./pipelineRunner.js";
+import { type RetryStageResult } from "./runRetryCoordinator.js";
+import { type StageExecutionMode } from "./stageConcurrency.js";
+import { StageProcessLauncher } from "./stageProcessLauncher.js";
+import { StageHitlController, type DeliverAnswerResult, type HitlSeams } from "./stageHitl.js";
+import { type StartTaskInput } from "./taskInput.js";
+import type { OperatorCatalog } from "./stageAttemptBootstrap.js";
+export type BusyCode = "busy_capacity" | "busy_checkout";
+export type StartRunResult = {
+    ok: true;
+    runId: string;
+    done: Promise<PipelineRunResult>;
+} | {
+    ok: false;
+    reason: string;
+    status?: number;
+    code?: BusyCode;
+    activeCount?: number;
+    maxConcurrent?: number;
+    activeRunIds?: string[];
+    conflictingRunId?: string;
+    conflictingCheckout?: string;
+};
+export type CapacityHealth = {
+    ok: true;
+    activeRunIds: string[];
+    activeCount: number;
+    maxConcurrent: number;
+    slotsAvailable: number;
+    activeStageProcesses: number;
+    maxActiveStageProcesses: number | null;
+};
+export type { DeliverAnswerResult };
+export type { RetryStageResult };
+export type AbandonStageResult = {
+    ok: true;
+    runId: string;
+    stageId: string;
+} | {
+    ok: false;
+    reason: string;
+    status?: number;
+};
+export declare class RunManager {
+    private readonly options;
+    private readonly active;
+    private readonly checkoutLeases;
+    private readonly provisionalIds;
+    private readonly resumeInFlight;
+    private readonly retryInFlight;
+    private trackingGeneration;
+    private maxConcurrent;
+    private readonly maxActiveStagesPerRun;
+    private readonly executionMode;
+    private readonly stageProcessLauncher;
+    private readonly hitl;
+    private readonly attachedWaiting;
+    private readonly retryCoordinator;
+    private readonly retryTracking;
+    private readonly cwd;
+    constructor(options: {
+        agent: AgentPort;
+        store: RunStore;
+        cwd?: string;
+        operatorCatalog?: OperatorCatalog;
+        seams?: HitlSeams;
+        maxConcurrent?: number;
+        maxActiveStagesPerRun?: number;
+        executionMode?: StageExecutionMode;
+        stageProcessLauncher?: StageProcessLauncher;
+    });
+    getMaxConcurrent(): number;
+    setMaxConcurrent(n: number): CapacityHealth;
+    getActiveCount(): number;
+    getActiveRunIds(): string[];
+    getHealth(): CapacityHealth;
+    getHitlController(): StageHitlController;
+    /**
+     * KTD7/KTD8: discover waiting stages from the store; leave waiting; do not
+     * auto-resume. Registers each waiting run into the active set (capacity)
+     * and re-acquires checkout leases from durable checkout_root (even over soft max).
+     */
+    attachWaitingStages(): Promise<Array<{
+        runId: string;
+        stageId: string;
+    }>>;
+    hasActiveWorker(runId: string, stageId: string): boolean;
+    reconcileOrphanedStages(): Promise<{
+        reconciled: Array<{
+            runId: string;
+            stageId: string;
+            reason: string;
+        }>;
+    }>;
+    abandonStage(runId: string, stageId: string): Promise<AbandonStageResult>;
+    startRun(input: StartTaskInput & {
+        pipeline: string;
+        task?: string | TaskFile;
+        checkoutOverride?: string;
+    }): Promise<StartRunResult>;
+    rerun(runId: string): Promise<StartRunResult>;
+    retryStage(runId: string, stageId: string): Promise<RetryStageResult>;
+    /**
+     * Deliver an operator answer for `(runId, stageId)` (KTD2 / KTD6).
+     * Same-process: unparks the live yield loop. After restart: reconstructs
+     * the stage session seam and continues that stage (KTD8).
+     */
+    deliverAnswer(runId: string, stageId: string, opaqueAnswer: OpaqueAnswer): Promise<DeliverAnswerResult>;
+    private resumeViaSubprocess;
+    private reconstructAndContinue;
+    private reserveAndStartPipeline;
+    private busyFailure;
+    private tryReserve;
+    private clearReservation;
+    private track;
+    /**
+     * Acquire active tracking + checkout lease for a restart resume before
+     * reconstruct starts. Over-max is allowed. Lease held by another run → fail closed.
+     */
+    private ensureResumeTracked;
+    private registerResumeUntrack;
+    private findActiveCheckoutConflict;
+    private quarantineAttachRun;
+    private untrackIfGeneration;
+    private removeActiveEntry;
+}