patchwork-os 0.2.0-alpha.27 → 0.2.0-alpha.29

package/dist/commands/recipe.js

@@ -7,16 +7,16 @@ import { existsSync, mkdirSync, readFileSync, statSync, watch, writeFileSync, }
 import os from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Ajv } from "ajv";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import "../recipes/tools/index.js";
 import { loadFixtureLibrary } from "../connectors/fixtureLibrary.js";
 import { MockConnector } from "../connectors/mockConnector.js";
-import { FLAG_SCHEMA_LINT, isEnabled } from "../featureFlags.js";
 import { normalizeRecipeForRuntime } from "../recipes/legacyRecipeCompat.js";
 import { generateSchemaSet, writeSchemas } from "../recipes/schemaGenerator.js";
-import { getTool, isConnectorNamespace, listToolOutputContextKeys, seedToolOutputPreviewContext, } from "../recipes/toolRegistry.js";
+import { getTool, isConnectorNamespace, seedToolOutputPreviewContext, } from "../recipes/toolRegistry.js";
+import { validateRecipeDefinition, } from "../recipes/validation.js";
 import { buildChainedDeps, dispatchRecipe, loadYamlRecipe, render, runYamlRecipe, } from "../recipes/yamlRunner.js";
+import { findYamlRecipePath } from "../recipesHttp.js";
 const RECIPES_DIR = join(os.homedir(), ".patchwork", "recipes");
 const FIXTURES_DIR = join(os.homedir(), ".patchwork", "fixtures");
 const RECIPE_SCHEMA_HEADER = "# yaml-language-server: $schema=https://patchworkos.com/schema/recipe.v1.json";
