intentdna 1.9.0 → 1.9.3

package/dist/runtime/run-controller.d.ts

@@ -16,6 +16,7 @@ interface ControllerHandoffBase {
 export interface ControllerReferenceHandoff extends ControllerHandoffBase {
     readonly mode: "reference";
     readonly source: SourceWithoutResultId;
+    readonly artifact_kind: "file" | "directory" | "git_commit";
 }
 export interface ControllerQuoteHandoff extends ControllerHandoffBase {
     readonly mode: "quote";
@@ -153,11 +154,5 @@ export declare class RunController {
     requestCancellation(runId: RunId, reason?: string | null): Promise<RunStoreSnapshot>;
     private finalizeRunIfTerminal;
     private launchClaimed;
-    /**
-     * Runs scheduling until durable terminal state. Every successful claim creates
-     * a fresh attempt and worker session; this Controller never gives a worker a
-     * second Step.
-     */
-    runUntilTerminal(runId: RunId): Promise<RunStoreSnapshot>;
 }
 export {};

package/dist/runtime/run-controller.js

@@ -1205,45 +1205,4 @@ export class RunController {
         });
         return completion;
     }
-    /**
-     * Runs scheduling until durable terminal state. Every successful claim creates
-     * a fresh attempt and worker session; this Controller never gives a worker a
-     * second Step.
-     */
-    async runUntilTerminal(runId) {
-        while (true) {
-            let snapshot = await this.resume(runId);
-            snapshot = await this.refreshDependencyReadiness(runId);
-            snapshot = await this.finalizeRunIfTerminal(runId);
-            if (snapshot.run.terminal !== null)
-                return snapshot;
-            let launched = false;
-            while (this.active.size < this.maxConcurrency) {
-                const claimed = await this.claimNextReady(runId);
-                if (!claimed)
-                    break;
-                launched = true;
-                void this.launchClaimed(claimed);
-            }
-            if (this.active.size > 0) {
-                await Promise.race([...this.active.values()].map((entry) => entry.completion));
-                continue;
-            }
-            snapshot = await this.store.requireRun(runId);
-            const externallyActive = snapshot.tasks.some((task) => task.state === "claimed" || task.state === "running");
-            const retryPending = snapshot.tasks.some((task) => {
-                if (task.state !== "ready")
-                    return false;
-                const definition = this.definitionByStep.get(task.step_id);
-                return definition
-                    ? this.readyAt(definition, task, snapshot) > this.now().getTime()
-                    : false;
-            });
-            if (externallyActive || retryPending || launched) {
-                await sleep(this.schedulerPollMs);
-                continue;
-            }
-            throw new RunControllerError("scheduler_stalled", `run ${runId} has no runnable or active Step`);
-        }
-    }
 }

package/dist/runtime/run-store.d.ts

@@ -1,5 +1,9 @@
-import type { AttemptRecord, CommittedStepResult, JsonValue, RunId, RuntimeEvent, TaskClaim, TaskRecord } from "./run-contracts.js";
+import type { CanonicalActivationRecord, CanonicalAttemptClaim, CanonicalAttemptRecord, CanonicalResultRef, CanonicalRuntimeEvent, AttemptRecord, CommittedStepResult, JsonValue, RunId, RuntimeEvent, TaskClaim, TaskRecord } from "./run-contracts.js";
+import type { Sha256Digest } from "./executable-run-plan.js";
+import { type StoredRunBinding } from "./run-binding.js";
+export declare const LEGACY_RUN_STORE_SCHEMA_VERSION: 1;
 export declare const RUN_STORE_SCHEMA_VERSION: 1;
+export declare const CANONICAL_RUN_STORE_SCHEMA_VERSION: 2;
 export declare const RUN_STATUS_VALUES: readonly ["active", "cancelling", "succeeded", "failed", "cancelled"];
 export type RunStatus = typeof RUN_STATUS_VALUES[number];
 export type TerminalRunStatus = Extract<RunStatus, "succeeded" | "failed" | "cancelled">;
@@ -12,6 +16,9 @@ export interface RunTerminalRecord {
     readonly reason: string | null;
     readonly completed_at: string;
 }
