@agwab/pi-workflow 0.2.0 → 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

package/dist/compiler.d.ts

@@ -1,5 +1,5 @@
-import { type ArtifactGraphWorkflowSpec, type ThinkingLevel } from "./types.js";
-import { type WorkflowModelInfo } from "./workflow-runtime.js";
+import { type ArtifactGraphWorkflowSpec } from "./types.js";
+import { type WorkflowModelInfo, type WorkflowRuntimeDefaults } from "./workflow-runtime.js";
 interface CompileOptions {
     cwd: string;
     specPath?: string;
@@ -7,9 +7,7 @@ interface CompileOptions {
 }
 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,7 +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, } from "./workflow-runtime.js";
+import { resolveWorkflowRuntime, selectWorkflowRuntime, } from "./workflow-runtime.js";
 const DELEGATION_TOOLS = new Set([
     "skill_test_subagent",
     "workflow",
@@ -413,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)) {
@@ -450,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 = [];
@@ -475,17 +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 resolvedDynamicRuntime = await resolveWorkflowRuntime({ model: defaultModel, thinking: defaultThinking }, {
+            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,
@@ -539,13 +560,7 @@ async function compileArtifactGraphPlan(spec, options) {
         validateToolSubset(toolSelection.tools, stageAgent, issues, toolPath);
         validateDelegationBoundary(toolSelection.tools, issues, toolPath);
         const filteredToolSelection = filterToolSelection(toolSelection);
-        // Explicit runtime overrides outrank stage pins; spec defaults fill last.
-        const requestedRuntime = {
-            model: options.runtimeDefaults?.model ?? stage.model ?? spec.defaults?.model,
-            thinking: options.runtimeDefaults?.thinking ??
-                stage.thinking ??
-                spec.defaults?.thinking,
-        };
+        const requestedRuntime = selectWorkflowRuntime(runtimeOverrides, runtimeSettings(stage), runtimeDefaults, specRuntimeDefaults);
         const resolvedRuntime = await resolveWorkflowRuntime(requestedRuntime, {
             taskKey: key,
             stageId: stage.id,
@@ -825,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;
 }
@@ -889,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");
@@ -942,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,
@@ -960,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: {
@@ -999,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 }
@@ -1054,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,15 +1,13 @@
-import { type WorkflowModelInfo } from "./workflow-runtime.js";
+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;
@@ -17,6 +15,7 @@ export interface WorkflowRunOptions {
 }
 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,10 +1,10 @@
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+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";
@@ -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,6 +62,7 @@ async function runLoadedWorkflowSpec(cwd, specPath, spec, options, provenance) {
         cwd,
         specPath,
         task: options.task,
+        runtimeOverrides: options.runtimeOverrides,
         runtimeDefaults: options.runtimeDefaults,
         availableModels: options.availableModels,
     });
@@ -76,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) {
@@ -168,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);
         });
@@ -184,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);
@@ -630,6 +655,7 @@ async function executeDynamicControllerTask(cwd, run, compiledFlow, controllerIn
             sources,
             dynamic: compiledTask.dynamic,
             dynamicUi: options.dynamicUi,
+            availableModels: options.availableModels,
         });
         await assertDynamicGeneratedTasksSettled({
             cwd,
@@ -639,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);
@@ -1171,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);
@@ -1540,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,
@@ -1635,6 +1618,7 @@ async function runDynamicAgentRequest(input) {
                 branchId: generationBranchId,
                 request: generationRequest,
                 dynamic: input.dynamic,
+                availableModels: input.availableModels,
             });
         assertDynamicGeneratedMetadataMatches(compiledTask, {
             controllerSpecId: input.controllerTask.specId,

package/dist/extension.js

@@ -13,7 +13,7 @@ import { fromProjectPath, readIndex, readRunRecord } from "./store.js";
 import { loadWorkflowSpec } from "./schema.js";
 import { listWorkflows, resolveWorkflowRef } from "./workflow-specs.js";
 import { WorkflowValidationError, } from "./types.js";
-import { toWorkflowModelInfo } from "./workflow-runtime.js";
+import { toWorkflowModelInfo, } from "./workflow-runtime.js";
 const UNFINISHED_RUN_NOTICE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const UNFINISHED_RUN_NOTICE_MAX_RUNS = 5;
 const UNFINISHED_RUN_NOTICE_DEDUPE_MS = 6 * 60 * 60 * 1000;
@@ -442,8 +442,8 @@ function parseWorkflowDynamicToolParams(params) {
     const model = optionalStringParam(params, "model", "workflow_dynamic")?.trim();
     const rawThinking = optionalStringParam(params, "thinking", "workflow_dynamic")?.trim();
     const thinking = rawThinking ? parseThinkingLevel(rawThinking) : undefined;
-    const runtimeDefaults = model || thinking ? { model: model || undefined, thinking } : undefined;
-    return { task, detach: detachValue === true, runtimeDefaults };
+    const runtimeOverrides = model || thinking ? { model: model || undefined, thinking } : undefined;
+    return { task, detach: detachValue === true, runtimeOverrides };
 }
 function stringParam(params, key, toolName) {
     const value = params[key];
@@ -521,7 +521,8 @@ async function startWorkflowRunFromRequest(request, ctx, api) {
         throw new Error('This workflow needs a task. Usage: /workflow run <workflow-name-or-path> "<task>"');
     const run = await runWorkflowSpec(workflow, ctx.cwd, {
         task,
-        runtimeDefaults: request.runtimeDefaults ?? currentRuntimeDefaults(ctx, api),
+        runtimeOverrides: request.runtimeOverrides,
+        runtimeDefaults: currentRuntimeDefaults(ctx, api),
         availableModels: availableWorkflowModels(ctx),
         dynamicUi: dynamicUiFromContext(ctx),
     });
@@ -544,7 +545,8 @@ async function startDynamicRunFromRequest(request, ctx, api) {
         throw new Error('This dynamic workflow needs a task. Usage: /workflow dynamic "<task>"');
     const run = await runDynamicTask(ctx.cwd, {
         task,
-        runtimeDefaults: request.runtimeDefaults ?? currentRuntimeDefaults(ctx, api),
+        runtimeOverrides: request.runtimeOverrides,
+        runtimeDefaults: currentRuntimeDefaults(ctx, api),
         availableModels: availableWorkflowModels(ctx),
         dynamicUi: dynamicUiFromContext(ctx),
     });
@@ -763,27 +765,27 @@ async function handleWorkflowCommand(args, ctx, api) {
             const parsed = parseWorkflowRunArgs(args);
             const specPath = parsed.specPath ||
                 requireArg(tokens, 1, '/workflow run <workflow-name-or-path> "<task>"');
-            const runtimeDefaults = parsed.model || parsed.thinking
+            const runtimeOverrides = parsed.model || parsed.thinking
                 ? { model: parsed.model, thinking: parsed.thinking }
                 : undefined;
             const result = await startWorkflowRunFromRequest({
                 workflow: specPath,
                 task: parsed.task,
                 detach: parsed.detach,
-                runtimeDefaults,
+                runtimeOverrides,
             }, ctx, api);
             emitRunStartResult(ctx, result.run.status, result.text);
             return;
         }
         if (action === "dynamic") {
             const parsed = parseWorkflowDynamicArgs(args);
-            const runtimeDefaults = parsed.model || parsed.thinking
+            const runtimeOverrides = parsed.model || parsed.thinking
                 ? { model: parsed.model, thinking: parsed.thinking }
                 : undefined;
             const result = await startDynamicRunFromRequest({
                 task: parsed.task,
                 detach: parsed.detach,
-                runtimeDefaults,
+                runtimeOverrides,
             }, ctx, api);
             emitRunStartResult(ctx, result.run.status, result.text);
             return;

package/dist/store.d.ts

@@ -25,13 +25,15 @@ export declare function createRunRecord(cwd: string, compiled: CompiledWorkflow,
     runDir: string;
 }>;
 export declare function writeRunRecord(cwd: string, run: WorkflowRunRecord): Promise<void>;
+export declare function flushPendingIndexUpdatesForTests(): Promise<void>;
+export declare function setIndexUpdateDebounceMsForTests(value?: number): void;
 export declare function writeCompiledRunArtifact(cwd: string, runId: string, compiled: CompiledWorkflow): Promise<void>;
 export declare function writeStaticRunArtifacts(cwd: string, run: WorkflowRunRecord, compiled: CompiledWorkflow, originalSpec: unknown): Promise<void>;
 export declare function findRunRecordPath(cwd: string, runIdOrPrefix: string): Promise<string | undefined>;
 export declare function readRunRecord(cwd: string, runIdOrPrefix: string): Promise<WorkflowRunRecord>;
 export declare function readIndex(cwd: string): Promise<WorkflowIndexRecord | undefined>;
 export declare function listRunRecords(cwd: string): Promise<WorkflowRunRecord[]>;
-export declare function updateIndex(cwd: string): Promise<WorkflowIndexRecord>;
+export declare function updateIndex(cwd: string, changedRunId?: string): Promise<WorkflowIndexRecord>;
 export declare function deriveRunStatus(run: WorkflowRunRecord): WorkflowRunRecord;
 export declare function summarizeTasks(tasks: WorkflowTaskRunRecord[]): TaskSummary;
 export declare function deriveWorkflowStatus(summary: TaskSummary): WorkflowRunStatus;