@agwab/pi-workflow 0.1.2 → 0.2.1

package/README.md

@@ -64,6 +64,8 @@ If you want deterministic manual control, use the slash command form:
 /workflow run deep-research "Research this repository and summarize the architecture tradeoffs."
 ```
 
+For opt-in lower-latency runs, add `--thinking low`; defaults remain conservative pending holdout evidence. See [`docs/usage.md`](./docs/usage.md).
+
 For a one-off adaptive workflow that should plan, fan out, and synthesize without choosing a saved workflow, use:
 
 ```text
@@ -167,22 +169,16 @@ Workflow definitions compose a small set of stage patterns and graph shapes.
 
 ![Core workflow stage shapes: single, foreach, reduce, loop, dag, and dynamic](./docs/assets/readme/stage-types.png)
 
-Parallel execution is a graph shape, not a stage type: model parallel branches as multiple roots or with `after: []`. Support helpers are declared with a `support` object, not a stage `type`.
-
-Dynamic workflows are the advanced form of adaptive orchestration. A JSON `type: "dynamic"` stage points at trusted bundle-local `.mjs` controller code; that controller can add official workflow tasks, call helpers, or run nested workflows while preserving replayable run state. See [`docs/usage.md`](./docs/usage.md) for approval, detach, helper retry, nested workflow, and cache details.
-
-New workflows should prefer `workflow_web_search`, `workflow_web_fetch_source`, and `workflow_web_source_read`: search returns compact candidates, fetch returns a source card with an opaque `sourceRef`, and source-read retrieves narrow evidence snippets. Preserve `sourceRef` through workflow outputs; use `urls: [...]` or `sources: [...]` to batch several source fetches, use `queries: [...]` or `reads: [...]` to batch several snippets from one sourceRef, and use `claim` + distinctive `terms` to get candidate quote windows with match metadata when the exact quote is unknown. Normalized web sources are cached under `.pi/workflows/<run-id>/web-source-cache/` without exposing cache paths to agents; same-URL fetches and deterministic terminal failures are coordinated across parallel workers. Legacy `fetch_content` calls still use `.pi/workflows/<run-id>/source-cache/fetch-content/`; set `PI_WORKFLOW_FETCH_CONTENT_CACHE=0` to opt out of that legacy cache.
-
 ## Predefined workflows
 
-The package includes a small starter set. These are practical defaults and authoring examples, not a complete workflow catalog.
+The package includes four bundled workflows for common research and review jobs. They are runnable defaults and authoring examples, not a complete workflow catalog.
 
-| Workflow | Use when |
-|---|---|
-| `deep-research` | Grounded answers or summaries based on source material. |
-| `deep-review` | Careful code or design review from multiple angles. |
-| `spec-review` | Checks that requirements, API specs, or contracts are reflected in implementation and tests. |
-| `impact-review` | Pre-merge or pre-release risk review across affected areas, tests, and docs. |
+| Workflow | Best for | What it does |
+|---|---|---|
+| `deep-research` | Deep, source-grounded research when breadth, verification, and cited recommendations matter. | Plans research questions by depth, fans out question-level research, normalizes and ranks claims, verifies selected claims against evidence, and renders an audited executive handoff. |
+| `deep-review` | Code or design review when one reviewer pass is not enough. | Triage selects review lenses, reviewers produce findings, a deterministic helper deduplicates them, a challenge pass tests the surviving findings, a deterministic helper partitions verdicts, and the final report keeps only evidence-backed issues. |
+| `spec-review` | Requirements-to-implementation traceability for an existing spec, API contract, or acceptance criteria. | Extracts testable requirements, maps implementation and tests, verifies candidate gaps, and reports which requirements are covered, missing, ambiguous, or need human judgment. |
+| `impact-review` | Side-effect and risk review for proposed or applied changes. | Maps change scope and affected surfaces, analyzes contract, state/data, validation, docs, security, and performance impact, then joins those lenses into likely regressions, missing checks, and next actions. |
 
 ![Deep research workflow flow](./docs/assets/readme/deep-research-flow.png)
 

