intentdna 1.8.7 → 1.9.0-rc.2

package/dist/runtime/evaluator.js

@@ -0,0 +1,46 @@
+export const MAX_EVALUATOR_RESULT_BYTES = 65_536;
+export class EvaluatorResultError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EvaluatorResultError";
+    }
+}
+function evaluatorError(message) {
+    return new EvaluatorResultError(message);
+}
+export function parseEvaluatorResult(raw, options = {}) {
+    const maxBytes = options.max_bytes ?? MAX_EVALUATOR_RESULT_BYTES;
+    if (!Number.isSafeInteger(maxBytes)
+        || maxBytes < 1) {
+        throw evaluatorError("Evaluator result max_bytes must be a positive safe integer.");
+    }
+    if (Buffer.byteLength(raw, "utf8") > maxBytes) {
+        throw evaluatorError(`Evaluator output exceeds the ${maxBytes}-byte limit.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw evaluatorError("Evaluator output must be valid JSON with required boolean pass and optional numeric score.");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw evaluatorError("Evaluator output must be a JSON object.");
+    }
+    const result = parsed;
+    if (typeof result.pass !== "boolean") {
+        throw evaluatorError("Evaluator output must include boolean pass.");
+    }
+    if (result.score !== undefined
+        && (typeof result.score !== "number"
+            || !Number.isFinite(result.score))) {
+        throw evaluatorError("Evaluator output score must be finite numeric when provided.");
+    }
+    if (options.require_score === true && result.score === undefined) {
+        throw evaluatorError("Evaluator output numeric score is required.");
+    }
+    return {
+        pass: result.pass,
+        ...(result.score === undefined ? {} : { score: result.score }),
+    };
+}

package/dist/runtime/index.d.ts

@@ -4,8 +4,8 @@ export { compileRoleToAgentMD, compileAllRolesToAgentMD, writeAgentMDFiles, remo
 export type { AgentMDOptions, AgentMDResult } from "./agent-md.js";
 export { compileWorkflowToShell, writeWorkflowScript, removeWorkflowScripts, } from "./workflow-runner.js";
 export type { WorkflowShellOptions, WorkflowShellResult } from "./workflow-runner.js";
-export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
-export type { CompiledIRFile } from "./plugin-adapter.js";
+export { createCompiledIR, writeCompiledIR, loadCompiledIR, loadCompiledIRResult, removeCompiledIR, } from "./plugin-adapter.js";
+export type { CompiledIRFile, CompiledIRLoadResult } from "./plugin-adapter.js";
 export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";
 export { CODEX_ADAPTER_MINIMUM_VERSION, CODEX_NATIVE_HOOK_EVENTS, appendCodexRuntimeDecisionEvent, buildCodexDispatcherCommand, buildCodexHookTrustState, codexHookTrustedHash, codexInstallModeSemantics, codexTrustStateToml, compileCodexAdapterArtifacts, compileCodexHooksConfig, compileCodexInstructionArtifact, compileCodexPluginManifest, compileCodexPolicyMapArtifact, mapCodexDecisionEvent, mergeCodexFallbackHooks, mergeCodexTrustStateConfig, normalizeCodexHookInput, probeCodexRuntime, runCodexExecDogfood, removeCodexAdapterArtifacts, removeCodexFallbackHooks, removeCodexTrustStateConfig, runCodexHook, withCodexDogfoodEvidence, verifyCodexHookTrust, writeCodexAdapterArtifacts, } from "./codex-adapter.js";
 export type { CodexAdapterArtifacts, CodexAdapterEvidence, CodexAdapterSupportStatus, CodexCommandHook, CodexDecisionMappingInput, CodexDogfoodResult, CodexEvidenceClassification, CodexExecJsonEvent, CodexHookGroup, CodexHookInput, CodexHookInstallMode, CodexHookRunnerOptions, CodexHookRunnerResult, CodexHookTrustState, CodexHooksConfig, CodexInstallModeSemantics, CodexInstructionArtifact, CodexNativeHookEvent, CodexPluginManifest, CodexPolicyMap, CodexPolicyMapArtifact, CodexPolicyMapEntry, CodexRuntimeProbe, CodexTrustVerification, RunCodexDogfoodOptions, CodexTrustVerificationInput, CompileCodexAdapterOptions, } from "./codex-adapter.js";
@@ -34,8 +34,12 @@ export type { ProcessTerminationReason, ProcessTreeRunOptions, ProcessTreeRunRes
 export { executeWorkerAttempt } from "./worker-executor.js";
 export type { WorkerExecutorOptions, WorkerExecutionWithEvents, } from "./worker-executor.js";
 export { RunControllerError, RunController, } from "./run-controller.js";
-export type { ControllerReferenceHandoff, ControllerQuoteHandoff, ControllerStructuredHandoff, ControllerNoHandoff, ControllerHandoffDeclaration, MaterializeStepPacketInput, ControllerStepDefinition, ReconciledAttemptState, AttemptReconciler, RunControllerOptions, CreateControllerRunInput, ClaimedStep, RunControllerErrorCode, } from "./run-controller.js";
-export { WorkflowPlanAdapterError, adaptWorkflowPlan, } from "./workflow-plan-adapter.js";
+export type { ControllerReferenceHandoff, ControllerQuoteHandoff, ControllerStructuredHandoff, ControllerNoHandoff, ControllerHandoffDeclaration, MaterializeStepPacketInput, ControllerStepDefinition, WorkflowRetryLoopPolicy, ReconciledAttemptState, AttemptReconciler, RunControllerOptions, CreateControllerRunInput, ClaimedStep, RunControllerErrorCode, } from "./run-controller.js";
+export { WorkflowPlanAdapterError, adaptWorkflowPlan, adaptWorkflowRetryLoop, } from "./workflow-plan-adapter.js";
 export type { WorkflowPlanAdapterErrorCode, WorkflowPlanAdapterOptions, } from "./workflow-plan-adapter.js";
 export { WorkspaceIsolationError, planAttemptWorkspace, allocateAttemptWorkspace, inspectAttemptWorkspace, applyWorkspaceLifecycleDecision, defaultWorktreeRoot, describeWorkspace, } from "./workspace-isolation.js";
 export type { WorkspaceIsolation, WorkspaceIsolationErrorCode, AttemptWorkspaceRequest, SharedWorkspacePlan, IsolatedWorkspacePlan, AttemptWorkspacePlan, SharedWorkspaceAllocation, IsolatedWorkspaceAllocation, AttemptWorkspaceAllocation, WorkspaceInspection, WorkspacePreservationReason, WorkspaceLifecycleDecision, WorkspaceLifecycleResult, } from "./workspace-isolation.js";
+export { MAX_EVALUATOR_RESULT_BYTES, EvaluatorResultError, parseEvaluatorResult, } from "./evaluator.js";
+export type { EvaluatorResult, ParseEvaluatorResultOptions, } from "./evaluator.js";
+export { runCompletionVerifier, runCheckpointVerifier, } from "./verifier.js";
+export type { VerifierRuntimeContext, VerifierCheckResult, } from "./verifier.js";

package/dist/runtime/index.js

@@ -1,7 +1,7 @@
 export { compileForClaude } from "./claude-sdk.js";
 export { compileRoleToAgentMD, compileAllRolesToAgentMD, writeAgentMDFiles, removeAgentMDFiles, toKebabCase, } from "./agent-md.js";
 export { compileWorkflowToShell, writeWorkflowScript, removeWorkflowScripts, } from "./workflow-runner.js";
-export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
+export { createCompiledIR, writeCompiledIR, loadCompiledIR, loadCompiledIRResult, removeCompiledIR, } from "./plugin-adapter.js";
 export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";
 export { CODEX_ADAPTER_MINIMUM_VERSION, CODEX_NATIVE_HOOK_EVENTS, appendCodexRuntimeDecisionEvent, buildCodexDispatcherCommand, buildCodexHookTrustState, codexHookTrustedHash, codexInstallModeSemantics, codexTrustStateToml, compileCodexAdapterArtifacts, compileCodexHooksConfig, compileCodexInstructionArtifact, compileCodexPluginManifest, compileCodexPolicyMapArtifact, mapCodexDecisionEvent, mergeCodexFallbackHooks, mergeCodexTrustStateConfig, normalizeCodexHookInput, probeCodexRuntime, runCodexExecDogfood, removeCodexAdapterArtifacts, removeCodexFallbackHooks, removeCodexTrustStateConfig, runCodexHook, withCodexDogfoodEvidence, verifyCodexHookTrust, writeCodexAdapterArtifacts, } from "./codex-adapter.js";
 export { codexSyncDispatcherCommand, createCodexSyncTargetPlan, executeCodexSyncTargetPlan, formatCodexSyncTargetPlanSummary, removeCodexSyncTargetArtifacts, } from "./codex-sync-target.js";
@@ -18,5 +18,7 @@ export { createCodexExecutionProvider } from "./providers/codex.js";
 export { runProcessTree, runProcessTreeWithTimeout, } from "./process-tree.js";
 export { executeWorkerAttempt } from "./worker-executor.js";
 export { RunControllerError, RunController, } from "./run-controller.js";
-export { WorkflowPlanAdapterError, adaptWorkflowPlan, } from "./workflow-plan-adapter.js";
+export { WorkflowPlanAdapterError, adaptWorkflowPlan, adaptWorkflowRetryLoop, } from "./workflow-plan-adapter.js";
 export { WorkspaceIsolationError, planAttemptWorkspace, allocateAttemptWorkspace, inspectAttemptWorkspace, applyWorkspaceLifecycleDecision, defaultWorktreeRoot, describeWorkspace, } from "./workspace-isolation.js";
+export { MAX_EVALUATOR_RESULT_BYTES, EvaluatorResultError, parseEvaluatorResult, } from "./evaluator.js";
+export { runCompletionVerifier, runCheckpointVerifier, } from "./verifier.js";

package/dist/runtime/plugin-adapter.d.ts

@@ -7,6 +7,7 @@
  * This is the bridge between compile-time (dna sync) and runtime (hook execution).
  */
 import type { CompiledProvenanceManifest, ConstraintIR, RoleDef } from "../schema/types.js";
+import type { WorkflowRuntimeManifest } from "./workflow-runtime-manifest.js";
 /** Wrapper around ConstraintIR with versioning metadata */
 export interface CompiledIRFile {
     /** Schema version for forward compatibility */
@@ -23,11 +24,22 @@ export interface CompiledIRFile {
     compiled_ir_hash?: string;
     /** Cascade and source provenance used by enterprise evidence */
     provenance?: CompiledProvenanceManifest;
+    /** Deterministic workflow runtime bindings used to initialize workflow state. */
+    workflow_runtime?: WorkflowRuntimeManifest;
 }
+export type CompiledIRLoadResult = {
+    status: "loaded";
+    compiled: CompiledIRFile;
+} | {
+    status: "missing";
+} | {
+    status: "invalid";
+    reason: string;
+};
 /**
  * Create a CompiledIRFile wrapper around a ConstraintIR.
  */
-export declare function createCompiledIR(ir: ConstraintIR, roles?: Record<string, RoleDef>): CompiledIRFile;
+export declare function createCompiledIR(ir: ConstraintIR, roles?: Record<string, RoleDef>, workflowRuntime?: WorkflowRuntimeManifest): CompiledIRFile;
 /**
  * Write compiled IR to .dna/compiled/ir.json.
  * Creates the directory if needed.
@@ -39,6 +51,7 @@ export declare function writeCompiledIR(projectDir: string, compiled: CompiledIR
  * Returns null if not found or invalid.
  */
 export declare function loadCompiledIR(irPath: string): Promise<CompiledIRFile | null>;
+export declare function loadCompiledIRResult(irPath: string): Promise<CompiledIRLoadResult>;
 /**
  * Remove compiled IR file.
  * Returns true if removed, false if not found.

package/dist/runtime/plugin-adapter.js

@@ -13,7 +13,7 @@ import { atomicWrite } from "../hooks/state.js";
 /**
  * Create a CompiledIRFile wrapper around a ConstraintIR.
  */
-export function createCompiledIR(ir, roles) {
+export function createCompiledIR(ir, roles, workflowRuntime) {
     return {
         ir_version: 1,
         compiled_at: ir.compiled_at,
@@ -22,6 +22,7 @@ export function createCompiledIR(ir, roles) {
         roles: roles && Object.keys(roles).length > 0 ? roles : undefined,
         compiled_ir_hash: ir.compiled_ir_hash,
         provenance: ir.provenance,
+        ...(workflowRuntime ? { workflow_runtime: workflowRuntime } : {}),
     };
 }
 /**
@@ -41,26 +42,39 @@ export async function writeCompiledIR(projectDir, compiled) {
  * Returns null if not found or invalid.
  */
 export async function loadCompiledIR(irPath) {
+    const result = await loadCompiledIRResult(irPath);
+    return result.status === "loaded" ? result.compiled : null;
+}
+export async function loadCompiledIRResult(irPath) {
     try {
         const raw = await readFile(irPath, "utf-8");
         const data = JSON.parse(raw);
         // Validate wrapper format
         if (data.ir_version === 1 && data.ir && data.compiled_at) {
-            return data;
+            return { status: "loaded", compiled: data };
         }
         // Maybe it's a raw ConstraintIR (backward compat)
         if (data.compiled_at && data.source_dna_ids) {
             return {
-                ir_version: 1,
-                compiled_at: data.compiled_at,
-                source_dna_ids: data.source_dna_ids,
-                ir: data,
+                status: "loaded",
+                compiled: {
+                    ir_version: 1,
+                    compiled_at: data.compiled_at,
+                    source_dna_ids: data.source_dna_ids,
+                    ir: data,
+                },
             };
         }
-        return null;
+        return { status: "invalid", reason: "compiled IR has an unsupported shape" };
     }
-    catch {
-        return null;
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+        if (code === "ENOENT")
+            return { status: "missing" };
+        return {
+            status: "invalid",
+            reason: error instanceof Error ? error.message : "compiled IR cannot be read",
+        };
     }
 }
 /**

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

@@ -31,7 +31,7 @@ export interface AttemptIdentity extends TaskKey {
     readonly attempt_id: AttemptId;
     readonly worker_session_id: WorkerSessionId;
 }
-export declare const TASK_STATE_VALUES: readonly ["dependency_blocked", "ready", "claimed", "running", "succeeded", "failed", "skipped", "cancelled"];
+export declare const TASK_STATE_VALUES: readonly ["dependency_blocked", "ready", "claimed", "running", "round_succeeded", "succeeded", "failed", "skipped", "cancelled"];
 export type TaskState = typeof TASK_STATE_VALUES[number];
 export type TerminalTaskState = Extract<TaskState, "succeeded" | "failed" | "skipped" | "cancelled">;
 /**
@@ -42,7 +42,8 @@ export declare const TASK_STATE_TRANSITIONS: {
     readonly dependency_blocked: readonly ["ready", "skipped", "cancelled"];
     readonly ready: readonly ["claimed", "skipped", "cancelled"];
     readonly claimed: readonly ["ready", "running", "cancelled"];
-    readonly running: readonly ["ready", "succeeded", "failed", "cancelled"];
+    readonly running: readonly ["ready", "round_succeeded", "succeeded", "failed", "cancelled"];
+    readonly round_succeeded: readonly ["dependency_blocked", "ready", "succeeded", "skipped", "cancelled"];
     readonly succeeded: readonly [];
     readonly failed: readonly [];
     readonly skipped: readonly [];
@@ -170,6 +171,7 @@ export type StepOutput = {
 export interface StepPacket extends AttemptIdentity {
     readonly packet_version: 1;
     readonly attempt_number: number;
+    readonly workflow_round: number;
     readonly role: string;
     readonly constraints: readonly string[];
     readonly standalone_prompt: string;
@@ -272,7 +274,7 @@ export interface CommittedStepResult extends ProviderExecutionResult {
     readonly commit_status: "committed";
     readonly committed_at: string;
 }
-export declare const RUNTIME_EVENT_TYPE_VALUES: readonly ["run_created", "run_cancel_requested", "run_terminal", "task_state_changed", "task_claimed", "task_lease_renewed", "task_claim_released", "attempt_started", "attempt_terminal", "handoff_resolved", "result_committed"];
+export declare const RUNTIME_EVENT_TYPE_VALUES: readonly ["run_created", "run_cancel_requested", "run_terminal", "task_state_changed", "task_claimed", "task_lease_renewed", "task_claim_released", "attempt_started", "attempt_terminal", "handoff_resolved", "result_committed", "workflow_round_advanced", "workflow_round_completed"];
 export type RuntimeEventType = typeof RUNTIME_EVENT_TYPE_VALUES[number];
 export interface RuntimeEvent {
     readonly event_id: EventId;

package/dist/runtime/run-contracts.js

@@ -10,6 +10,7 @@ export const TASK_STATE_VALUES = [
     "ready",
     "claimed",
     "running",
+    "round_succeeded",
     "succeeded",
     "failed",
     "skipped",
@@ -23,7 +24,14 @@ export const TASK_STATE_TRANSITIONS = {
     dependency_blocked: ["ready", "skipped", "cancelled"],
     ready: ["claimed", "skipped", "cancelled"],
     claimed: ["ready", "running", "cancelled"],
-    running: ["ready", "succeeded", "failed", "cancelled"],
+    running: ["ready", "round_succeeded", "succeeded", "failed", "cancelled"],
+    round_succeeded: [
+        "dependency_blocked",
+        "ready",
+        "succeeded",
+        "skipped",
+        "cancelled",
+    ],
     succeeded: [],
     failed: [],
     skipped: [],
@@ -55,4 +63,6 @@ export const RUNTIME_EVENT_TYPE_VALUES = [
     "attempt_terminal",
     "handoff_resolved",
     "result_committed",
+    "workflow_round_advanced",
+    "workflow_round_completed",
 ];

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

@@ -1,4 +1,4 @@
-import type { AttemptId, AttemptIdentity, AttemptRecord, ClaimToken, EventId, HandoffBinding, ResultId, RetryPolicy, RunId, StepId, StepPacket, TaskClaim, WorkerSessionId } from "./run-contracts.js";
+import type { AttemptId, AttemptIdentity, AttemptRecord, ClaimToken, EventId, HandoffBinding, ResultId, RetryBackoff, RetryPolicy, RunId, StepId, StepPacket, TaskClaim, WorkerSessionId } from "./run-contracts.js";
 import type { ExecutionProvider } from "./execution-provider.js";
 import { HandoffResolver, type QuoteHandoffRequest } from "./handoff-resolver.js";
 import { DurableRunStore, type RunRecord, type RunStoreSnapshot } from "./run-store.js";
@@ -35,6 +35,7 @@ export interface ControllerNoHandoff extends ControllerHandoffBase {
 export type ControllerHandoffDeclaration = ControllerReferenceHandoff | ControllerQuoteHandoff | ControllerStructuredHandoff | ControllerNoHandoff;
 export interface MaterializeStepPacketInput extends AttemptIdentity {
     readonly attempt_number: number;
+    readonly workflow_round: number;
     readonly input_bindings: readonly HandoffBinding[];
     readonly retry_policy: RetryPolicy;
     readonly created_at: string;
@@ -52,12 +53,22 @@ export interface ControllerStepDefinition {
     readonly handoffs: readonly ControllerHandoffDeclaration[];
     materialize_packet(input: MaterializeStepPacketInput): StepPacket;
 }
+export interface WorkflowRetryLoopPolicy {
+    readonly retry_from: StepId;
+    readonly step_ids: readonly StepId[];
+    readonly completion_step: StepId;
+    readonly max_retries: number;
+    readonly backoff: RetryBackoff;
+    readonly initial_delay_ms: number;
+    readonly max_delay_ms: number | null;
+}
 export type ReconciledAttemptState = "live" | "dead" | "unknown";
 export type AttemptReconciler = (attempt: AttemptRecord, claim: TaskClaim) => Promise<ReconciledAttemptState>;
 export interface RunControllerOptions {
     readonly run_store: DurableRunStore;
     readonly handoff_resolver?: HandoffResolver;
     readonly steps: readonly ControllerStepDefinition[];
+    readonly workflow_retry_loop?: WorkflowRetryLoopPolicy | null;
     readonly provider_for_step: (definition: ControllerStepDefinition) => ExecutionProvider;
     readonly max_concurrency: number;
     readonly lease_duration_ms: number;
@@ -93,6 +104,8 @@ export declare class RunController {
     private readonly resolver;
     private readonly definitions;
     private readonly definitionByStep;
+    private readonly workflowRetryLoop;
+    private readonly workflowRetrySteps;
     private readonly providerForStep;
     private readonly maxConcurrency;
     private readonly leaseDurationMs;
@@ -111,6 +124,7 @@ export declare class RunController {
     private readonly active;
     constructor(options: RunControllerOptions);
     private validateDefinitions;
+    private validateWorkflowRetryLoop;
     private events;
     createRun(input: CreateControllerRunInput): Promise<RunStoreSnapshot>;
     inspect(runId: RunId): Promise<RunStoreSnapshot>;