@marcoscale98/pi-extensible-workflows 5.19.1-fork.1 → 6.2.1-fork.1

package/dist/src/utils.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
-import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, THINKING_LEVELS, WorkflowError } from "./types.js";
+import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WorkflowError } from "./types.js";
 import { Minimatch } from "minimatch";
+import { THINKING_LEVELS } from "./types.js";
 export class SerialLane {
     #tail = Promise.resolve();
     run(task) {
@@ -103,13 +104,22 @@ export const WORKFLOW_EXTENSION_NAMESPACE = /^[A-Za-z][A-Za-z0-9_-]*$/;
 export function validWorkflowExtensionNamespace(value) { return WORKFLOW_EXTENSION_NAMESPACE.test(value) && value !== "__proto__" && value !== "constructor" && value !== "prototype"; }
 export function parseThinking(value) { return isThinkingLevel(value) ? value : undefined; }
 export function parseModelReference(value) {
-    const match = /^([^/:\s]+)\/([^:\s]+)(?::([^:\s]+))?$/.exec(value);
+    const match = /^([^/:\s]+)\/([^\s]+)$/.exec(value);
     if (!match?.[1] || !match[2])
         fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
-    const thinking = match[3];
-    if (thinking !== undefined && !isThinkingLevel(thinking))
-        fail("UNKNOWN_MODEL", `Invalid thinking level: ${thinking}`);
-    return { provider: match[1], model: match[2], ...(thinking !== undefined ? { thinking } : {}) };
+    // The model id is everything after the first slash, so namespaced ids such as
+    // `deepseek/deepseek-v4.1-flash:nitro` survive intact. Only a trailing segment
+    // that names a thinking level is one.
+    const reference = match[2];
+    const separator = reference.lastIndexOf(":");
+    const suffix = separator === -1 ? undefined : reference.slice(separator + 1);
+    if (suffix === "")
+        fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+    const thinking = suffix !== undefined && isThinkingLevel(suffix) ? suffix : undefined;
+    const model = thinking === undefined ? reference : reference.slice(0, separator);
+    if (model === "")
+        fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+    return { provider: match[1], model, ...(thinking === undefined ? {} : { thinking }) };
 }
 export function assertModelThinking(value, path = "model") {
     if (value.includes("/") && parseModelReference(value).thinking === undefined)
@@ -190,6 +200,10 @@ export function resolveModelReference(value, aliases = {}, knownModels, settings
     };
     return resolveReference(value, []);
 }
+export function modelCapability(value, aliases, knownModels, settingsPath) {
+    const parsed = typeof value === "string" ? resolveModelReference(value, aliases, knownModels, settingsPath) : value;
+    return `${parsed.provider}/${parsed.model}`;
+}
 /**
  * Tools a session can reach, and so the ceiling for its agents: the declared tools plus the ones
  * only codemode scripts call or tool_search loads, such as MCP tools with the default exposure.
@@ -208,10 +222,6 @@ export function physicalModel(spec, aliases = {}, knownModels, settingsPath) {
     const target = resolveModelReference(spec.model, aliases, knownModels, settingsPath);
     return spec.thinking === undefined ? target : { ...target, thinking: spec.thinking };
 }
-export function modelCapability(value, aliases, knownModels, settingsPath) {
-    const parsed = typeof value === "string" ? resolveModelReference(value, aliases, knownModels, settingsPath) : value;
-    return `${parsed.provider}/${parsed.model}`;
-}
 export function aliasDrift(previous, current) {
     return [...new Set([...Object.keys(previous), ...Object.keys(current)])].sort().flatMap((name) => previous[name] === current[name] ? [] : [`${name}: ${previous[name] ?? "(missing)"} -> ${current[name] ?? "(missing)"}`]);
 }

package/dist/src/validation.d.ts

@@ -1,8 +1,6 @@
 import type { CheckpointInput, JsonValue, PreflightCapabilities, PreflightResult, ShellOptions, StaticWorkflowCall, ValidatedWorkflowLaunch, WorkflowMetadata, WorkflowValidationContext, WorkflowValidationParameters } from "./types.js";
 import type { WorkflowRegistryApi } from "./registry.js";
 export { validateSchema } from "./utils.js";
-export { loadAgentDefinitions, loadProjectAgentDefinitions, parseRoleMarkdown, workflowRoleDirectories } from "./roles.js";
-export type { WorkflowRoleDirectoryInput } from "./roles.js";
 export { DEFAULT_SETTINGS, loadCodemodeToolsSetting, loadSettings, loadSettingsOverrides, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateContextFileScopes, validateModelAliasAvailability, validateSelectorList, validateWorkflowExtensionSettings, workflowProjectSettingsPath, workflowSettingsPath, workflowToolExposure } from "./settings.js";
 export declare function validateCheckpoint(value: unknown): CheckpointInput;
 /**
@@ -12,10 +10,18 @@ export declare function validateCheckpoint(value: unknown): CheckpointInput;
 export declare function scriptToolReferences(script: string): string[] | undefined;
 export declare function instrumentWorkflow(script: string): string;
 export declare function workflowPrompt(template: string, values: Readonly<Record<string, JsonValue>>): string;
+export declare function isCoreAgentOption(key: string): boolean;
 export declare function validateAgentOptions(value: unknown): Readonly<Record<string, JsonValue>>;
 export declare function validateShellOptions(value: unknown): ShellOptions;
 export declare function validateShellCommand(value: unknown): string;
 export declare function inspectWorkflowScript(script: string): StaticWorkflowCall[];
+/**
+ * Distinct, completely static option objects of agent(...) and agent.create(...) calls, so launch can inspect them
+ * before any effect. Calls with any dynamic option stay runtime-checked, and so do handles whose sends may add options.
+ */
+export declare function staticAgentPreparationOptions(script: string, registered?: Readonly<Record<string, {
+    run: (...args: never[]) => unknown;
+}>>): Array<Readonly<Record<string, JsonValue>>>;
 export declare function preflight(script: string, capabilities: PreflightCapabilities, schemas?: readonly unknown[], metadata?: WorkflowMetadata, compatibility?: boolean): PreflightResult;
 export declare function validateWorkflowLaunch(params: WorkflowValidationParameters, context: WorkflowValidationContext, registry?: WorkflowRegistryApi): ValidatedWorkflowLaunch;
 export declare function validateWorkflowLaunchWithRegistry(params: WorkflowValidationParameters, context: WorkflowValidationContext, registry?: WorkflowRegistryApi): ValidatedWorkflowLaunch;

package/dist/src/validation.js

@@ -2,11 +2,9 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import * as acorn from "acorn";
 import { Script } from "node:vm";
-import { assertModelThinking, validateSchema, deepFreeze, errorText, fail, jsonObject, jsonValue, mergeWorkflowExtensionSettings, modelAliasName, modelCapability, object, positiveInteger, resolveModelReference, resourcePatternHasMagic, unknownModel } from "./utils.js";
+import { assertModelThinking, validateSchema, deepFreeze, errorText, fail, jsonObject, jsonValue, object, positiveInteger, resourcePatternHasMagic } from "./utils.js";
 import { WORKFLOW_CALL_KINDS } from "./types.js";
 export { validateSchema } from "./utils.js";
-import { loadAgentDefinitions, loadProjectAgentDefinitions } from "./roles.js";
-export { loadAgentDefinitions, loadProjectAgentDefinitions, parseRoleMarkdown, workflowRoleDirectories } from "./roles.js";
 import { validateContextFileScopes, validateSelectorList } from "./settings.js";
 export { DEFAULT_SETTINGS, loadCodemodeToolsSetting, loadSettings, loadSettingsOverrides, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateContextFileScopes, validateModelAliasAvailability, validateSelectorList, validateWorkflowExtensionSettings, workflowProjectSettingsPath, workflowSettingsPath, workflowToolExposure } from "./settings.js";
 export function validateCheckpoint(value) {
@@ -18,23 +16,6 @@ export function validateCheckpoint(value) {
         fail("INVALID_METADATA", "checkpoint context exceeds 4096 UTF-8 bytes");
     return { name: value.name, prompt: value.prompt, context: value.context };
 }
-function validateRolePolicies(definitions, roles, availableModels, aliases = {}, knownModels = availableModels, settingsPath) {
-    for (const role of roles) {
-        const definition = definitions[role];
-        if (!definition)
-            continue;
-        if (definition.model !== undefined) {
-            const resolved = modelCapability(definition.model, aliases, knownModels, settingsPath);
-            if (!availableModels.has(resolved)) {
-                if (modelAliasName(definition.model, aliases))
-                    unknownModel(definition.model, resolved, settingsPath);
-                fail("UNKNOWN_MODEL", `Unknown model for role ${role}: ${resolved}`);
-            }
-        }
-        // Role tools absent from the session are tolerated at launch: the runtime resolve emits a
-        // warning and the agent runs without them. Doctor still reports unmatched patterns.
-    }
-}
 function validateWorkflowMetadata(value) {
     if (!object(value) || typeof value.name !== "string" || value.name.trim() === "")
         fail("INVALID_METADATA", "Workflow metadata requires a non-empty name");
@@ -348,8 +329,9 @@ export function workflowPrompt(template, values) {
         return typeof value === "string" ? value : JSON.stringify(value, null, 2);
     });
 }
-const AGENT_OPTION_KEYS = new Set(["label", "model", "tools", "skills", "extensions", "contextFiles", "role", "outputSchema", "retries", "timeoutMs"]);
-function validateAgentOption(key, value, aliases, knownModels, settingsPath) {
+const AGENT_OPTION_KEYS = new Set(["label", "model", "tools", "excludeTools", "skills", "extensions", "contextFiles", "outputSchema", "retries", "timeoutMs"]);
+export function isCoreAgentOption(key) { return AGENT_OPTION_KEYS.has(key); }
+function validateAgentOption(key, value) {
     switch (key) {
         case "label":
             if (typeof value !== "string" || !value.trim())
@@ -359,21 +341,21 @@ function validateAgentOption(key, value, aliases, knownModels, settingsPath) {
             if (typeof value !== "string" || !value.trim())
                 fail("INVALID_METADATA", "agent model must be a non-empty string");
             assertModelThinking(value, "agent model");
-            if (aliases !== undefined)
-                resolveModelReference(value, aliases, knownModels, settingsPath);
             break;
         case "tools":
         case "skills":
         case "extensions":
             validateSelectorList(value, "agent options", key, "INVALID_METADATA", key !== "extensions");
             break;
+        case "excludeTools":
+            if (!Array.isArray(value) || value.some((tool) => typeof tool !== "string" || !tool.trim() || tool !== tool.trim() || tool.startsWith("!") || resourcePatternHasMagic(tool)))
+                fail("INVALID_METADATA", "agent excludeTools must be an array of exact tool names");
+            if (value.includes("workflow_result"))
+                fail("INVALID_METADATA", "agent excludeTools cannot remove workflow_result");
+            break;
         case "contextFiles":
             validateContextFileScopes(value, "agent options");
             break;
-        case "role":
-            if (typeof value !== "string" || !value.trim())
-                fail("INVALID_METADATA", "agent role must be a non-empty string");
-            break;
         case "outputSchema":
             validateSchema(value, "agent outputSchema");
             break;
@@ -483,43 +465,123 @@ export function inspectWorkflowScript(script) {
                     knownOptionEntries.push([key, value.value]);
             }
             const knownOptions = Object.fromEntries(knownOptionEntries);
-            const base = { ...placement, kind, start: call.start, end: call.end, name: null, prompt: staticString(first), model: staticString(propertyNode(options, "model")), label: staticString(propertyNode(options, "label")), role: staticString(propertyNode(options, "role")) };
+            const base = { ...placement, kind, start: call.start, end: call.end, name: null, prompt: staticString(first), model: staticString(propertyNode(options, "model")), label: staticString(propertyNode(options, "label")) };
             return { ...base, ...(retries.known && typeof retries.value === "number" ? { retries: retries.value } : {}), ...(staticOutputSchema === undefined ? {} : { outputSchema: staticOutputSchema }), ...(optionKeys.length ? { options: knownOptions, optionKeys } : {}) };
         }
         if (kind === "checkpoint")
-            return { ...placement, kind, start: call.start, end: call.end, name: staticString(propertyNode(first, "name")), prompt: staticString(propertyNode(first, "prompt")), model: null, role: null };
+            return { ...placement, kind, start: call.start, end: call.end, name: staticString(propertyNode(first, "name")), prompt: staticString(propertyNode(first, "prompt")), model: null };
         if (kind === "shell")
-            return { ...placement, kind, start: call.start, end: call.end, name: staticString(first), prompt: null, model: null, role: null };
-        return { ...placement, kind, start: call.start, end: call.end, name: staticString(first), prompt: null, model: null, role: null };
+            return { ...placement, kind, start: call.start, end: call.end, name: staticString(first), prompt: null, model: null };
+        return { ...placement, kind, start: call.start, end: call.end, name: staticString(first), prompt: null, model: null };
+    });
+}
+/** Every option is a preparation input, because any hook may read it; one dynamic value leaves the whole call to runtime. */
+function staticPreparationOptions(node, omitted) {
+    if (node?.type !== "ObjectExpression")
+        return undefined;
+    const options = new Map();
+    for (const property of node.properties) {
+        if (property.type === "SpreadElement" || property.computed)
+            return undefined;
+        const key = propertyKeyName(property);
+        if (key === undefined)
+            return undefined;
+        if (key === omitted)
+            continue;
+        const value = staticValue(property.value);
+        // NOTE: an output schema only shapes the result, so a computed one (a const declared elsewhere) does not hide the call.
+        if (key === "outputSchema" && !value.known)
+            continue;
+        if (!value.known || !jsonValue(value.value))
+            return undefined;
+        options.set(key, value.value);
+    }
+    return Object.fromEntries(options);
+}
+/**
+ * A handle prepares its first turn with the create options merged with that send's options, so create options are complete
+ * only when every use of the handle provably passes no send options: `agent.create(...).send(prompt)` directly, or a
+ * `const` handle whose every reference is `handle.send(prompt)`. Computed access, destructuring, aliases or any other
+ * use leave the handle to runtime.
+ */
+function handlesWithCompleteOptions(program) {
+    const parents = new Map();
+    const references = new Map();
+    const visit = (node) => {
+        if (node.type === "Identifier")
+            references.set(node.name, [...(references.get(node.name) ?? []), node]);
+        for (const child of astChildren(node)) {
+            parents.set(child, node);
+            visit(child);
+        }
+    };
+    visit(program);
+    const plainSend = (member) => {
+        const call = member ? parents.get(member) : undefined;
+        return member?.type === "MemberExpression" && !member.computed && member.property.type === "Identifier" && member.property.name === "send"
+            && call?.type === "CallExpression" && call.callee === member && call.arguments.length <= 1 && call.arguments.every((argument) => argument.type !== "SpreadElement");
+    };
+    return agentCreateCalls(program).filter((create) => {
+        const parent = parents.get(create);
+        if (parent?.type === "MemberExpression" && parent.object === create)
+            return plainSend(parent);
+        const declaration = parent ? parents.get(parent) : undefined;
+        if (parent?.type !== "VariableDeclarator" || parent.init !== create || parent.id.type !== "Identifier" || declaration?.type !== "VariableDeclaration" || declaration.kind !== "const")
+            return false;
+        const name = parent.id.name;
+        return (references.get(name) ?? []).every((reference) => reference === parent.id || (parents.get(reference)?.type === "MemberExpression" && parents.get(reference).object === reference && plainSend(parents.get(reference))));
     });
 }
-function validateStaticAgentOptions(node, aliases = {}, knownModels, settingsPath) {
+/**
+ * Distinct, completely static option objects of agent(...) and agent.create(...) calls, so launch can inspect them
+ * before any effect. Calls with any dynamic option stay runtime-checked, and so do handles whose sends may add options.
+ */
+export function staticAgentPreparationOptions(script, registered = {}) {
+    const program = parseWorkflow(script);
+    const sources = [program, ...registeredFunctionPrograms(program, registered)];
+    const distinct = new Map();
+    for (const source of sources)
+        for (const options of programAgentOptions(source))
+            distinct.set(JSON.stringify(options), deepFreeze(options));
+    return [...distinct.values()];
+}
+/** Programs of the registered functions the script calls by name, so their agents are inspected before launch like inline ones. */
+function registeredFunctionPrograms(program, registered) {
+    const called = new Set();
+    const visit = (node) => {
+        if (node.type === "CallExpression" && node.callee.type === "Identifier" && Object.prototype.hasOwnProperty.call(registered, node.callee.name))
+            called.add(node.callee.name);
+        for (const child of astChildren(node))
+            visit(child);
+    };
+    visit(program);
+    const programs = [];
+    for (const name of called) {
+        const source = registered[name]?.run.toString() ?? "";
+        // A method prints as `async run(...) {}`, which only parses inside an object literal.
+        for (const wrapped of [`(${source})`, `({${source}})`]) {
+            try {
+                programs.push(acorn.parse(wrapped, { ecmaVersion: "latest", sourceType: "module" }));
+                break;
+            }
+            catch { /* try the next form; an unparsable function stays runtime-checked */ }
+        }
+    }
+    return programs;
+}
+function programAgentOptions(program) {
+    const calls = workflowCalls(program).filter((call) => call.callee.name === "agent").map((call) => call.arguments.some((argument) => argument.type === "SpreadElement") ? undefined : call.arguments.length < 2 ? {} : staticPreparationOptions(callArgument(call, 1)));
+    const handles = handlesWithCompleteOptions(program).map((call) => staticPreparationOptions(callArgument(call, 0), "name"));
+    return [...calls, ...handles].filter((options) => options !== undefined);
+}
+function validateStaticAgentOptions(node) {
     if (node?.type !== "ObjectExpression")
         return;
     for (const key of AGENT_OPTION_KEYS) {
         const value = staticValue(propertyNode(node, key));
         if (value.known)
-            validateAgentOption(key, value.value, aliases, knownModels, settingsPath);
-    }
-}
-function hasDynamicAgentRole(node) {
-    if (!node)
-        return false;
-    if (node.type !== "ObjectExpression")
-        return true;
-    for (let index = node.properties.length - 1; index >= 0; index -= 1) {
-        const property = node.properties[index];
-        if (!property || property.type === "SpreadElement" || property.computed)
-            return true;
-        const key = propertyKeyName(property);
-        if (key === "role") {
-            const roleValue = staticValue(property.value);
-            if (roleValue.known && typeof roleValue.value === "string")
-                return false;
-            return true;
-        }
+            validateAgentOption(key, value.value);
     }
-    return false;
 }
 function validateStaticShellOptions(call) {
     if (call.arguments.some((argument) => argument.type === "SpreadElement"))
@@ -564,7 +626,7 @@ export function preflight(script, capabilities, schemas = [], metadata = { name:
     for (const call of calls) {
         const operation = call.callee.name;
         if (operation === "agent")
-            validateStaticAgentOptions(call.arguments[1], capabilities.modelAliases ?? {}, capabilities.knownModels ?? capabilities.models, capabilities.settingsPath);
+            validateStaticAgentOptions(call.arguments[1]);
         if (operation === "withWorktree")
             validateStaticWithWorktree(call, compatibility);
         if (operation === "shell")
@@ -582,11 +644,10 @@ export function preflight(script, capabilities, schemas = [], metadata = { name:
         const options = call.arguments.length === 1 ? callArgument(call, 0) : undefined;
         if (options?.type !== "ObjectExpression" || !literalString(propertyNode(options, "name"))?.trim())
             fail("INVALID_METADATA", "agent.create requires an options object with a stable explicit name");
-        validateStaticAgentOptions(options, capabilities.modelAliases ?? {}, capabilities.knownModels ?? capabilities.models, capabilities.settingsPath);
+        validateStaticAgentOptions(options);
         return options;
     });
     const agentOptions = [...calls.filter((call) => call.callee.name === "agent").map((call) => callArgument(call, 1)), ...handleOptions];
-    const dynamicAgentRoles = agentOptions.some((options) => hasDynamicAgentRole(options));
     const staticSchemas = [];
     for (const options of agentOptions) {
         const value = staticValue(propertyNode(options, "outputSchema"));
@@ -597,28 +658,17 @@ export function preflight(script, capabilities, schemas = [], metadata = { name:
         staticSchemas.push(schema);
     }
     checkedSchemas.push(...staticSchemas);
-    const modelRefs = agentOptions.flatMap((options) => { const requested = literalString(propertyNode(options, "model")); return requested === undefined ? [] : [{ requested, resolved: modelCapability(requested, capabilities.modelAliases, capabilities.knownModels ?? capabilities.models, capabilities.settingsPath) }]; });
-    const models = modelRefs.map(({ resolved }) => resolved);
+    const models = [];
     const tools = agentOptions.flatMap((options) => {
         const value = propertyNode(options, "tools");
         return value?.type === "ArrayExpression" ? value.elements.flatMap((element) => { const tool = element && element.type !== "SpreadElement" ? literalString(element) : undefined; return tool === undefined ? [] : [tool]; }) : [];
     });
-    const agentTypes = agentOptions.flatMap((options) => { const value = staticString(propertyNode(options, "role")); return value === null ? [] : [value]; });
     for (const pattern of tools) {
         const body = pattern.startsWith("!") ? pattern.slice(1) : pattern;
         if (!pattern.startsWith("!") && !resourcePatternHasMagic(pattern) && !capabilities.tools.has(body))
             fail("UNKNOWN_TOOL", `Unknown tool: ${body}`);
     }
-    const missingModel = capabilities.skipModelAvailability ? undefined : modelRefs.find(({ resolved }) => !capabilities.models.has(resolved));
-    if (missingModel) {
-        if (modelAliasName(missingModel.requested, capabilities.modelAliases ?? {}))
-            unknownModel(missingModel.requested, missingModel.resolved, capabilities.settingsPath);
-        fail("UNKNOWN_MODEL", `Unknown model: ${missingModel.resolved}`);
-    }
-    const missingType = agentTypes.find((type) => !capabilities.agentTypes.has(type));
-    if (missingType)
-        fail("UNKNOWN_AGENT_TYPE", `Unknown agent type: ${missingType}`);
-    return Object.freeze({ metadata: deepFreeze(checkedMetadata), referenced: deepFreeze({ phases, models, tools, agentTypes }), schemas: deepFreeze(checkedSchemas), dynamicAgentRoles });
+    return Object.freeze({ metadata: deepFreeze(checkedMetadata), referenced: deepFreeze({ phases, models, tools }), schemas: deepFreeze(checkedSchemas) });
 }
 export function validateWorkflowLaunch(params, context, registry) {
     return validateWorkflowLaunchWithRegistry(params, context, registry);
@@ -650,22 +700,8 @@ export function validateWorkflowLaunchWithRegistry(params, context, registry) {
     if (!script)
         fail("INVALID_SYNTAX", "Provide script or scriptPath");
     const metadata = validateWorkflowMetadata({ name: explicitName, ...(typeof params.description === "string" ? { description: params.description } : {}) });
-    const globalAgentDefinitions = loadAgentDefinitions(context.cwd, context.agentDir, false, registry && typeof registry.roleDirectoryRegistrations === "function" ? registry.roleDirectoryRegistrations() : registry && typeof registry.roleDirectories === "function" ? registry.roleDirectories() : undefined);
-    const projectAgentDefinitions = context.projectTrusted ? loadProjectAgentDefinitions(context.cwd) : {};
-    const agentDefinitions = deepFreeze({ ...globalAgentDefinitions, ...projectAgentDefinitions });
-    const aliases = context.modelAliases ?? {};
-    const knownModels = context.knownModels ?? context.availableModels;
-    const checked = preflight(script, { models: context.availableModels, tools: context.rootTools, agentTypes: new Set(Object.keys(agentDefinitions)), modelAliases: aliases, knownModels, ...(context.settingsPath ? { settingsPath: context.settingsPath } : {}) }, [], metadata);
-    const roleNames = checked.dynamicAgentRoles ? Object.keys(agentDefinitions) : checked.referenced.agentTypes;
-    validateRolePolicies(agentDefinitions, roleNames, context.availableModels, aliases, knownModels, context.settingsPath);
-    if (registry?.validateExtensionSettings) {
-        const validate = registry.validateExtensionSettings.bind(registry);
-        const validatorContext = (source, role) => ({ source, cwd: context.cwd, projectTrusted: context.projectTrusted, ...(context.settingsPath ? { settingsPath: context.settingsPath } : {}), ...(role === undefined ? {} : { role }) });
-        validate(context.extensionSettings, validatorContext("effective"));
-        for (const role of roleNames) {
-            validate(mergeWorkflowExtensionSettings(context.extensionSettings, agentDefinitions[role]?.extensionSettings), validatorContext("role", role));
-        }
-    }
-    return { script, checked, agentDefinitions, projectAgentDefinitions, roleNames };
+    const checked = preflight(script, { models: context.availableModels, tools: context.rootTools, modelAliases: context.modelAliases ?? {}, knownModels: context.knownModels ?? context.availableModels, ...(context.settingsPath ? { settingsPath: context.settingsPath } : {}) }, [], metadata);
+    registry?.validateExtensionSettings(context.extensionSettings, { source: "effective", cwd: context.cwd, projectTrusted: context.projectTrusted, ...(context.settingsPath ? { settingsPath: context.settingsPath } : {}) });
+    return { script, checked };
 }
 export { createLaunchSnapshot, loadLaunchSnapshot } from "./utils.js";

package/dist/starter/index.js

@@ -20,23 +20,23 @@ var reviewLoop = defineWorkflowFunction({
     );
     let devResult = null;
     let review = { pass: false, findings: [] };
+    const developer = agent.create({ name: "developer", label: "Developer", role: "developer" });
     for (let iterations = 1; iterations <= maxIterations; iterations += 1) {
       const devPrompt = iterations === 1 ? prompt("Implement this task:\n\n{task}", { task }) : prompt(
-        `Address the previous review findings and complete the task.
-<original_task>{task}</original_task>
+        `Address the latest review findings and complete the original task.
 <last_review>{review}</last_review>`,
-        { task, review: review.findings }
+        { review: review.findings }
       );
-      devResult = await agent(devPrompt, { role: "developer" });
+      devResult = await developer.send(devPrompt);
       review = await agent(
         prompt(
-          `Review the implementation against the task. Set pass=true only when the task is complete and correct. The developer may have addressed a previous review run of yours. So its summary is related to the last round of review if present.
+          `Review the actual current implementation against the entire original task. Inspect the code and run relevant checks yourself. Do not rely on the developer summary or on previous findings; they may be incomplete or wrong. Set pass=true only when the whole task is complete and correct.
 <original_task>{task}</original_task>
-<last_review>{review}</last_review>
+<previous_review_findings>{review}</previous_review_findings>
 <dev_summary>{devResult}</dev_summary>`,
           { task, devResult, review: review.findings }
         ),
-        { role: "reviewer", outputSchema: reviewSchema }
+        { label: `Reviewer ${String(iterations)}`, role: "reviewer", outputSchema: reviewSchema }
       );
       if (review.pass) return { pass: true, iterations, devResult, review };
     }
@@ -89,8 +89,7 @@ var extension = {
     "researcher-model": {
       resolve: ({ rootModel }) => `${rootModel.provider}/${rootModel.model}`
     }
-  },
-  roleDirectories: [new URL("./roles/", import.meta.url)]
+  }
 };
 function starter_default() {
   registerWorkflowExtension(extension);

package/dist/starter/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../starter/index.ts", "../../starter/review-loop.ts"],
-  "mappings": "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",
+  "mappings": "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",
   "names": []
 }

package/dist/starter/review-loop.js

@@ -9,17 +9,18 @@ export const reviewLoop = defineWorkflowFunction({
         }, { additionalProperties: false });
         let devResult = null;
         let review = { pass: false, findings: [] };
+        // One developer keeps its transcript across iterations; each reviewer starts fresh.
+        const developer = agent.create({ name: "developer", label: "Developer", role: "developer" });
         for (let iterations = 1; iterations <= maxIterations; iterations += 1) {
             const devPrompt = iterations === 1
                 ? prompt("Implement this task:\n\n{task}", { task })
-                : prompt(`Address the previous review findings and complete the task.
+                : prompt(`Address the latest review findings and complete the original task.
+<last_review>{review}</last_review>`, { review: review.findings });
+            devResult = await developer.send(devPrompt);
+            review = await agent(prompt(`Review the actual current implementation against the entire original task. Inspect the code and run relevant checks yourself. Do not rely on the developer summary or on previous findings; they may be incomplete or wrong. Set pass=true only when the whole task is complete and correct.
 <original_task>{task}</original_task>
-<last_review>{review}</last_review>`, { task, review: review.findings });
-            devResult = await agent(devPrompt, { role: "developer" });
-            review = await agent(prompt(`Review the implementation against the task. Set pass=true only when the task is complete and correct. The developer may have addressed a previous review run of yours. So its summary is related to the last round of review if present.
-<original_task>{task}</original_task>
-<last_review>{review}</last_review>
-<dev_summary>{devResult}</dev_summary>`, { task, devResult, review: review.findings }), { role: "reviewer", outputSchema: reviewSchema });
+<previous_review_findings>{review}</previous_review_findings>
+<dev_summary>{devResult}</dev_summary>`, { task, devResult, review: review.findings }), { label: `Reviewer ${String(iterations)}`, role: "reviewer", outputSchema: reviewSchema });
             if (review.pass)
                 return { pass: true, iterations, devResult, review };
         }