package/dist/compiler.d.ts

@@ -1,13 +1,13 @@
-import { type ArtifactGraphWorkflowSpec, type ThinkingLevel } from "./types.js";
+import { type ArtifactGraphWorkflowSpec } from "./types.js";
+import { type WorkflowModelInfo, type WorkflowRuntimeDefaults } from "./workflow-runtime.js";
 interface CompileOptions {
     cwd: string;
     specPath?: string;
+    availableModels?: WorkflowModelInfo[];
 }
 export declare function compileWorkflow(spec: ArtifactGraphWorkflowSpec, options: CompileOptions & {
     task?: string;
-    runtimeDefaults?: {
-        model?: string;
-        thinking?: ThinkingLevel;
-    };
+    runtimeOverrides?: WorkflowRuntimeDefaults;
+    runtimeDefaults?: WorkflowRuntimeDefaults;
 }): Promise<any>;
 export {};

package/dist/compiler.js

@@ -4,6 +4,7 @@ import { loadAgentByName } from "./agents.js";
 import { DYNAMIC_OUTPUT_PROFILES } from "./dynamic-profiles.js";
 import { classifyToolCapability, effectiveToolClassification, providersForSelectedTools, resolveToolSelection, TOOL_NAME_PATTERN, toolAllowedByAuthorityCeiling, toolNameForSpec, } from "./tool-metadata.js";
 import { WorkflowValidationError, WORKFLOW_RUN_TYPE, } from "./types.js";