@@ -133,7 +133,6 @@ export async function runSchema(outputDir) {
  * Falls back to basic YAML parsing if schema linting is disabled.
  */
 export function runLint(recipePath) {
-    const issues = [];
     // Check file exists
     if (!existsSync(recipePath)) {
         return {
@@ -143,9 +142,7 @@ export function runLint(recipePath) {
             errors: 1,
         };
     }
-    // Read and parse
     let content;
-    let recipe;
     try {
         content = readFileSync(recipePath, "utf-8");
     }
@@ -162,8 +159,9 @@ export function runLint(recipePath) {
             errors: 1,
         };
     }
+    let parsed;
     try {
-        recipe = parseYaml(content);
+        parsed = parseYaml(content);
     }
     catch (err) {
         return {
@@ -178,427 +176,147 @@ export function runLint(recipePath) {
             errors: 1,
         };
     }
-    const normalizedRecipe = normalizeRecipeForValidation(recipe);
-    // Basic structural validation
-    if (!normalizedRecipe || typeof normalizedRecipe !== "object") {
-        issues.push({ level: "error", message: "Recipe must be a YAML object" });
-    }
-    else {
-        const r = normalizedRecipe;
-        // Required fields
-        if (!r.name || typeof r.name !== "string") {
-            issues.push({
-                level: "error",
-                message: "Missing or invalid 'name' field",
-            });
+    const result = validateRecipeDefinition(parsed);
+    // For chained recipes, check that chain: file references resolve on disk.
+    const chainIssues = lintChainRefs(parsed, recipePath);
+    if (chainIssues.length > 0) {
+        result.issues.push(...chainIssues);
+        result.errors += chainIssues.filter((i) => i.level === "error").length;
+        result.warnings += chainIssues.filter((i) => i.level === "warning").length;
+        if (result.errors > 0) {
+            result.valid = false;
         }
-        else if (!/^[a-z0-9-]+$/.test(r.name)) {
-            issues.push({
-                level: "warning",
-                message: "Recipe name should use kebab-case (lowercase letters, numbers, hyphens)",
-            });
-        }
-        if (!r.description || typeof r.description !== "string") {
-            issues.push({ level: "warning", message: "Missing 'description' field" });
+    }
+    return result;
+}
+/**
+ * Walk chained recipe steps, check that chain:/recipe: refs resolve on disk,
+ * and recursively lint any child recipe that does resolve.
+ *
+ * `visited` tracks absolute paths already linted in this call chain to prevent
+ * infinite recursion when two recipes chain each other.
+ */
+function lintChainRefs(parsed, recipePath, visited = new Set()) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    const r = parsed;
+    const trigger = r.trigger && typeof r.trigger === "object"
+        ? r.trigger
+        : undefined;
+    if (trigger?.type !== "chained")
+        return [];
+    const steps = Array.isArray(r.steps)
+        ? r.steps
+        : [];
+    const recipeDir = dirname(recipePath);
+    const issues = [];
+    // Mark the current recipe as visited before descending.
+    const absPath = resolve(recipePath);
+    visited.add(absPath);
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (!step)
+            continue;
+        issues.push(...lintStep(step, i + 1, recipeDir, visited));
+    }
+    return issues;
+}
+/**
+ * Check a single step (or recurse into its parallel: children).
+ * `stepLabel` is the 1-based position string used in issue messages.
+ */
+function lintStep(step, stepLabel, recipeDir, visited) {
+    const issues = [];
+    // Recurse into parallel: groups — each child is checked independently.
+    if (Array.isArray(step.parallel)) {
+        for (let j = 0; j < step.parallel.length; j++) {
+            const child = step.parallel[j];
+            if (!child || typeof child !== "object" || Array.isArray(child))
+                continue;
+            issues.push(...lintStep(child, stepLabel, recipeDir, visited));
         }
-        if (!r.trigger || typeof r.trigger !== "object") {
+        return issues;
+    }
+    const ref = typeof step.chain === "string"
+        ? step.chain
+        : typeof step.recipe === "string"
+            ? step.recipe
+            : null;
+    if (!ref)
+        return issues;
+    const field = typeof step.chain === "string" ? "chain" : "recipe";
+    // Refs that look like file paths (extension or separator) → resolve relative to recipe dir.
+    const looksLikePath = /\.ya?ml$/i.test(ref) ||
+        ref.startsWith("./") ||
+        ref.startsWith("../") ||
+        /[\\/]/.test(ref);
+    if (looksLikePath) {
+        const resolved = /^\//.test(ref) ? ref : resolve(recipeDir, ref);
+        const candidates = /\.ya?ml$/i.test(resolved)
+            ? [resolved]
+            : [`${resolved}.yaml`, `${resolved}.yml`, resolved];
+        const childPath = candidates.find(existsSync) ?? null;
+        if (!childPath) {
             issues.push({
                 level: "error",
-                message: "Missing or invalid 'trigger' field",
+                message: `Step ${stepLabel}: '${field}: ${ref}' — file not found relative to recipe directory (${recipeDir})`,
             });
+            return issues;
         }
-        else {
-            const trigger = r.trigger;
-            const validTypes = [
-                "manual",
-                "cron",
-                "webhook",
-                "file_watch",
-                "git_hook",
-                "on_file_save",
-                "on_test_run",
-                "chained",
-            ];
-            if (!trigger.type || !validTypes.includes(trigger.type)) {
-                issues.push({
-                    level: "error",
-                    message: `Invalid trigger.type. Must be one of: ${validTypes.join(", ")}`,
-                });
-            }
-            if (trigger.type === "cron" && !trigger.at) {
-                issues.push({
-                    level: "warning",
-                    message: "cron trigger should have 'at' (cron expression)",
-                });
-            }
-        }
-        if (!Array.isArray(r.steps) || r.steps.length === 0) {
+        issues.push(...lintChildRecipe(childPath, field, ref, stepLabel, visited));
+        return issues;
+    }
+    // Named ref (no extension, no separator) → check ~/.patchwork/recipes/.
+    // Emit a warning rather than error: the recipe may be installed on the
+    // deploy target but not the author's machine.
+    if (existsSync(RECIPES_DIR)) {
+        const found = findYamlRecipePath(RECIPES_DIR, ref) ??
+            (existsSync(join(RECIPES_DIR, ref)) ? join(RECIPES_DIR, ref) : null);
+        if (!found) {
             issues.push({
-                level: "error",
-                message: "Recipe must have at least one step",
+                level: "warning",
+                message: `Step ${stepLabel}: '${field}: ${ref}' — recipe not found in ${RECIPES_DIR}`,
             });
         }
         else {
-            const triggerType = r.trigger && typeof r.trigger === "object"
-                ? r.trigger.type
-                : undefined;
-            const allowNestedRecipeSteps = triggerType === "chained";
-            // Validate each step
-            for (let i = 0; i < r.steps.length; i++) {
-                const step = r.steps[i];
-                const hasTool = typeof step.tool === "string";
-                const hasAgent = !!step.agent;
-                const hasNestedRecipe = allowNestedRecipeSteps && typeof step.recipe === "string";
-                if (!hasTool && !hasAgent && !hasNestedRecipe) {
-                    issues.push({
-                        level: "error",
-                        message: `Step ${i + 1}: Must have 'tool' or 'agent' field${allowNestedRecipeSteps ? " (or 'recipe' for chained recipes)" : ""}`,
-                    });
-                }
-                if (step.agent && typeof step.agent === "object") {
-                    const agent = step.agent;
-                    if (!agent.prompt || typeof agent.prompt !== "string") {
-                        issues.push({
-                            level: "error",
-                            message: `Step ${i + 1}: Agent step missing 'prompt'`,
-                        });
-                    }
-                }
-            }
-            validateTemplateReferences(r, issues);
+            issues.push(...lintChildRecipe(found, field, ref, stepLabel, visited));
         }
     }
-    // Schema-based validation (if enabled)
-    if (isEnabled(FLAG_SCHEMA_LINT)) {
-        issues.push(...validateRecipeSchema(normalizedRecipe));
-    }
-    const errors = issues.filter((i) => i.level === "error").length;
-    const warnings = issues.filter((i) => i.level === "warning").length;
-    return {
-        valid: errors === 0,
-        issues,
-        warnings,
-        errors,
-    };
+    return issues;
 }
-function normalizeRecipeForValidation(recipe) {
-    const normalized = normalizeRecipeForRuntime(recipe);
-    if (!normalized ||
-        typeof normalized !== "object" ||
-        Array.isArray(normalized)) {
-        return normalized;
-    }
-    const validationReady = {
-        ...normalized,
-    };
-    if (validationReady.trigger &&
-        typeof validationReady.trigger === "object" &&
-        !Array.isArray(validationReady.trigger)) {
-        validationReady.trigger = normalizeValidationTrigger(validationReady.trigger);
-    }
-    if (Array.isArray(validationReady.steps)) {
-        validationReady.steps = flattenValidationSteps(validationReady.steps);
-    }
-    return validationReady;
-}
-function normalizeValidationTrigger(trigger) {
-    const normalized = { ...trigger };
-    if (normalized.type === "event") {
-        normalized.type = "webhook";
-        normalized.legacyType = "event";
-        if (typeof normalized.on === "string") {
-            normalized.eventSource = normalized.on;
-        }
-        delete normalized.on;
-        if (normalized.filter !== undefined &&
-            typeof normalized.filter !== "string") {
-            normalized.eventFilter = normalized.filter;
-            delete normalized.filter;
-        }
-        if (normalized.lead_time_hours !== undefined) {
-            normalized.eventLeadTimeHours = normalized.lead_time_hours;
-            delete normalized.lead_time_hours;
-        }
-        if (normalized.lead_time_minutes !== undefined) {
-            normalized.eventLeadTimeMinutes = normalized.lead_time_minutes;
-            delete normalized.lead_time_minutes;
-        }
-    }
-    return normalized;
-}
-function flattenValidationSteps(steps) {
-    const normalizedSteps = [];
-    for (const step of steps) {
-        normalizedSteps.push(...flattenValidationStep(step));
-    }
-    return normalizedSteps;
-}
-function flattenValidationStep(step) {
-    if (!step || typeof step !== "object" || Array.isArray(step)) {
-        return [step];
-    }
-    const record = step;
-    if (Array.isArray(record.parallel)) {
-        const parallelSteps = [];
-        for (const nestedStep of record.parallel) {
-            parallelSteps.push(...flattenValidationStep(nestedStep));
-        }
-        return parallelSteps;
-    }
-    if (Array.isArray(record.branch)) {
-        const branchSteps = [];
-        for (const branchStep of record.branch) {
-            if (!branchStep ||
-                typeof branchStep !== "object" ||
-                Array.isArray(branchStep)) {
-                continue;
-            }
-            const branchRecord = branchStep;
-            const otherwiseStep = branchRecord.otherwise;
-            if (otherwiseStep &&
-                typeof otherwiseStep === "object" &&
-                !Array.isArray(otherwiseStep)) {
-                branchSteps.push(...flattenValidationStep(otherwiseStep));
-                continue;
-            }
-            branchSteps.push(...flattenValidationStep(branchRecord));
-        }
-        return branchSteps.length > 0 ? branchSteps : [record];
-    }
-    return [record];
-}
-function validateRecipeSchema(recipe) {
+/**
+ * Read, parse, and validate a resolved child recipe path. Skips the file if
+ * it has already been visited (cycle). Issues are prefixed with the parent
+ * step context so the author knows where the problem originates.
+ */
+function lintChildRecipe(childPath, field, ref, stepNumber, visited) {
+    const absChild = resolve(childPath);
+    if (visited.has(absChild))
+        return []; // cycle — already linted
+    let childParsed;
     try {
-        const schemas = generateSchemaSet();
-        const ajv = new Ajv({ strict: false, allErrors: true });
-        for (const schema of Object.values(schemas.namespaces)) {
-            ajv.addSchema(schema);
-        }
-        const validate = ajv.compile(schemas.recipe);
-        const valid = validate(recipe);
-        if (valid) {
-            return [];
-        }
-        return (validate.errors ?? []).map(toSchemaLintIssue);
+        childParsed = parseYaml(readFileSync(childPath, "utf-8"));
     }
     catch (err) {
         return [
             {
                 level: "error",
-                message: `Schema validation failed to initialize: ${err instanceof Error ? err.message : String(err)}`,
+                message: `Step ${stepNumber}: '${field}: ${ref}' — could not read child recipe: ${err instanceof Error ? err.message : String(err)}`,
             },
         ];
     }
-}
-function registerRecipeContextKeys(recipe, availableKeys) {
-    const trigger = recipe.trigger && typeof recipe.trigger === "object"
-        ? recipe.trigger
-        : undefined;
-    if (trigger?.type === "git_hook") {
-        availableKeys.add("hash");
-        availableKeys.add("message");
-        availableKeys.add("branch");
-    }
-    if (trigger?.type === "on_file_save") {
-        availableKeys.add("file");
-    }
-    if (trigger?.type === "on_test_run") {
-        availableKeys.add("runner");
-        availableKeys.add("failed");
-        availableKeys.add("passed");
-        availableKeys.add("total");
-        availableKeys.add("failures");
-    }
-    if (trigger?.legacyType === "event") {
-        availableKeys.add("event");
-    }
-    if (Array.isArray(trigger?.vars)) {
-        for (const item of trigger.vars) {
-            if (item && typeof item === "object" && typeof item.name === "string") {
-                availableKeys.add(item.name);
-            }
-        }
-    }
-    if (Array.isArray(trigger?.inputs)) {
-        for (const item of trigger.inputs) {
-            if (item && typeof item === "object" && typeof item.name === "string") {
-                availableKeys.add(item.name);
-            }
-        }
-    }
-    if (Array.isArray(recipe.context)) {
-        for (const block of recipe.context) {
-            if (!block || typeof block !== "object") {
-                continue;
-            }
-            const typedBlock = block;
-            if (typedBlock.type === "env" && Array.isArray(typedBlock.keys)) {
-                for (const key of typedBlock.keys) {
-                    if (typeof key === "string") {
-                        availableKeys.add(key);
-                    }
-                }
-            }
-        }
-    }
-}
-function toSchemaLintIssue(error) {
-    const path = error.instancePath
-        ? error.instancePath.slice(1).replace(/\//g, ".")
-        : "recipe";
-    return {
-        level: "error",
-        message: `Schema validation: ${path} ${error.message ?? "is invalid"}`,
-    };
-}
-function validateTemplateReferences(recipe, issues) {
-    const BUILTIN_KEYS = new Set([
-        "date",
-        "time",
-        "YYYY-MM",
-        "YYYY-MM-DD",
-        "ISO_NOW",
-    ]);
-    const availableKeys = new Set(BUILTIN_KEYS);
-    registerRecipeContextKeys(recipe, availableKeys);
-    const triggerType = recipe.trigger && typeof recipe.trigger === "object"
-        ? recipe.trigger.type
-        : undefined;
-    const isChainedRecipe = triggerType === "chained";
-    const steps = Array.isArray(recipe.steps)
-        ? recipe.steps
-        : [];
-    // Track all `into` keys produced so far for duplicate detection
-    const seenIntoKeys = new Map(); // key → first step (1-indexed)
-    for (let index = 0; index < steps.length; index++) {
-        const step = steps[index] ?? {};
-        const templates = collectRenderedTemplates(step, isChainedRecipe);
-        for (const template of templates) {
-            for (const expression of extractTemplateExpressions(template.value)) {
-                for (const identifier of extractTemplateIdentifiers(expression)) {
-                    if (!availableKeys.has(identifier)) {
-                        issues.push({
-                            level: "error",
-                            message: `Step ${index + 1}: Unknown template reference '{{${expression}}}' in ${template.label}`,
-                        });
-                        break;
-                    }
-                }
-            }
-        }
-        // Validate the `into` key produced by this step
-        const intoKey = resolveStepIntoKey(step, isChainedRecipe);
-        if (intoKey) {
-            if (BUILTIN_KEYS.has(intoKey)) {
-                issues.push({
-                    level: "error",
-                    message: `Step ${index + 1}: 'into: ${intoKey}' shadows a built-in context key`,
-                });
-            }
-            else {
-                const firstSeen = seenIntoKeys.get(intoKey);
-                if (firstSeen !== undefined) {
-                    issues.push({
-                        level: "warning",
-                        message: `Step ${index + 1}: 'into: ${intoKey}' overwrites value already written by step ${firstSeen}`,
-                    });
-                }
-                else {
-                    seenIntoKeys.set(intoKey, index + 1);
-                }
-            }
-        }
-        registerStepContextKeys(step, availableKeys, isChainedRecipe);
-    }
-}
-/** Return the context key a step writes to (its `into` value), or null. */
-function resolveStepIntoKey(step, isChainedRecipe) {
-    if (step.agent && typeof step.agent === "object") {
-        const agent = step.agent;
-        return typeof agent.into === "string" ? agent.into : "agent_output";
-    }
-    if (typeof step.into === "string")
-        return step.into;
-    if (isChainedRecipe && typeof step.id === "string")
-        return step.id;
-    return null;
-}
-function collectRenderedTemplates(step, isChainedRecipe) {
-    const templates = [];
-    for (const [key, value] of Object.entries(step)) {
-        if (key === "tool" || key === "into" || key === "agent") {
-            continue;
-        }
-        if (typeof value === "string") {
-            templates.push({ label: key, value });
-        }
-    }
-    if (step.agent && typeof step.agent === "object") {
-        const agent = step.agent;
-        if (typeof agent.prompt === "string") {
-            templates.push({ label: "agent.prompt", value: agent.prompt });
-        }
-    }
-    if (isChainedRecipe && step.vars && typeof step.vars === "object") {
-        for (const [key, value] of Object.entries(step.vars)) {
-            if (typeof value === "string") {
-                templates.push({ label: `vars.${key}`, value });
-            }
-        }
-    }
-    return templates;
-}
-function extractTemplateExpressions(template) {
-    const matches = template.matchAll(/\{\{\s*([^}]+?)\s*\}\}/g);
-    const expressions = [];
-    for (const match of matches) {
-        const expression = match[1]?.trim();
-        if (expression) {
-            expressions.push(expression);
-        }
-    }
-    return expressions;
-}
-function extractTemplateIdentifiers(expression) {
-    const reserved = new Set(["true", "false", "null"]);
-    const identifiers = new Set();
-    for (const match of expression.matchAll(/[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]+)*/g)) {
-        const rawIdentifier = match[0];
-        if (!rawIdentifier) {
-            continue;
-        }
-        const rootIdentifier = rawIdentifier.split(".")[0] ?? rawIdentifier;
-        if (!reserved.has(rootIdentifier)) {
-            identifiers.add(rootIdentifier);
-        }
-    }
-    return Array.from(identifiers);
-}
-function registerStepContextKeys(step, availableKeys, isChainedRecipe = false) {
-    if (isChainedRecipe) {
-        const stepId = typeof step.id === "string" ? step.id : undefined;
-        if (stepId) {
-            availableKeys.add(stepId);
-        }
-    }
-    if (step.agent && typeof step.agent === "object") {
-        const agent = step.agent;
-        const intoKey = typeof agent.into === "string" ? agent.into : "agent_output";
-        availableKeys.add(intoKey);
-        return;
-    }
-    const intoKey = typeof step.into === "string" ? step.into : undefined;
-    if (!intoKey) {
-        return;
-    }
-    availableKeys.add(intoKey);
-    const toolId = typeof step.tool === "string" ? step.tool : undefined;
-    if (!toolId) {
-        return;
-    }
-    for (const key of listToolOutputContextKeys(toolId, intoKey)) {
-        availableKeys.add(key);
-    }
+    const childResult = validateRecipeDefinition(childParsed);
+    const childChainIssues = lintChainRefs(childParsed, childPath, visited);
+    return [
+        ...childResult.issues.map((issue) => ({
+            ...issue,
+            message: `Step ${stepNumber}: '${field}: ${ref}' — child recipe invalid: ${issue.message}`,
+        })),
+        ...childChainIssues.map((issue) => ({
+            ...issue,
+            message: `Step ${stepNumber}: '${field}: ${ref}' — ${issue.message}`,
+        })),
+    ];
 }
 /**
  * Format/normalize a recipe file.
@@ -696,6 +414,7 @@ export async function runRecipe(recipeRef, options = {}) {
     const result = await dispatchRecipe(recipeToRun, {
         ...runnerDeps,
         chainedDeps: buildChainedDeps(runnerDeps),
+        chainedOptions: { sourcePath: recipePath },
     }, options.vars ?? {});
     return {
         recipe,
@@ -730,6 +449,68 @@ export function summarizeRecipeExecution(result) {
         skipped: result.summary.skipped,
     };
 }
+/**
+ * Normalize either a yamlRunner RunResult or a chainedRunner ChainedRunResult
+ * into the RunStepResult[] shape expected by RecipeRunLog.appendDirect.
+ * Returns undefined when the result has no step-level detail.
+ */
+export function extractRunLogStepResults(result) {
+    if ("stepsRun" in result) {
+        // yamlRunner: stepResults is already StepResult[]
+        if (!Array.isArray(result.stepResults))
+            return undefined;
+        return result.stepResults.map((s) => ({
+            id: s.id,
+            ...(s.tool ? { tool: s.tool } : {}),
+            status: s.status,
+            ...(s.error ? { error: s.error } : {}),
+            durationMs: s.durationMs,
+        }));
+    }
+    // chainedRunner: stepResults is Map<string, ChainedStepRunResult>
+    return [...result.stepResults.entries()].map(([id, s]) => ({
+        id,
+        status: s.skipped ? "skipped" : s.success ? "ok" : "error",
+        durationMs: s.durationMs ?? 0,
+        ...(s.error ? { error: s.error.message } : {}),
+    }));
+}
+export function formatRunReport(result, recipeName) {
+    const lines = [];
+    const hr = "─".repeat(48);
+    if ("stepsRun" in result) {
+        // Simple (non-chained) recipe — compact summary
+        const ok = !result.errorMessage;
+        lines.push(`${ok ? "✓" : "✗"} ${recipeName} — ${result.stepsRun} step(s)`);
+        if (result.outputs.length > 0) {
+            for (const o of result.outputs)
+                lines.push(`  → ${o}`);
+        }
+        if (result.errorMessage)
+            lines.push(`  Error: ${result.errorMessage}`);
+        return lines.join("\n");
+    }
+    // Chained recipe — per-step table
+    const { stepResults, summary } = result;
+    const overallOk = result.success;
+    lines.push(hr);
+    lines.push(`Recipe: ${recipeName}`);
+    lines.push(hr);
+    for (const [id, step] of stepResults) {
+        const icon = step.skipped ? "↷" : step.success ? "✓" : "✗";
+        const dur = step.durationMs !== undefined ? ` (${step.durationMs}ms)` : "";
+        const err = step.error ? `  → ${step.error.message}` : "";
+        lines.push(`  ${icon} ${id}${dur}${err}`);
+    }
+    lines.push(hr);
+    const parts = [`${summary.succeeded} ok`];
+    if (summary.skipped > 0)
+        parts.push(`${summary.skipped} skipped`);
+    if (summary.failed > 0)
+        parts.push(`${summary.failed} failed`);
+    lines.push(`${overallOk ? "✓" : "✗"} ${parts.join(" · ")}`);
+    return lines.join("\n");
+}
 export async function runWatchedRecipe(recipePath, options = {}) {
     const lint = runLint(recipePath);
     if (!lint.valid) {
@@ -1117,34 +898,70 @@ export async function runTest(recipePath, options = {}) {
     if (issues.every((issue) => issue.level !== "error")) {
         try {
             const recipe = loadYamlRecipe(recipePath);
-            const mockConnectors = createMockToolConnectors(recipe.steps, fixturesDir);
-            const run = await runYamlRecipe(recipe, {
-                testMode: true,
-                mockConnectors,
-                readFile: (filePath) => readFileSync(filePath, "utf-8"),
-                writeFile: () => { },
-                appendFile: () => { },
-                mkdir: () => { },
-                gitLogSince: () => "[mock git log]",
-                gitStaleBranches: () => "[mock stale branches]",
-                getDiagnostics: () => "[mock diagnostics]",
-                claudeFn: async () => "[mock agent output]",
-                claudeCodeFn: async () => "[mock agent output]",
-                providerDriverFn: async () => "[mock agent output]",
-            });
-            stepsRun = run.stepsRun;
-            outputs = run.outputs;
-            if (run.assertionFailures && run.assertionFailures.length > 0) {
-                assertionFailures = run.assertionFailures;
-                for (const failure of run.assertionFailures) {
-                    issues.push({ level: "error", message: failure.message });
+            const triggerType = recipe.trigger?.type;
+            if (triggerType === "chained") {
+                // Chained recipes: run through chainedRunner with mocked tool + agent executors
+                const { runChainedRecipe } = await import("../recipes/chainedRunner.js");
+                const { evaluateExpect } = await import("../recipes/yamlRunner.js");
+                const chainedRecipe = recipe;
+                const recipeRecord = recipe;
+                const run = await runChainedRecipe(chainedRecipe, {
+                    env: process.env,
+                    maxConcurrency: recipeRecord.maxConcurrency ?? 4,
+                    maxDepth: recipeRecord.maxDepth ?? 3,
+                    dryRun: false,
+                    sourcePath: recipePath,
+                }, {
+                    executeTool: async (tool) => `[mock:${tool}]`,
+                    executeAgent: async () => "[mock agent output]",
+                    loadNestedRecipe: async () => null,
+                });
+                stepsRun = run.summary.total;
+                if (run.errorMessage) {
+                    issues.push({ level: "error", message: run.errorMessage });
+                }
+                // Evaluate expect: block against chained run results
+                const expectBlock = recipeRecord.expect;
+                if (expectBlock) {
+                    const failures = evaluateExpect({
+                        stepsRun: run.summary.total,
+                        outputs: [],
+                        context: run.context,
+                        errorMessage: run.errorMessage,
+                    }, expectBlock);
+                    assertionFailures = failures;
+                    for (const failure of failures) {
+                        issues.push({ level: "error", message: failure.message });
+                    }
                 }
             }
-            if (run.errorMessage) {
-                issues.push({
-                    level: "error",
-                    message: run.errorMessage,
+            else {
+                const mockConnectors = createMockToolConnectors(recipe.steps, fixturesDir);
+                const run = await runYamlRecipe(recipe, {
+                    testMode: true,
+                    mockConnectors,
+                    readFile: (filePath) => readFileSync(filePath, "utf-8"),
+                    writeFile: () => { },
+                    appendFile: () => { },
+                    mkdir: () => { },
+                    gitLogSince: () => "[mock git log]",
+                    gitStaleBranches: () => "[mock stale branches]",
+                    getDiagnostics: () => "[mock diagnostics]",
+                    claudeFn: async () => "[mock agent output]",
+                    claudeCodeFn: async () => "[mock agent output]",
+                    providerDriverFn: async () => "[mock agent output]",
                 });
+                stepsRun = run.stepsRun;
+                outputs = run.outputs;
+                if (run.assertionFailures && run.assertionFailures.length > 0) {
+                    assertionFailures = run.assertionFailures;
+                    for (const failure of run.assertionFailures) {
+                        issues.push({ level: "error", message: failure.message });
+                    }
+                }
+                if (run.errorMessage) {
+                    issues.push({ level: "error", message: run.errorMessage });
+                }
             }
         }
         catch (err) {