@osolmaz/pi-workflows 0.16.4 → 0.16.6

package/src/workflows/tool-input.ts

@@ -13,13 +13,12 @@ const inputSchema = Type.Unknown({
 });
 const runIdSchema = Type.String({
   description:
-    "Run id; required for restart and optional for status, cancel, answer, settings, and follow-ups",
+    "Run id; required for restart and optional for status, cancel, settings, and follow-ups",
 });
-const stepSchema = Type.String({
-  description: "Workflow step id; required when action is update or submit",
-});
-const attemptSchema = Type.String({
-  description: "Workflow attempt id; required when action is update or submit",
+const requestIdSchema = Type.String({
+  minLength: 1,
+  description:
+    "Exact durable request id from the step contract or checkpoint; required for answer, update, and submit",
 });
 const updateSchema = Type.Object(
   {
@@ -45,7 +44,18 @@ export const WorkflowActionSchemas = {
     },
     noExtraProperties,
   ),
-  restart: Type.Object({ action: Type.Literal("restart"), runId: runIdSchema }, noExtraProperties),
+  restart: Type.Object(
+    {
+      action: Type.Literal("restart"),
+      runId: runIdSchema,
+      expectedRevision: Type.Integer({
+        minimum: 0,
+        description:
+          "Use runRevision from the terminal run view, not its presentation revision. Restart only when the user explicitly requests a fresh run.",
+      }),
+    },
+    noExtraProperties,
+  ),
   "change-settings": Type.Object(
     {
       action: Type.Literal("change-settings"),
@@ -85,16 +95,15 @@ export const WorkflowActionSchemas = {
   answer: Type.Object(
     {
       action: Type.Literal("answer"),
+      requestId: requestIdSchema,
       input: inputSchema,
-      runId: Type.Optional(runIdSchema),
     },
     noExtraProperties,
   ),
   update: Type.Object(
     {
       action: Type.Literal("update"),
-      step: stepSchema,
-      attempt: attemptSchema,
+      requestId: requestIdSchema,
       update: updateSchema,
     },
     noExtraProperties,
@@ -102,8 +111,7 @@ export const WorkflowActionSchemas = {
   submit: Type.Object(
     {
       action: Type.Literal("submit"),
-      step: stepSchema,
-      attempt: attemptSchema,
+      requestId: requestIdSchema,
       output: outputSchema,
     },
     noExtraProperties,

package/src/workflows/transitions.ts

@@ -0,0 +1,330 @@
+import { isDeepStrictEqual } from "node:util";
+import type { JsonValue } from "../state/json.js";
+import { resolveNext, resolveNextForOutcome } from "./graph.js";
+import type {
+  WorkflowDefinitionSnapshot,
+  WorkflowRunState,
+  WorkflowStepRecord,
+  WorkflowTraceEventDraft,
+} from "./types.js";
+
+/** Worker proposals carry one change, never a replacement run projection. */
+export type WorkflowTransition = {
+  event: WorkflowTraceEventDraft;
+} & (
+  | { kind: "startAttempt"; startedAt: string }
+  | { kind: "finishAttempt"; step: WorkflowStepRecord }
+  | { kind: "setTimeout"; timeoutMs: number | null }
+  | { kind: "resume"; attemptId?: string }
+  | { kind: "pause" }
+  | { kind: "resumeInteraction" }
+  | {
+      kind: "waitForInput";
+      requestId: string;
+      requestKind: "checkpoint" | "decision";
+      contract: JsonValue;
+    }
+  | {
+      kind: "finish";
+      status: "completed" | "failed" | "timed_out" | "cancelled";
+      error?: string;
+      finalOutput?: unknown;
+    }
+  | { kind: "record" }
+);
+
+/** Translate engine-local state into the narrow proposal for this event. */
+export function executionTransition(
+  state: WorkflowRunState,
+  event: WorkflowTraceEventDraft,
+): WorkflowTransition {
+  switch (event.type) {
+    case "node_started":
+      if (state.currentNodeStartedAt === undefined)
+        throw new Error("Attempt start time is missing");
+      return { kind: "startAttempt", startedAt: state.currentNodeStartedAt, event };
+    case "node_finished":
+    case "node_failed": {
+      const step = state.steps.at(-1);
+      if (step === undefined || step.attemptId !== event.attemptId) {
+        throw new Error("Finished attempt is missing from engine state");
+      }
+      return { kind: "finishAttempt", step, event };
+    }
+    case "node_timeout_set":
+      return { kind: "setTimeout", timeoutMs: state.currentNodeTimeoutMs ?? null, event };
+    case "run_resumed":
+      return {
+        kind: "resume",
+        ...(state.currentAttemptId === undefined ? {} : { attemptId: state.currentAttemptId }),
+        event,
+      };
+    case "run_paused":
+      return { kind: "pause", event };
+    case "interaction_validation_started":
+    case "interaction_accepted":
+      return { kind: "resumeInteraction", event };
+    case "run_completed":
+    case "run_failed":
+    case "run_interrupted":
+    case "run_timed_out":
+    case "run_cancelled":
+      if (state.status === "running" || state.status === "waiting")
+        throw new Error("Terminal transition has unfinished execution");
+      return {
+        kind: "finish",
+        status: state.status,
+        ...(state.error === undefined ? {} : { error: state.error }),
+        ...(state.finalOutput === undefined ? {} : { finalOutput: state.finalOutput }),
+        event,
+      };
+    default:
+      return { kind: "record", event };
+  }
+}
+
+const recordEvents = new Set([
+  "run_started",
+  "include_entered",
+  "include_exited",
+  "settings_route_retried",
+  "agent_session_required",
+  "agent_prompt_sent",
+  "interaction_resume_prepared",
+]);
+
+/** Apply a validated transition to a projection read by the durable owner. */
+export function applyExecutionTransition(
+  current: WorkflowRunState,
+  definition: WorkflowDefinitionSnapshot,
+  transition: WorkflowTransition,
+  now: string,
+): WorkflowRunState {
+  if (
+    current.status !== "running" &&
+    !(current.status === "waiting" && transition.kind === "resumeInteraction")
+  ) {
+    throw new Error(`Run ${current.runId} cannot execute with status ${current.status}`);
+  }
+  const state = structuredClone(current);
+  const event = transition.event;
+  if (typeof event !== "object" || event === null || typeof event.type !== "string") {
+    throw new Error("Execution transition event is invalid");
+  }
+  switch (transition.kind) {
+    case "startAttempt": {
+      requireEvent(event, "node_started");
+      const nodeId = requireIdentity(event.nodeId, "node");
+      const attemptId = requireIdentity(event.attemptId, "attempt");
+      const node = definition.nodes[nodeId];
+      if (node === undefined || node.nodeType !== event.payload.nodeType) {
+        throw new Error("Attempt node does not match the workflow definition");
+      }
+      if (state.steps.some((step) => step.attemptId === attemptId)) {
+        throw new Error("A completed attempt cannot start again");
+      }
+      if (state.currentAttemptId !== undefined) {
+        throw new Error("Another attempt is already active");
+      }
+      if (nextNode(definition, state) !== nodeId) {
+        throw new Error("Attempt does not follow the accepted graph route");
+      }
+      if (!Number.isFinite(Date.parse(transition.startedAt)))
+        throw new Error("Invalid attempt time");
+      state.currentNode = nodeId;
+      state.currentAttemptId = attemptId;
+      state.currentNodeStartedAt = transition.startedAt;
+      setSettings(state, event.payload);
+      if (node.statusDetail !== undefined) state.statusDetail = node.statusDetail;
+      break;
+    }
+    case "finishAttempt": {
+      const step = transition.step;
+      requireEvent(event, step.outcome === "ok" ? "node_finished" : "node_failed");
+      requireAttempt(state, event);
+      if (
+        step.attemptId !== event.attemptId ||
+        step.nodeId !== event.nodeId ||
+        step.nodeType !== definition.nodes[step.nodeId]?.nodeType ||
+        step.startedAt !== state.currentNodeStartedAt ||
+        step.outcome !== event.payload.outcome ||
+        !isDeepStrictEqual(step.output, event.payload.output ?? null)
+      ) {
+        throw new Error("Attempt result does not match the active request");
+      }
+      if (state.steps.some((prior) => prior.attemptId === step.attemptId)) {
+        throw new Error("Attempt result was already committed");
+      }
+      state.steps.push(structuredClone(step));
+      state.results[step.nodeId] = {
+        ...step,
+        durationMs: Date.parse(step.finishedAt) - Date.parse(step.startedAt),
+      };
+      if (step.outcome === "ok") state.outputs[step.nodeId] = step.output;
+      clearAttempt(state);
+      break;
+    }
+    case "setTimeout":
+      requireEvent(event, "node_timeout_set");
+      requireAttempt(state, event);
+      if (
+        transition.timeoutMs !== null &&
+        (!Number.isFinite(transition.timeoutMs) || transition.timeoutMs <= 0)
+      ) {
+        throw new Error("Invalid attempt timeout");
+      }
+      if (state.currentNodeElapsedMs !== undefined)
+        throw new Error("Attempt timeout was already configured");
+      state.currentNodeTimeoutMs = transition.timeoutMs;
+      state.currentNodeElapsedMs = 0;
+      break;
+    case "resume":
+      requireEvent(event, "run_resumed");
+      if (transition.attemptId !== undefined && transition.attemptId !== state.currentAttemptId) {
+        throw new Error("Resume does not name the active attempt");
+      }
+      if (transition.attemptId === undefined) clearAttempt(state);
+      delete state.paused;
+      break;
+    case "waitForInput":
+      requireEvent(event, "checkpoint_requested");
+      requireAttempt(state, event);
+      if (definition.nodes[state.currentNode ?? ""]?.nodeType !== "checkpoint") {
+        throw new Error("Only a checkpoint can request checkpoint input");
+      }
+      state.status = "waiting";
+      state.waitingOn = requireIdentity(event.nodeId, "node");
+      state.statusDetail =
+        transition.requestKind === "decision"
+          ? "waiting for a human decision"
+          : "waiting for checkpoint input";
+      delete state.finishedAt;
+      break;
+    case "resumeInteraction":
+      if (
+        event.type !== "interaction_validation_started" &&
+        event.type !== "interaction_accepted"
+      ) {
+        throw new Error("Invalid interaction resume event");
+      }
+      if (state.waitingOn !== event.nodeId || state.currentAttemptId !== event.attemptId) {
+        throw new Error("Interaction does not match the waiting attempt");
+      }
+      state.status = "running";
+      state.currentNode = requireIdentity(event.nodeId, "node");
+      delete state.waitingOn;
+      delete state.finishedAt;
+      delete state.statusDetail;
+      break;
+    case "pause":
+      requireEvent(event, "run_paused");
+      state.paused = true;
+      break;
+    case "finish":
+      if (
+        !["completed", "failed", "timed_out", "cancelled"].includes(transition.status) ||
+        (event.type !== `run_${transition.status}` &&
+          !(event.type === "run_interrupted" && transition.status === "failed"))
+      ) {
+        throw new Error("Run outcome does not match the transition");
+      }
+      if (transition.status === "completed" && state.currentAttemptId !== undefined) {
+        throw new Error("A run with an unfinished attempt cannot complete");
+      }
+      if (transition.status === "completed") {
+        const last = state.steps.at(-1);
+        if (
+          last?.outcome !== "ok" ||
+          nextNode(definition, state) !== null ||
+          !isDeepStrictEqual(transition.finalOutput, last.output)
+        ) {
+          throw new Error("Completion does not match the accepted graph result");
+        }
+      }
+      state.status = transition.status;
+      state.finishedAt = now;
+      if (transition.error !== undefined) state.error = transition.error;
+      if (transition.finalOutput !== undefined) state.finalOutput = transition.finalOutput;
+      clearAttempt(state);
+      break;
+    case "record":
+      if (!recordEvents.has(event.type)) throw new Error(`Unknown execution event: ${event.type}`);
+      if (event.type === "agent_prompt_sent" || event.type === "agent_session_required") {
+        requireAttempt(state, event);
+      }
+      if (event.type === "agent_session_required")
+        state.statusDetail = "waiting for origin Pi session";
+      if (event.type === "settings_route_retried") {
+        const payload = event.payload;
+        if (typeof payload.scopeId !== "string" || typeof payload.changeNumber !== "number") {
+          throw new Error("Settings retry binding is invalid");
+        }
+        state.currentSettingsScopeId = payload.scopeId;
+        state.currentSettingsChangeNumber = payload.changeNumber;
+        if (typeof payload.settingsHash !== "string")
+          throw new Error("Settings retry hash is missing");
+        state.currentSettingsHash = payload.settingsHash;
+      }
+      break;
+    default:
+      throw new Error("Unknown execution transition");
+  }
+  return state;
+}
+
+function nextNode(definition: WorkflowDefinitionSnapshot, state: WorkflowRunState): string | null {
+  const last = state.steps.at(-1);
+  if (last === undefined) return definition.startAt;
+  const result = state.results[last.nodeId];
+  if (result === undefined) throw new Error("Accepted graph result is missing");
+  return result.outcome === "ok"
+    ? resolveNext(definition.edges, last.nodeId, result.output, result)
+    : resolveNextForOutcome(definition.edges, last.nodeId, result);
+}
+
+function requireEvent(event: WorkflowTraceEventDraft, type: string): void {
+  if (event.type !== type) throw new Error(`Transition requires ${type}`);
+}
+
+function requireIdentity(value: string | undefined, name: string): string {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`Missing ${name} identity`);
+  return value;
+}
+
+function requireAttempt(state: WorkflowRunState, event: WorkflowTraceEventDraft): void {
+  if (
+    state.currentNode !== requireIdentity(event.nodeId, "node") ||
+    state.currentAttemptId !== requireIdentity(event.attemptId, "attempt")
+  ) {
+    throw new Error("Execution transition does not match the active attempt");
+  }
+}
+
+function clearAttempt(state: WorkflowRunState): void {
+  delete state.currentNode;
+  delete state.currentAttemptId;
+  delete state.currentNodeStartedAt;
+  delete state.currentNodeTimeoutMs;
+  delete state.currentNodeElapsedMs;
+  delete state.currentSettingsScopeId;
+  delete state.currentSettingsChangeNumber;
+  delete state.currentSettingsHash;
+  delete state.statusDetail;
+}
+
+function setSettings(state: WorkflowRunState, payload: WorkflowTraceEventDraft["payload"]): void {
+  delete state.currentSettingsScopeId;
+  delete state.currentSettingsChangeNumber;
+  delete state.currentSettingsHash;
+  if (typeof payload.settingsScopeId === "string") {
+    if (
+      typeof payload.settingsChangeNumber !== "number" ||
+      typeof payload.settingsHash !== "string"
+    ) {
+      throw new Error("Attempt settings binding is invalid");
+    }
+    state.currentSettingsScopeId = payload.settingsScopeId;
+    state.currentSettingsChangeNumber = payload.settingsChangeNumber;
+    state.currentSettingsHash = payload.settingsHash;
+  }
+}

package/src/workflows/types.ts

@@ -448,20 +448,9 @@ export type HumanDecisionCancellationRecord = {
   reason: "cancelled" | "expired";
 };
 
-export type HumanDecisionContinuationRecord = {
-  schema: "pi-workflows.human-decision-continuation.v1";
-  decisionId: string;
-  requestDigest: string;
-  provenance: "human" | "timeout";
-  parentRunId: string;
-  runId: string;
-  createdAt: string;
-};
-
 /**
- * A pause point. The run terminates with status `waiting` so a human (or an
- * external trigger) can decide how to continue. The optional `run` callback
- * produces the checkpoint's output before the run pauses.
+ * A same-run input request. The optional `run` callback produces its prompt.
+ * The accepted answer becomes the node output; requesting input does not finish the node.
  */
 export type CheckpointNodeDefinition = WorkflowNodeCommon & {
   nodeType: "checkpoint";
@@ -478,15 +467,6 @@ export type WorkflowNodeDefinition =
   | ActionNodeDefinition
   | CheckpointNodeDefinition;
 
-export type WorkflowPresentationContext = {
-  /** Final persisted state of the workflow run. */
-  state: WorkflowRunState;
-  /** Convenience alias for `state.finalOutput`. */
-  finalOutput: unknown;
-  /** Aborted if a new run starts, the session closes, or prompt generation times out. */
-  signal: AbortSignal;
-};
-
 /** Runtime parser that also carries its normalized TypeScript result type. */
 export type WorkflowValueParser<T> = (value: unknown) => MaybePromise<T>;
 
@@ -577,14 +557,6 @@ export type WorkflowDefinition<
   title?:
     | string
     | ((context: { input: TInput; workflowName: string }) => MaybePromise<string | undefined>);
-  /**
-   * Optional instructions for a normal assistant response after the run ends.
-   * The Pi extension resolves this only after the final state is persisted;
-   * the engine and durable store remain presentation-agnostic.
-   */
-  presentationPrompt?:
-    | string
-    | ((context: WorkflowPresentationContext) => MaybePromise<string | undefined>);
   startAt: string;
   nodes: Record<string, WorkflowNodeDefinition>;
   includes?: TIncludes;
@@ -686,14 +658,8 @@ export type WorkflowRunState = {
   traceSeq: number;
   runId: string;
   workflowName: string;
-  /** Set on continuation runs: the checkpointed run this one carries forward. */
+  /** Set on explicit fresh restarts. Checkpoint answers keep the same run. */
   parentRunId?: string;
-  /**
-   * Steps carried from the parent at continuation start. Steps beyond this
-   * count were recorded by this run itself; resume uses it to tell a
-   * carried checkpoint from this run's own.
-   */
-  carriedStepCount?: number;
   runTitle?: string;
   /** Stable built-in identity or immutable file source used by this run. */
   workflowSource?: WorkflowSource;
@@ -718,12 +684,13 @@ export type WorkflowRunState = {
   currentAttemptId?: string;
   currentNodeStartedAt?: string;
   /** Durable active-execution deadline for the current attempt. Null disables the deadline. */
-  currentNodeDeadlineAt?: string | null;
+  currentNodeTimeoutMs?: number | null;
+  currentNodeElapsedMs?: number;
   currentSettingsScopeId?: string;
   currentSettingsChangeNumber?: number;
   currentSettingsHash?: string;
   statusDetail?: string;
-  /** Redacted verified-human receipt carried by a continuation run. */
+  /** Redacted receipt for the latest accepted human decision in this run. */
   humanDecision?: HumanDecisionReceipt;
   /** True while the run is held at a step boundary by a pause request. */
   paused?: boolean;
@@ -878,6 +845,7 @@ export type AssistantMessageReceipt = {
 
 /** The step contract handed to the executor alongside the prompt. */
 export type AgentStepContract = {
+  requestId: string;
   runId: string;
   workflowName: string;
   nodeId: string;
@@ -931,8 +899,8 @@ export interface AgentStepExecutor {
    * leave the run claimable for an origin session. Omission is unsupported.
    */
   readonly assistantMessageMode?: "visible" | "park" | "unsupported";
-  /** True when the executor can park outside this process and resume the same attempt. */
-  readonly preservesDeadlineWhileParked?: boolean;
+  /** True when the host records active time while this executor parks and resumes an attempt. */
+  readonly preservesActiveTimeBudget?: boolean;
   runAgentStep(request: AgentStepRequest, signal: AbortSignal): Promise<AgentStepSubmission>;
 }
 
@@ -968,11 +936,6 @@ export type WorkflowEngineOptions = {
    * Awaited after `run_started` is persisted, before any node executes.
    */
   onRunStarted?: (runId: string, state: WorkflowRunState) => MaybePromise<void>;
-  /**
-   * Awaited before the terminal snapshot is persisted. This is where a
-   * session recorder stops and drains. Errors are swallowed: finishing the run wins.
-   */
-  onRunFinishing?: (runId: string, state: WorkflowRunState) => MaybePromise<void>;
   /** Default per-node timeout. Defaults to 15 minutes. */
   defaultNodeTimeoutMs?: number;
   /** Guard against unbounded graph loops. Defaults to 100 executed steps. */

package/src/workflows/workflow-message-content.ts

@@ -9,7 +9,7 @@ import type { AgentStepContract } from "./types.js";
 export const WORKFLOW_STEP_MESSAGE_TYPE = "pi-workflows-step";
 export const WORKFLOW_DECISION_MESSAGE_TYPE = "pi-workflows-interaction";
 export const WORKFLOW_NOTIFICATION_MESSAGE_TYPE = "pi-workflows-notification";
-export const WORKFLOW_TERMINAL_MESSAGE_TYPE = "pi-workflows-presentation";
+export const WORKFLOW_TERMINAL_MESSAGE_TYPE = "pi-workflows-terminal";
 export const WORKFLOW_FOLLOW_UP_MESSAGE_TYPE = "pi-workflows-follow-up";
 
 export function stepWorkflowMessageContent(options: {
@@ -20,6 +20,8 @@ export function stepWorkflowMessageContent(options: {
 }): WorkflowMessageContent {
   const outer = requireRecord(options.contract, "Stored workflow step contract");
   const agent = requireAgentContract(outer.contract);
+  if (agent.requestId !== options.requestId)
+    throw new Error("Workflow message request identity conflicts with its contract");
   const details: Record<string, JsonValue> = {
     schema: "pi-workflows.agent-step-message.v1",
     kind: "step",
@@ -61,6 +63,27 @@ export function decisionWorkflowMessageContent(options: {
   };
 }
 
+export function checkpointWorkflowMessageContent(options: {
+  workflowMessageId: string;
+  requestId: string;
+  runId: string;
+  contract: JsonValue;
+}): WorkflowMessageContent {
+  return {
+    schema: WORKFLOW_MESSAGE_CONTENT_SCHEMA,
+    customType: WORKFLOW_DECISION_MESSAGE_TYPE,
+    content: `${JSON.stringify(options.contract, null, 2)}\n\nAnswer checkpoint ${options.requestId} with the workflow answer action.`,
+    display: true,
+    details: {
+      workflowMessageId: options.workflowMessageId,
+      requestId: options.requestId,
+      runId: options.runId,
+      kind: "checkpoint",
+    },
+    triggerTurn: false,
+  };
+}
+
 export function notificationWorkflowMessageContent(options: {
   workflowMessageId: string;
   notificationId: string;
@@ -93,14 +116,14 @@ export function terminalWorkflowMessageContent(options: {
     schema: WORKFLOW_MESSAGE_CONTENT_SCHEMA,
     customType: WORKFLOW_TERMINAL_MESSAGE_TYPE,
     content: options.content,
-    display: false,
+    display: true,
     details: {
       workflowMessageId: options.workflowMessageId,
       runId: options.runId,
       kind: "terminal",
       terminal: options.details,
     },
-    triggerTurn: true,
+    triggerTurn: false,
   };
 }
 
@@ -128,6 +151,7 @@ export function followUpWorkflowMessageContent(options: {
 function requireAgentContract(value: unknown): AgentStepContract {
   if (
     !isRecord(value) ||
+    typeof value.requestId !== "string" ||
     typeof value.runId !== "string" ||
     typeof value.workflowName !== "string" ||
     typeof value.nodeId !== "string" ||
@@ -159,7 +183,7 @@ function decisionPrompt(contract: Record<string, unknown>): string {
     typeof presentation.summary === "string" ? presentation.summary : "",
     ...blocks,
     choices.length === 0 ? "" : `Choices:\n${choices.join("\n")}`,
-    "A human must answer this protected decision with `/workflow answer`.",
+    `A human must answer this protected decision with \`/workflow answer ${String(contract.decisionId)} <response>\`.`,
   ]
     .filter(Boolean)
     .join("\n\n");

package/dist/resource-managers/runtime.d.ts

@@ -1,59 +0,0 @@
-import type { ResourceManagerStore } from "./store.js";
-import type { AnyResourceManagerDefinition, ResourceManagerDefinition, ManagedResource, ManagedResourceRef } from "./types.js";
-import { ResourceManagerWorkflowCoordinator, type ResourceManagerWorkflowScheduler } from "./workflows.js";
-export type ResourceManagerRuntimeOptions = {
-    store: ResourceManagerStore;
-    resourceManagers: AnyResourceManagerDefinition[];
-    workflowScheduler?: ResourceManagerWorkflowScheduler;
-    maxConcurrent?: number;
-    resourceManagerConcurrency?: Record<string, number>;
-    defaultTimeoutMs?: number;
-    leaseMs?: number;
-    pollIntervalMs?: number;
-    baseBackoffMs?: number;
-    maxBackoffMs?: number;
-    jitterRatio?: number;
-    now?: () => Date;
-    random?: () => number;
-};
-export declare class ResourceManagerRuntime {
-    readonly store: ResourceManagerStore;
-    private readonly ownerId;
-    private readonly definitions;
-    private readonly workflowCoordinator;
-    private readonly maxConcurrent;
-    private readonly resourceManagerConcurrency;
-    private readonly defaultTimeoutMs;
-    private readonly leaseMs;
-    private readonly pollIntervalMs;
-    private readonly baseBackoffMs;
-    private readonly maxBackoffMs;
-    private readonly jitterRatio;
-    private readonly now;
-    private readonly random;
-    private readonly activeByResourceManager;
-    private readonly activeReconciles;
-    private runAbort;
-    private runnerTasks;
-    constructor(options: ResourceManagerRuntimeOptions);
-    putResource<TSpec, TStatus>(definition: ResourceManagerDefinition<TSpec, TStatus>, key: string, spec: TSpec): ManagedResource<TSpec, TStatus>;
-    putResourceByName(resourceManager: string, key: string, spec: unknown): ManagedResource;
-    requestDeletion(ref: ManagedResourceRef): ManagedResource;
-    enqueue(ref: ManagedResourceRef, afterMs?: number): void;
-    start(): void;
-    stop(): Promise<void>;
-    runOne(): Promise<boolean>;
-    runUntilIdle(maxReconciles?: number): Promise<number>;
-    get workflowRequests(): ResourceManagerWorkflowCoordinator;
-    private runnerLoop;
-    private claimNext;
-    private eligibleResourceManagers;
-    private processClaim;
-    private reconcileClaim;
-    private callReconciler;
-    private finishSuccessfulClaim;
-    private finishFailedClaim;
-    private backoffMs;
-    private readyQueueExists;
-    private recordEvent;
-}