+import { resolveWorkflowRuntime, selectWorkflowRuntime, } from "./workflow-runtime.js";
 const DELEGATION_TOOLS = new Set([
     "skill_test_subagent",
     "workflow",
@@ -412,6 +413,17 @@ async function collectForeachPathWarnings(stages, specDir) {
     }
     return warnings;
 }
+function runtimeSettings(value) {
+    if (!isPlainRecord(value))
+        return undefined;
+    const model = typeof value.model === "string" && value.model.trim()
+        ? value.model.trim()
+        : undefined;
+    const thinking = typeof value.thinking === "string" && value.thinking.trim()
+        ? value.thinking.trim()
+        : undefined;
+    return model || thinking ? { model, thinking } : undefined;
+}
 async function compileArtifactGraphPlan(spec, options) {
     const stages = spec.stages;
     if (!Array.isArray(stages)) {
@@ -449,8 +461,9 @@ async function compileArtifactGraphPlan(spec, options) {
         Object.keys(workflowInput).length > 0
         ? `# Workflow Input\n\n${JSON.stringify(workflowInput, null, 2)}`
         : "";
-    const defaultModel = options.runtimeDefaults?.model ?? spec.defaults?.model;
-    const defaultThinking = options.runtimeDefaults?.thinking ?? spec.defaults?.thinking;
+    const runtimeOverrides = options.runtimeOverrides;
+    const runtimeDefaults = options.runtimeDefaults;
+    const specRuntimeDefaults = runtimeSettings(spec.defaults);
     const tasks = [];
     const stageRecords = [];
     const issues = [];
@@ -474,7 +487,26 @@ async function compileArtifactGraphPlan(spec, options) {
                     : `$.artifactGraph.stages.${jsonKey(stage.id)}.dynamic`;
             validateDelegationBoundary(rawDynamicToolSelection.tools, issues, dynamicToolPath);
             const dynamicToolSelection = filterToolSelection(rawDynamicToolSelection);
-            const dynamicTask = buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, options.cwd, specDir, workflowInputText, options.task, defaultModel, defaultThinking, overrides);
+            const requestedRuntime = selectWorkflowRuntime(runtimeOverrides, runtimeSettings(stage), runtimeDefaults, specRuntimeDefaults);
+            const resolvedDynamicRuntime = await resolveWorkflowRuntime(requestedRuntime, {
+                taskKey: key,
+                stageId: stage.id,
+                taskId,
+                agent: "dynamic",
+            }, { availableModels: options.availableModels });
+            const dynamicTask = buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, options.cwd, specDir, workflowInputText, options.task, resolvedDynamicRuntime, {
+                runtimeOverrides,
+                runtimeDefaults,
+                specRuntimeDefaults,
+                stageRuntime: runtimeSettings(stage),
+            }, overrides);
+            dynamicTask.runtime = {
+                ...dynamicTask.runtime,
+                ...resolvedDynamicRuntime,
+            };
+            if (options.availableModels?.length) {
+                dynamicTask.dynamic.availableModels = options.availableModels;
+            }
             if (dynamicToolSelection.tools || dynamicToolSelection.toolProviders) {
                 dynamicTask.runtime = {
                     ...dynamicTask.runtime,
@@ -528,10 +560,18 @@ async function compileArtifactGraphPlan(spec, options) {
         validateToolSubset(toolSelection.tools, stageAgent, issues, toolPath);
         validateDelegationBoundary(toolSelection.tools, issues, toolPath);
         const filteredToolSelection = filterToolSelection(toolSelection);
+        const requestedRuntime = selectWorkflowRuntime(runtimeOverrides, runtimeSettings(stage), runtimeDefaults, specRuntimeDefaults);
+        const resolvedRuntime = await resolveWorkflowRuntime(requestedRuntime, {
+            taskKey: key,
+            stageId: stage.id,
+            taskId,
+            agent: stageAgentName,
+        }, {
+            availableModels: options.availableModels,
+        });
         const runtime = {
             approvalMode: stage.approvalMode ?? spec.defaults?.approvalMode ?? "non-interactive",
-            model: stage.model ?? defaultModel,
-            thinking: stage.thinking ?? defaultThinking,
+            ...resolvedRuntime,
             tools: filteredToolSelection.tools,
             ...(filteredToolSelection.toolProviders
                 ? { toolProviders: filteredToolSelection.toolProviders }
@@ -800,11 +840,33 @@ async function compileArtifactGraphPlan(spec, options) {
         tasks,
         warnings,
         budget: {
-            models: defaultModel ? [{ model: defaultModel }] : [],
+            models: budgetModelRows(tasks),
             unratedModels: [],
         },
     };
 }
+function budgetModelRows(tasks) {
+    const models = new Set();
+    for (const task of tasks) {
+        if (typeof task?.runtime?.model === "string" && task.runtime.model.trim()) {
+            models.add(task.runtime.model.trim());
+        }
+        const loop = task?.dynamic?.decisionLoop;
+        if (!loop || typeof loop !== "object")
+            continue;
+        for (const profile of [
+            loop.planner,
+            loop.workerDefaults,
+            loop.verifier,
+            loop.synthesis,
+        ]) {
+            if (typeof profile?.model === "string" && profile.model.trim()) {
+                models.add(profile.model.trim());
+            }
+        }
+    }
+    return [...models].sort().map((model) => ({ model }));
+}
 function isSupportStage(stage) {
     return stage?.support !== undefined && stage?.type === undefined;
 }
@@ -864,7 +926,7 @@ function buildSupportTask(stage, taskId, key, prompt, dependencyKeys, cwd, workf
         ...overrides,
     };
 }
-function buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, cwd, specDir, workflowInputText, runtimeTask, defaultModel, defaultThinking, overrides) {
+function buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, cwd, specDir, workflowInputText, runtimeTask, controllerRuntime, runtimePriority, overrides) {
     const dynamic = stage.dynamic ?? {};
     const uses = String(dynamic.uses);
     const normalizedPrompt = String(prompt ?? "").replace(/\$\{item\}/g, "the relevant item from the dependency context");
@@ -917,7 +979,7 @@ function buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, cwd, specD
             usesPath: resolve(specDir, String(workflow.uses)),
         };
     }
-    const decisionLoop = compileDynamicDecisionLoop(dynamic.decisionLoop, defaultModel, defaultThinking);
+    const decisionLoop = compileDynamicDecisionLoop(dynamic.decisionLoop, runtimePriority);
     return {
         key,
         id: key,
@@ -935,8 +997,7 @@ function buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, cwd, specD
         explicitWorktreePolicy: false,
         runtime: {
             approvalMode: "non-interactive",
-            model: defaultModel,
-            thinking: defaultThinking,
+            ...controllerRuntime,
             maxRuntimeMs: dynamic.budget?.maxRuntimeMs ?? DEFAULT_DYNAMIC_MAX_RUNTIME_MS,
         },
         safety: {
@@ -974,21 +1035,24 @@ function buildDynamicTask(stage, taskId, key, prompt, dependencyKeys, cwd, specD
             helpers,
             workflows,
             ...(decisionLoop ? { decisionLoop } : {}),
+            ...(runtimePriority.runtimeOverrides
+                ? { runtimeOverrides: runtimePriority.runtimeOverrides }
+                : {}),
         },
         ...overrides,
     };
 }
-function compileDynamicDecisionLoop(value, defaultModel, defaultThinking) {
+function compileDynamicDecisionLoop(value, runtimePriority) {
     if (!isPlainRecord(value))
         return undefined;
     const allowedToolSelection = filterToolSelection(resolveToolSelection([Array.isArray(value.allowedTools) ? value.allowedTools : undefined], undefined));
     const maxFindings = positiveInteger(recordValue(value.stateIndex, "maxFindings"));
     const deprecatedRequiredFindingIds = stringArray(recordValue(value.stateIndex, "requiredFindingIds"));
     return {
-        planner: compileDynamicDecisionLoopProfile(value.planner, defaultModel, defaultThinking),
-        workerDefaults: compileDynamicDecisionLoopProfile(value.workerDefaults, defaultModel, defaultThinking),
-        verifier: compileDynamicDecisionLoopProfile(value.verifier, defaultModel, defaultThinking),
-        synthesis: compileDynamicDecisionLoopProfile(value.synthesis, defaultModel, defaultThinking),
+        planner: compileDynamicDecisionLoopProfile(value.planner, runtimePriority),
+        workerDefaults: compileDynamicDecisionLoopProfile(value.workerDefaults, runtimePriority),
+        verifier: compileDynamicDecisionLoopProfile(value.verifier, runtimePriority),
+        synthesis: compileDynamicDecisionLoopProfile(value.synthesis, runtimePriority),
         allowedAgents: stringArray(value.allowedAgents),
         ...(allowedToolSelection.tools
             ? { allowedTools: allowedToolSelection.tools }
@@ -1029,22 +1093,16 @@ function compileDynamicDecisionLoop(value, defaultModel, defaultThinking) {
         },
     };
 }
-function compileDynamicDecisionLoopProfile(value, defaultModel, defaultThinking) {
+function compileDynamicDecisionLoopProfile(value, runtimePriority) {
     if (!isPlainRecord(value))
         return undefined;
     const toolSelection = filterToolSelection(resolveToolSelection([Array.isArray(value.tools) ? value.tools : undefined], undefined));
-    const model = typeof value.model === "string" && value.model.trim()
-        ? value.model.trim()
-        : defaultModel;
-    const thinking = typeof value.thinking === "string" && value.thinking.trim()
-        ? value.thinking.trim()
-        : defaultThinking;
+    const runtime = selectWorkflowRuntime(runtimePriority.runtimeOverrides, runtimeSettings(value), runtimePriority.stageRuntime, runtimePriority.runtimeDefaults, runtimePriority.specRuntimeDefaults);
     return {
         ...(typeof value.agent === "string" && value.agent.trim()
             ? { agent: value.agent.trim() }
             : {}),
-        ...(model ? { model } : {}),
-        ...(thinking ? { thinking } : {}),
+        ...runtime,
         ...(toolSelection.tools ? { tools: toolSelection.tools } : {}),
         ...(toolSelection.toolProviders
             ? { toolProviders: toolSelection.toolProviders }

package/dist/dynamic-generated-task-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledDynamicWorkflowTask, CompiledTask, CompiledWorkflow, ThinkingLevel, WorkflowRunRecord, WorkflowTaskRunRecord } from "./types.js";
+import { type WorkflowModelInfo } from "./workflow-runtime.js";
 export interface DynamicArtifactInput {
     kind: "workflow-artifact-ref";
     name: string;
@@ -41,6 +42,7 @@ export declare function buildDynamicGeneratedCompiledTask(input: {
     branchId?: string;
     request: DynamicAgentRequest;
     dynamic: CompiledDynamicWorkflowTask;
+    availableModels?: WorkflowModelInfo[];
 }): Promise<CompiledTask>;
 export declare function isDynamicCompiledTaskPayload(value: unknown): value is CompiledTask;
 export declare function assertDynamicGeneratedMetadataMatches(compiledTask: CompiledTask, expected: {

package/dist/dynamic-generated-task-runtime.js

@@ -6,6 +6,7 @@ import { readOrRebuildDynamicState } from "./dynamic-state.js";
 import { sanitizeTaskId } from "./engine-run-graph.js";
 import { fromProjectPath, isTerminalTaskStatus, readJson } from "./store.js";
 import { classifyToolCapability, effectiveToolClassification, providersForSelectedTools, toolAllowedByAuthorityCeiling, } from "./tool-metadata.js";
+import { resolveWorkflowRuntime, selectWorkflowRuntime, } from "./workflow-runtime.js";
 const DYNAMIC_OUTPUT_MAX_DIGEST_CHARS = 1000;
 const DYNAMIC_DELEGATION_TOOLS = new Set([
     "skill_test_subagent",
@@ -69,6 +70,13 @@ export async function buildDynamicGeneratedCompiledTask(input) {
     }
     const toolProviders = executionProfile?.toolProviders ??
         providersForSelectedTools(tools, new Map(Object.entries(input.controllerCompiledTask.runtime.toolProviders ?? {})));
+    const selectedRuntime = selectWorkflowRuntime(input.dynamic.runtimeOverrides, runtimeSettings(input.request), runtimeSettings(executionProfile), runtimeSettings(input.controllerCompiledTask.runtime), runtimeSettings(agentDefinition));
+    const resolvedRuntime = await resolveWorkflowRuntime(selectedRuntime, {
+        taskKey: input.generatedSpecId,
+        stageId: input.controllerStageId,
+        taskId: input.request.id,
+        agent: requestedAgent,
+    }, { availableModels: input.availableModels ?? input.dynamic.availableModels });
     const unknownTools = (tools ?? []).filter((tool) => effectiveToolClassification(tool, toolProviders) === undefined);
     if (unknownTools.length > 0) {
         throw new Error(`dynamic agent requested tools without trusted classification metadata: ${unknownTools.join(", ")}`);
@@ -135,14 +143,7 @@ export async function buildDynamicGeneratedCompiledTask(input) {
         explicitWorktreePolicy: requiresWorktree,
         runtime: {
             approvalMode: "non-interactive",
-            model: input.request.model ??
-                executionProfile?.model ??
-                input.controllerCompiledTask.runtime.model ??
-                agentDefinition.model,
-            thinking: input.request.thinking ??
-                executionProfile?.thinking ??
-                input.controllerCompiledTask.runtime.thinking ??
-                agentDefinition.thinking,
+            ...resolvedRuntime,
             tools,
             ...(toolProviders ? { toolProviders } : {}),
             maxRuntimeMs: input.request.maxRuntimeMs ??
@@ -461,6 +462,18 @@ function requiredDynamicString(value, field, api = "ctx.agent()") {
     }
     return value.trim();
 }
+function runtimeSettings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const model = typeof record.model === "string" && record.model.trim()
+        ? record.model.trim()
+        : undefined;
+    const thinking = typeof record.thinking === "string" && record.thinking.trim()
+        ? record.thinking.trim()
+        : undefined;
+    return model || thinking ? { model, thinking } : undefined;
+}
 function optionalDynamicString(value, field) {
     if (value === undefined)
         return undefined;

package/dist/engine.d.ts

@@ -1,20 +1,21 @@
+import { type WorkflowModelInfo, type WorkflowRuntimeDefaults } from "./workflow-runtime.js";
 import { type DynamicWorkflowUi } from "./dynamic-controller-policy.js";
-import { type CompiledWorkflow, type ThinkingLevel, type WorkflowRunRecord } from "./types.js";
+import { type CompiledWorkflow, type WorkflowRunRecord } from "./types.js";
 export { buildRunSourceContext } from "./workflow-source-context-runtime.js";
 export { evaluateLoopUntilCondition } from "./loop-runtime.js";
 export type { DynamicWorkflowUi } from "./dynamic-controller-policy.js";
 export interface WorkflowRunOptions {
     task?: string;
-    runtimeDefaults?: {
-        model?: string;
-        thinking?: ThinkingLevel;
-    };
+    runtimeOverrides?: WorkflowRuntimeDefaults;
+    runtimeDefaults?: WorkflowRuntimeDefaults;
+    availableModels?: WorkflowModelInfo[];
     dynamicUi?: DynamicWorkflowUi;
     runId?: string;
     parentRunId?: string;
 }
 interface WorkflowScheduleOptions {
     dynamicUi?: DynamicWorkflowUi;
+    availableModels?: WorkflowModelInfo[];
 }
 export declare function runWorkflowSpec(specPath: string, cwd: string, options?: WorkflowRunOptions): Promise<WorkflowRunRecord>;
 export declare function runDynamicTask(cwd: string, options?: WorkflowRunOptions): Promise<WorkflowRunRecord>;

package/dist/engine.js

@@ -1,16 +1,16 @@
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, extname, join, resolve, } from "node:path";
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
 import { compileWorkflow } from "./compiler.js";
 import { loadWorkflowSpec } from "./schema.js";
-import { createRunRecord, createTaskRunRecord, compiledWorkflowPath, fromProjectPath, indexSupervisorErrorPath, isTerminalWorkflowStatus, isTerminalTaskStatus, listRunRecords, readIndex, readJson, readRunRecord, resetTaskForResume, setTaskTerminal, supervisorPath, toProjectPath, updateIndex, withRunLease, writeJsonAtomic, writeRunRecord, writeCompiledRunArtifact, writeStaticRunArtifacts, } from "./store.js";
+import { createRunRecord, createTaskRunRecord, compiledWorkflowPath, fromProjectPath, indexSupervisorErrorPath, isTerminalWorkflowStatus, isTerminalTaskStatus, listRunRecords, readIndex, readJson, readRunRecord, resetTaskForResume, setTaskTerminal, supervisorPath, toProjectPath, updateIndex, withRunLease, workflowRunPath, writeJsonAtomic, writeRunRecord, writeCompiledRunArtifact, writeStaticRunArtifacts, } from "./store.js";
 import { resolveWorkflowBackend } from "./backend.js";
 import { ensureManagedWorktree } from "./worktree.js";
 import { resolveWorkflowHelperRef } from "./workflow-helpers.js";
 import { buildAvailableToolView } from "./tool-metadata.js";
 import { workflowBundleFingerprint, workflowBundleSpecPath, } from "./workflow-source-context-runtime.js";
-import { readSimpleJsonPath } from "./workflow-runtime.js";
+import { readSimpleJsonPath, } from "./workflow-runtime.js";
 import { dynamicRunDir, hashDynamicRequest, readDynamicEvents, } from "./dynamic-events.js";
 import { ensureDynamicControllerInitialized, readOrRebuildDynamicState, recordDynamicControllerPhase, recordDynamicControllerStatus, recordDynamicEventAndUpdateState, } from "./dynamic-state.js";
 import { DynamicControllerBudgetBlocked, DynamicControllerNestedApprovalBlocked, DynamicControllerSuspended, } from "./dynamic-controller-errors.js";
@@ -21,7 +21,6 @@ import { normalizeDynamicFanoutPlanRequest, runDynamicDecisionLoopStatusPersistC
 import { assertRunTaskPositionalAlignment, buildForeachGeneratedTasks, dependenciesReady, markDagDependentsSkipped, nextTaskRecordIndex, reconcileDynamicGeneratedRunRecords, recoverStaleRunningDynamicControllers, replaceDependencyList, sourceStageIdsForFrom, stageSourcePolicy, updateDownstreamDependencies, } from "./engine-run-graph.js";
 import { reconcileLoopTaskMaterialization, scheduleLoop, } from "./loop-runtime.js";
 import { executeSupportTask, normalizeDynamicControllerOutput, prepareArtifactGraphRetryTask, prepareDagTask, readArtifactGraphControl, readArtifactGraphSupportSources, readSupportSources, writeArtifactGraphDynamicResult, } from "./artifact-graph-runtime.js";
-import { isDynamicOutputProfile, } from "./dynamic-profiles.js";
 import { DIRECT_DYNAMIC_RUNTIME_VERSION, ensureDirectDynamicRuntimeBundle, } from "./dynamic-runtime-bundle.js";
 import { WORKFLOW_RUN_TYPE, } from "./types.js";
 export { buildRunSourceContext } from "./workflow-source-context-runtime.js";
@@ -37,6 +36,7 @@ const DYNAMIC_CONTROLLER_ENGINE_CAPABILITIES = Object.freeze({
 });
 const DYNAMIC_CONTROLLER_ENGINE_INTEGRITY_ERROR_MESSAGE = "incompatible or stale pi-workflow engine: dynamic controller context is missing runDecisionLoop (rebuild dist / reload workflow engine)";
 const supervisorTimers = new Map();
+const supervisorRunMtimes = new Map();
 export async function runWorkflowSpec(specPath, cwd, options = {}) {
     const loaded = await loadWorkflowSpec(specPath, cwd);
     return runLoadedWorkflowSpec(cwd, loaded.specPath, loaded.spec, options);
@@ -62,7 +62,9 @@ async function runLoadedWorkflowSpec(cwd, specPath, spec, options, provenance) {
         cwd,
         specPath,
         task: options.task,
+        runtimeOverrides: options.runtimeOverrides,
         runtimeDefaults: options.runtimeDefaults,
+        availableModels: options.availableModels,
     });
     const { run } = await createRunRecord(cwd, compiled, specPath, {
         runId: options.runId,
@@ -75,11 +77,14 @@ async function runLoadedWorkflowSpec(cwd, specPath, spec, options, provenance) {
         await writeStaticRunArtifacts(cwd, run, compiled, spec);
         await writeRunRecord(cwd, run);
     });
-    const scheduled = (await scheduleRun(cwd, run.runId, compiled, {
+    const scheduleOptions = {
         dynamicUi: options.dynamicUi,
-    })) ?? (await readRunRecord(cwd, run.runId));
+        availableModels: options.availableModels,
+    };
+    const scheduled = (await scheduleRun(cwd, run.runId, compiled, scheduleOptions)) ??
+        (await readRunRecord(cwd, run.runId));
     if (scheduled.status === "running")
-        watchRun(cwd, scheduled.runId, { dynamicUi: options.dynamicUi });
+        watchRun(cwd, scheduled.runId, scheduleOptions);
     return scheduled;
 }
 export async function refreshRun(cwd, runIdOrPrefix) {
@@ -167,15 +172,26 @@ export function watchRun(cwd, runId, options = {}) {
         return;
     const timer = setInterval(() => {
         void (async () => {
+            const previousMtime = supervisorRunMtimes.get(key);
+            const beforeMtime = await readRunMtimeMs(cwd, runId);
             const refreshed = await refreshRun(cwd, runId);
+            const afterMtime = await readRunMtimeMs(cwd, runId);
+            const currentMtime = afterMtime ?? beforeMtime;
+            if (currentMtime !== undefined)
+                supervisorRunMtimes.set(key, currentMtime);
             if (refreshed.status === "running") {
-                await scheduleRun(cwd, runId, undefined, options);
+                const unchanged = previousMtime !== undefined &&
+                    currentMtime !== undefined &&
+                    currentMtime <= previousMtime;
+                if (!unchanged)
+                    await scheduleRun(cwd, runId, undefined, options);
                 return;
             }
             const existing = supervisorTimers.get(key);
             if (existing)
                 clearInterval(existing);
             supervisorTimers.delete(key);
+            supervisorRunMtimes.delete(key);
         })().catch((error) => {
             void recordSupervisorError(cwd, runId, error);
         });
@@ -183,6 +199,16 @@ export function watchRun(cwd, runId, options = {}) {
     timer.unref?.();
     supervisorTimers.set(key, timer);
 }
+async function readRunMtimeMs(cwd, runId) {
+    try {
+        return (await stat(workflowRunPath(cwd, runId))).mtimeMs;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
 export async function scheduleRun(cwd, runId, compiled, options = {}) {
     return withRunLease(cwd, runId, async () => {
         let run = await readRunRecord(cwd, runId);
@@ -629,6 +655,7 @@ async function executeDynamicControllerTask(cwd, run, compiledFlow, controllerIn
             sources,
             dynamic: compiledTask.dynamic,
             dynamicUi: options.dynamicUi,
+            availableModels: options.availableModels,
         });
         await assertDynamicGeneratedTasksSettled({
             cwd,
@@ -638,6 +665,7 @@ async function executeDynamicControllerTask(cwd, run, compiledFlow, controllerIn
             controllerTask: task,
             controllerCompiledTask: compiledTask,
             dynamic: compiledTask.dynamic,
+            availableModels: options.availableModels,
         });
         await recordActiveRuntime();
         const unrunBranchBlockers = await dynamicUnrunBranchBlockers(cwd, run.runId, task.specId);
@@ -1170,57 +1198,12 @@ function requiredDynamicString(value, field, api = "ctx.agent()") {
     }
     return value.trim();
 }
-function optionalDynamicString(value, field) {
-    if (value === undefined)
-        return undefined;
-    return requiredDynamicString(value, field);
-}
-function optionalDynamicStringArray(value, field) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-        throw new Error(`ctx.agent() ${field} must be an array of strings`);
-    }
-    return value.map((item) => item.trim()).filter(Boolean);
-}
-function isPlainDynamicRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalDynamicPositiveInteger(value, field) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw new Error(`ctx.agent() ${field} must be a positive integer`);
-    }
-    return value;
-}
-function requiredDynamicOutputProfile(value, field, api) {
-    const profile = requiredDynamicString(value, field, api);
-    if (!isDynamicOutputProfile(profile)) {
-        throw new Error(`${api} ${field} has an unsupported output profile`);
-    }
-    return profile;
-}
-function requiredDynamicNonNegativeInteger(value, field, api) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-        throw new Error(`${api} ${field} must be a non-negative integer`);
-    }
-    return value;
-}
 function requiredDynamicPositiveInteger(value, field, api) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
         throw new Error(`${api} ${field} must be a positive integer`);
     }
     return value;
 }
-function optionalDynamicStringField(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function optionalDynamicOutputProfile(value) {
-    if (value === undefined)
-        return undefined;
-    return requiredDynamicOutputProfile(value, "outputProfile", "ctx.agent()");
-}
 async function currentDynamicBudgetRemaining(input) {
     const state = await readOrRebuildDynamicState(input.cwd, input.run.runId);
     const run = await readRunRecord(input.cwd, input.run.runId).catch(() => input.run);
@@ -1539,6 +1522,7 @@ async function repairMissingDynamicGeneratedTask(input, specId) {
             branchId: optionalEventString(event.payload.branchId),
             request,
             dynamic: input.dynamic,
+            availableModels: input.availableModels,
         });
     assertDynamicGeneratedMetadataMatches(compiledTask, {
         controllerSpecId: input.controllerTask.specId,
@@ -1634,6 +1618,7 @@ async function runDynamicAgentRequest(input) {
                 branchId: generationBranchId,
                 request: generationRequest,
                 dynamic: input.dynamic,
+                availableModels: input.availableModels,
             });
         assertDynamicGeneratedMetadataMatches(compiledTask, {
             controllerSpecId: input.controllerTask.specId,