+export interface CanonicalRunTerminalRecord extends RunTerminalRecord {
+    readonly reason_code: string;
+}
 export interface RunRecord {
     readonly run_id: RunId;
     readonly workflow_id: string;
@@ -30,7 +37,7 @@ export interface RunRecord {
  */
 export type StoredTaskClaim = TaskClaim;
 export interface RunStoreSnapshot {
-    readonly schema_version: typeof RUN_STORE_SCHEMA_VERSION;
+    readonly schema_version: typeof LEGACY_RUN_STORE_SCHEMA_VERSION;
     readonly record_version: number;
     readonly run: RunRecord;
     readonly tasks: readonly TaskRecord[];
@@ -41,10 +48,44 @@ export interface RunStoreSnapshot {
     readonly created_at: string;
     readonly updated_at: string;
 }
+export interface CanonicalRunTarget {
+    readonly kind: "workflow" | "controller";
+    readonly key: string;
+}
+export interface CanonicalRunRecord {
+    readonly run_id: RunId;
+    readonly target: CanonicalRunTarget;
+    readonly plan_id: Sha256Digest;
+    readonly plan_digest: Sha256Digest;
+    readonly run_binding: StoredRunBinding;
+    readonly status: RunStatus;
+    readonly cancellation: RunCancellationIntent | null;
+    readonly terminal: CanonicalRunTerminalRecord | null;
+    readonly metadata: JsonValue;
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+export interface CanonicalRunStoreSnapshot {
+    readonly schema_version: typeof CANONICAL_RUN_STORE_SCHEMA_VERSION;
+    readonly record_version: number;
+    readonly run: CanonicalRunRecord;
+    readonly activations: readonly CanonicalActivationRecord[];
+    readonly attempts: readonly CanonicalAttemptRecord[];
+    readonly claims: readonly CanonicalAttemptClaim[];
+    readonly events: readonly CanonicalRuntimeEvent[];
+    readonly result_refs: readonly CanonicalResultRef[];
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+export type AnyRunStoreSnapshot = RunStoreSnapshot | CanonicalRunStoreSnapshot;
 export interface CreateRunStoreRecord {
     readonly run: RunRecord;
     readonly tasks?: readonly TaskRecord[];
 }
+export interface CreateCanonicalRunStoreRecord {
+    readonly run: CanonicalRunRecord;
+    readonly activations?: readonly CanonicalActivationRecord[];
+}
 /**
  * Collections are upserted by their durable identity. Events and results are
  * append-only: an exact/idempotent replay is ignored and a conflict is rejected.
@@ -65,6 +106,22 @@ export interface RunStoreUpdateResult {
     readonly duplicate_event_ids: readonly string[];
     readonly duplicate_result_ids: readonly string[];
 }
+export interface CanonicalRunStoreUpdate {
+    readonly run_id: RunId;
+    readonly expected_record_version: number;
+    readonly run?: CanonicalRunRecord;
+    readonly activations?: readonly CanonicalActivationRecord[];
+    readonly attempts?: readonly CanonicalAttemptRecord[];
+    readonly claims?: readonly CanonicalAttemptClaim[];
+    readonly events?: readonly CanonicalRuntimeEvent[];
+    readonly result_refs?: readonly CanonicalResultRef[];
+}
+export interface CanonicalRunStoreUpdateResult {
+    readonly snapshot: CanonicalRunStoreSnapshot;
+    readonly applied: boolean;
+    readonly duplicate_event_ids: readonly string[];
+    readonly duplicate_result_ids: readonly string[];
+}
 export interface DurableRunStoreOptions {
     readonly root_directory: string;
     readonly lock_wait_ms?: number;
@@ -72,25 +129,46 @@ export interface DurableRunStoreOptions {
     readonly lock_retry_ms?: number;
     readonly lock_heartbeat_ms?: number;
 }
-export type RunStoreErrorCode = "invalid_options" | "invalid_record" | "unsupported_schema" | "run_exists" | "run_not_found" | "version_conflict" | "immutable_record" | "identity_conflict" | "event_conflict" | "result_conflict" | "lock_timeout" | "lock_lost";
+export type RunStoreErrorCode = "invalid_options" | "invalid_record" | "unsupported_schema" | "unsupported_legacy_run" | "run_exists" | "run_not_found" | "version_conflict" | "immutable_record" | "identity_conflict" | "event_conflict" | "result_conflict" | "lock_timeout" | "lock_lost";
 export declare class RunStoreError extends Error {
     readonly code: RunStoreErrorCode;
-    constructor(code: RunStoreErrorCode, message: string);
+    constructor(code: RunStoreErrorCode, message: string, options?: ErrorOptions);
 }
 export declare class DurableRunStore {
     private readonly options;
     constructor(options: DurableRunStoreOptions);
+    serviceOwnedRuntimeDirectory(component: "handoffs" | "workspace-locks"): string;
     private runDirectory;
     private ledgerPath;
-    private lockDirectory;
+    private versionsDirectory;
+    private versionPath;
+    private readLedgerSnapshot;
+    private readCommittedHeadFromDirectory;
+    private readCommittedHead;
+    private readProjectionForRepair;
+    private projectCommittedHead;
+    protected beforeLedgerCommit(_snapshot: AnyRunStoreSnapshot): Promise<void>;
+    protected afterLedgerCommit(_snapshot: AnyRunStoreSnapshot): Promise<void>;
+    private commitSnapshot;
+    private readAnySnapshot;
     private readSnapshot;
     createRun(input: CreateRunStoreRecord): Promise<RunStoreSnapshot>;
+    createCanonicalRun(input: CreateCanonicalRunStoreRecord): Promise<CanonicalRunStoreSnapshot>;
     loadRun(runId: RunId): Promise<RunStoreSnapshot | null>;
     requireRun(runId: RunId): Promise<RunStoreSnapshot>;
+    cancelLegacyRun(runId: RunId, reason?: string | null): Promise<RunStoreSnapshot>;
+    closeLegacyRun(runId: RunId, reason?: string | null): Promise<RunStoreSnapshot>;
+    loadAnyRun(runId: RunId): Promise<AnyRunStoreSnapshot | null>;
+    requireAnyRun(runId: RunId): Promise<AnyRunStoreSnapshot>;
+    loadCanonicalRun(runId: RunId): Promise<CanonicalRunStoreSnapshot | null>;
+    requireCanonicalRun(runId: RunId): Promise<CanonicalRunStoreSnapshot>;
     updateRun(update: RunStoreUpdate): Promise<RunStoreUpdateResult>;
+    updateCanonicalRun(update: CanonicalRunStoreUpdate): Promise<CanonicalRunStoreUpdateResult>;
+    loadAllAnyRuns(): Promise<readonly AnyRunStoreSnapshot[]>;
     /**
-     * Reads every valid run ledger after restart. No worker-session directory is
-     * consulted, and this store intentionally exposes no worker cleanup operation.
+     * Reads every valid legacy ledger after restart while allowing canonical
+     * ledgers to coexist in the same durable root.
      */
     loadAllRuns(): Promise<readonly RunStoreSnapshot[]>;
+    loadAllCanonicalRuns(): Promise<readonly CanonicalRunStoreSnapshot[]>;
 }