@quintinshaw/pi-dynamic-workflows 1.0.0

package/dist/deep-research.js

@@ -0,0 +1,110 @@
+/**
+ * Deep research workflow.
+ * Built-in workflow for comprehensive research across multiple sources.
+ */
+const DEFAULT_CONFIG = {
+    searchAngles: 4,
+    sourcesPerAngle: 3,
+    crossCheck: true,
+    maxAgents: 20,
+};
+/**
+ * Generate a deep research workflow script.
+ */
+export function generateDeepResearchWorkflow(question, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const escapedQuestion = question.replace(/'/g, "\\'").slice(0, 80);
+    const crossCheckPhase = cfg.crossCheck
+        ? `phase('Cross-Check');
+const crossCheck = await agent(
+  'Cross-check these research findings. Identify claims that are supported by multiple sources vs. claims that appear in only one source:\\n' +
+  'Sources: ' + JSON.stringify(sources),
+  { label: 'cross-checker' }
+);`
+        : "";
+    const crossCheckRef = cfg.crossCheck ? "'Cross-check: ' + crossCheck + '\\n' + " : "";
+    const crossCheckReturn = cfg.crossCheck ? "crossCheck, " : "";
+    return `export const meta = {
+  name: 'deep_research',
+  description: 'Deep research: ${escapedQuestion}',
+  phases: [
+    { title: 'Search Planning' },
+    { title: 'Source Gathering' },
+    { title: 'Cross-Check' },
+    { title: 'Report' },
+  ],
+};
+
+phase('Search Planning');
+const question = '${escapedQuestion}';
+const searchPlan = await agent(
+  'Plan ${cfg.searchAngles} different search angles to research this question comprehensively: ' + question,
+  { label: 'search-planner' }
+);
+
+phase('Source Gathering');
+const sources = await parallel(Array.from({ length: ${cfg.searchAngles} }, (_, i) => () =>
+  agent(
+    'Research angle ' + (i + 1) + ' for this question: ' + question + '\\n\\nPlan: ' + searchPlan + '\\n\\nFind and summarize ${cfg.sourcesPerAngle} relevant sources.',
+    { label: 'researcher-' + (i + 1) }
+  )
+));
+
+${crossCheckPhase}
+
+phase('Report');
+const report = await agent(
+  'Synthesize a comprehensive research report from these findings:\\n' +
+  'Question: ' + question + '\\n' +
+  'Sources: ' + JSON.stringify(sources) + '\\n' +
+  ${crossCheckRef}'\\n\\nProduce a well-structured report with citations and confidence levels.',
+  { label: 'report-writer' }
+);
+
+return { searchPlan, sources, ${crossCheckReturn}report };`;
+}
+/**
+ * Generate a codebase audit workflow.
+ */
+export function generateCodebaseAuditWorkflow(scope, checks) {
+    const escapedScope = scope.replace(/'/g, "\\'").slice(0, 60);
+    const checkAgents = checks
+        .map((check) => {
+        const label = check
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .slice(0, 20);
+        return `  () => agent('Audit ${check} across: ' + scope, { label: '${label}' }),`;
+    })
+        .join("\n");
+    return `export const meta = {
+  name: 'codebase_audit',
+  description: 'Codebase audit: ${escapedScope}',
+  phases: [
+    { title: 'Individual Checks' },
+    { title: 'Cross-Validation' },
+    { title: 'Report' },
+  ],
+};
+
+phase('Individual Checks');
+const scope = '${escapedScope}';
+const findings = await parallel([
+${checkAgents}
+]);
+
+phase('Cross-Validation');
+const validated = await agent(
+  'Cross-validate these audit findings. Remove false positives and confirm real issues:\\n' +
+  JSON.stringify(findings),
+  { label: 'validator' }
+);
+
+phase('Report');
+const report = await agent(
+  'Generate a prioritized audit report with actionable recommendations:\\n' + validated,
+  { label: 'report-writer' }
+);
+
+return { findings, validated, report };`;
+}

package/dist/display.d.ts

@@ -0,0 +1,62 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { WorkflowMeta } from "./workflow.js";
+export type WorkflowAgentStatus = "queued" | "running" | "done" | "error" | "skipped";
+export interface WorkflowAgentSnapshot {
+    id: number;
+    label: string;
+    phase?: string;
+    prompt: string;
+    status: WorkflowAgentStatus;
+    resultPreview?: string;
+    error?: string;
+    /** Tokens used by this agent. */
+    tokens?: number;
+}
+export interface WorkflowSnapshot {
+    name: string;
+    description?: string;
+    phases: string[];
+    currentPhase?: string;
+    logs: string[];
+    agents: WorkflowAgentSnapshot[];
+    agentCount: number;
+    runningCount: number;
+    doneCount: number;
+    errorCount: number;
+    durationMs?: number;
+    result?: unknown;
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    runId?: string;
+}
+export interface WorkflowDisplay {
+    update(snapshot: WorkflowSnapshot): void;
+    complete(snapshot: WorkflowSnapshot): void;
+    clear(): void;
+}
+export interface WorkflowDisplayOptions {
+    key?: string;
+    placement?: "aboveEditor" | "belowEditor";
+    maxAgents?: number;
+    maxLogs?: number;
+    showStatus?: boolean;
+    showResultPreviews?: boolean;
+}
+export declare function createWorkflowSnapshot(meta: WorkflowMeta): WorkflowSnapshot;
+export declare function recomputeWorkflowSnapshot(snapshot: WorkflowSnapshot): WorkflowSnapshot;
+export declare function createWidgetWorkflowDisplay(ctx: Pick<ExtensionContext, "ui" | "hasUI">, options?: WorkflowDisplayOptions): WorkflowDisplay;
+export declare function createToolUpdateWorkflowDisplay(onUpdate: ((result: {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: unknown;
+}) => void) | undefined, ctx?: Pick<ExtensionContext, "ui" | "hasUI">, options?: WorkflowDisplayOptions & {
+    streamToolUpdates?: boolean;
+}): WorkflowDisplay;
+export declare function renderWorkflowLines(snapshot: WorkflowSnapshot, options?: WorkflowDisplayOptions): string[];
+export declare function renderWorkflowText(snapshot: WorkflowSnapshot, completed?: boolean): string;
+export declare function preview(value: unknown, max?: number): string;

package/dist/display.js

@@ -0,0 +1,163 @@
+export function createWorkflowSnapshot(meta) {
+    return {
+        name: meta.name,
+        description: meta.description,
+        phases: meta.phases?.map((phase) => phase.title) ?? [],
+        logs: [],
+        agents: [],
+        agentCount: 0,
+        runningCount: 0,
+        doneCount: 0,
+        errorCount: 0,
+    };
+}
+export function recomputeWorkflowSnapshot(snapshot) {
+    const runningCount = snapshot.agents.filter((agent) => agent.status === "running").length;
+    const doneCount = snapshot.agents.filter((agent) => agent.status === "done").length;
+    const errorCount = snapshot.agents.filter((agent) => agent.status === "error").length;
+    return { ...snapshot, agentCount: snapshot.agents.length, runningCount, doneCount, errorCount };
+}
+export function createWidgetWorkflowDisplay(ctx, options = {}) {
+    const key = options.key ?? "workflow";
+    const placement = options.placement ?? "belowEditor";
+    const showStatus = options.showStatus ?? false;
+    const render = (snapshot, completed = false) => {
+        if (!ctx.hasUI)
+            return;
+        if (showStatus)
+            ctx.ui.setStatus(key, statusLine(snapshot, completed));
+        ctx.ui.setWidget(key, renderWorkflowLines(snapshot, options), { placement });
+    };
+    return {
+        update(snapshot) {
+            render(snapshot, false);
+        },
+        complete(snapshot) {
+            render(snapshot, true);
+        },
+        clear() {
+            if (!ctx.hasUI)
+                return;
+            if (showStatus)
+                ctx.ui.setStatus(key, undefined);
+            ctx.ui.setWidget(key, undefined);
+        },
+    };
+}
+export function createToolUpdateWorkflowDisplay(onUpdate, ctx, options = {}) {
+    const widget = ctx ? createWidgetWorkflowDisplay(ctx, options) : undefined;
+    const streamToolUpdates = options.streamToolUpdates ?? !ctx?.hasUI;
+    const emit = (snapshot, completed = false) => {
+        if (streamToolUpdates) {
+            onUpdate?.({
+                content: [{ type: "text", text: renderWorkflowText(snapshot, completed) }],
+                details: snapshot,
+            });
+        }
+        if (completed)
+            widget?.complete(snapshot);
+        else
+            widget?.update(snapshot);
+    };
+    return {
+        update(snapshot) {
+            emit(snapshot, false);
+        },
+        complete(snapshot) {
+            emit(snapshot, true);
+        },
+        clear() {
+            widget?.clear();
+        },
+    };
+}
+export function renderWorkflowLines(snapshot, options = {}) {
+    const maxAgents = options.maxAgents ?? 8;
+    const maxLogs = options.maxLogs ?? 2;
+    const showResultPreviews = options.showResultPreviews ?? false;
+    const state = snapshot.errorCount > 0
+        ? `, ${snapshot.errorCount} errors`
+        : snapshot.runningCount > 0
+            ? `, ${snapshot.runningCount} running`
+            : "";
+    // Build header with token info
+    const tokenInfo = snapshot.tokenUsage ? ` · ${snapshot.tokenUsage.total.toLocaleString()} tokens` : "";
+    const lines = [
+        `◆ Workflow: ${snapshot.name} (${snapshot.doneCount}/${snapshot.agentCount} done${state}${tokenInfo})`,
+    ];
+    const phaseNames = snapshot.phases.length
+        ? snapshot.phases
+        : unique(snapshot.agents.map((agent) => agent.phase).filter(Boolean));
+    const rendered = new Set();
+    for (const phase of phaseNames) {
+        const agents = snapshot.agents.filter((agent) => agent.phase === phase);
+        for (const agent of agents)
+            rendered.add(agent);
+        const done = agents.filter((agent) => agent.status === "done").length;
+        const running = agents.filter((agent) => agent.status === "running").length;
+        const errors = agents.filter((agent) => agent.status === "error").length;
+        const skipped = agents.filter((agent) => agent.status === "skipped").length;
+        const complete = agents.length > 0 && done + errors + skipped === agents.length;
+        const marker = running > 0 || (!complete && snapshot.currentPhase === phase) ? "▶" : complete ? "✓" : " ";
+        lines.push(`  ${marker} ${phase} ${done}/${agents.length}${running ? ` · ${running} running` : ""}${errors ? ` · ${errors} errors` : ""}${skipped ? ` · ${skipped} skipped` : ""}`);
+        const visibleAgents = agents.slice(-maxAgents);
+        for (const agent of visibleAgents) {
+            const order = `#${agent.id}`;
+            const result = showResultPreviews && agent.resultPreview ? ` — ${agent.resultPreview}` : "";
+            const agentTokens = agent.tokens ? ` [${agent.tokens.toLocaleString()} tok]` : "";
+            lines.push(`    ${order} ${statusIcon(agent.status)} ${shorten(agent.label, 48)}${agentTokens}${result}`);
+        }
+        if (agents.length > visibleAgents.length)
+            lines.push(`    … ${agents.length - visibleAgents.length} earlier agents`);
+    }
+    const unphased = snapshot.agents.filter((agent) => !rendered.has(agent));
+    if (unphased.length) {
+        lines.push("  Unphased");
+        for (const agent of unphased.slice(-maxAgents)) {
+            const result = showResultPreviews && agent.resultPreview ? ` — ${agent.resultPreview}` : "";
+            const agentTokens = agent.tokens ? ` [${agent.tokens.toLocaleString()} tok]` : "";
+            lines.push(`    #${agent.id} ${statusIcon(agent.status)} ${shorten(agent.label, 48)}${agentTokens}${result}`);
+        }
+    }
+    for (const log of snapshot.logs.slice(-maxLogs))
+        lines.push(`  log: ${log}`);
+    return lines;
+}
+export function renderWorkflowText(snapshot, completed = false) {
+    const header = completed ? "Workflow completed" : "Workflow running";
+    return [header, ...renderWorkflowLines(snapshot)].join("\n");
+}
+function statusLine(snapshot, completed) {
+    if (completed)
+        return `workflow ✓ ${snapshot.name}: ${snapshot.doneCount}/${snapshot.agentCount}`;
+    if (snapshot.runningCount > 0)
+        return `workflow ${snapshot.name}: ${snapshot.runningCount} running, ${snapshot.doneCount}/${snapshot.agentCount} done`;
+    return `workflow ${snapshot.name}: ${snapshot.doneCount}/${snapshot.agentCount} done`;
+}
+function statusIcon(status) {
+    switch (status) {
+        case "queued":
+            return "○";
+        case "running":
+            return "●";
+        case "done":
+            return "✓";
+        case "error":
+            return "✗";
+        case "skipped":
+            return "-";
+    }
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function shorten(value, max) {
+    const text = value.replace(/\s+/g, " ").trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+export function preview(value, max = 80) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    if (!text)
+        return "";
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}

package/dist/errors.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Workflow-specific error types.
+ */
+export declare enum WorkflowErrorCode {
+    /** Agent exceeded timeout. */
+    AGENT_TIMEOUT = "AGENT_TIMEOUT",
+    /** Workflow was aborted by user. */
+    WORKFLOW_ABORTED = "WORKFLOW_ABORTED",
+    /** Agent limit exceeded. */
+    AGENT_LIMIT_EXCEEDED = "AGENT_LIMIT_EXCEEDED",
+    /** Token budget exhausted. */
+    TOKEN_BUDGET_EXHAUSTED = "TOKEN_BUDGET_EXHAUSTED",
+    /** Script validation failed. */
+    SCRIPT_VALIDATION_ERROR = "SCRIPT_VALIDATION_ERROR",
+    /** Agent execution failed. */
+    AGENT_EXECUTION_ERROR = "AGENT_EXECUTION_ERROR",
+    /** Run state persistence failed. */
+    PERSISTENCE_ERROR = "PERSISTENCE_ERROR",
+    /** Unknown error. */
+    UNKNOWN = "UNKNOWN"
+}
+export declare class WorkflowError extends Error {
+    readonly code: WorkflowErrorCode;
+    readonly recoverable: boolean;
+    readonly agentLabel?: string;
+    readonly details?: unknown;
+    constructor(message: string, code: WorkflowErrorCode, options?: {
+        recoverable?: boolean;
+        agentLabel?: string;
+        details?: unknown;
+    });
+}
+export declare function isWorkflowError(error: unknown): error is WorkflowError;
+export declare function isAbortError(error: unknown): boolean;
+export declare function isTimeoutError(error: unknown): boolean;
+/**
+ * Wrap an unknown error into a WorkflowError with appropriate classification.
+ */
+export declare function wrapError(error: unknown, context?: {
+    agentLabel?: string;
+}): WorkflowError;

package/dist/errors.js

@@ -0,0 +1,63 @@
+/**
+ * Workflow-specific error types.
+ */
+export var WorkflowErrorCode;
+(function (WorkflowErrorCode) {
+    /** Agent exceeded timeout. */
+    WorkflowErrorCode["AGENT_TIMEOUT"] = "AGENT_TIMEOUT";
+    /** Workflow was aborted by user. */
+    WorkflowErrorCode["WORKFLOW_ABORTED"] = "WORKFLOW_ABORTED";
+    /** Agent limit exceeded. */
+    WorkflowErrorCode["AGENT_LIMIT_EXCEEDED"] = "AGENT_LIMIT_EXCEEDED";
+    /** Token budget exhausted. */
+    WorkflowErrorCode["TOKEN_BUDGET_EXHAUSTED"] = "TOKEN_BUDGET_EXHAUSTED";
+    /** Script validation failed. */
+    WorkflowErrorCode["SCRIPT_VALIDATION_ERROR"] = "SCRIPT_VALIDATION_ERROR";
+    /** Agent execution failed. */
+    WorkflowErrorCode["AGENT_EXECUTION_ERROR"] = "AGENT_EXECUTION_ERROR";
+    /** Run state persistence failed. */
+    WorkflowErrorCode["PERSISTENCE_ERROR"] = "PERSISTENCE_ERROR";
+    /** Unknown error. */
+    WorkflowErrorCode["UNKNOWN"] = "UNKNOWN";
+})(WorkflowErrorCode || (WorkflowErrorCode = {}));
+export class WorkflowError extends Error {
+    code;
+    recoverable;
+    agentLabel;
+    details;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.name = "WorkflowError";
+        this.code = code;
+        this.recoverable = options.recoverable ?? false;
+        this.agentLabel = options.agentLabel;
+        this.details = options.details;
+    }
+}
+export function isWorkflowError(error) {
+    return error instanceof WorkflowError;
+}
+export function isAbortError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /\babort(?:ed)?\b/i.test(error.message);
+}
+export function isTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /\btimeout\b/i.test(error.message) || error.name === "TimeoutError";
+}
+/**
+ * Wrap an unknown error into a WorkflowError with appropriate classification.
+ */
+export function wrapError(error, context) {
+    if (isWorkflowError(error))
+        return error;
+    if (isAbortError(error)) {
+        return new WorkflowError(error instanceof Error ? error.message : "Workflow was aborted", WorkflowErrorCode.WORKFLOW_ABORTED, { recoverable: true });
+    }
+    if (isTimeoutError(error)) {
+        return new WorkflowError(error instanceof Error ? error.message : "Agent timed out", WorkflowErrorCode.AGENT_TIMEOUT, { recoverable: true, agentLabel: context?.agentLabel });
+    }
+    return new WorkflowError(error instanceof Error ? error.message : String(error), WorkflowErrorCode.AGENT_EXECUTION_ERROR, { recoverable: true, agentLabel: context?.agentLabel, details: error });
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export type { AdversarialReviewConfig } from "./adversarial-review.js";
+export { generateAdversarialReviewWorkflow, generateMultiPerspectiveWorkflow } from "./adversarial-review.js";
+export type { AgentRunOptions, AgentRunResult, WorkflowAgentOptions } from "./agent.js";
+export { WorkflowAgent } from "./agent.js";
+export type { AutoWorkflowConfig } from "./auto-workflow.js";
+export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
+export * from "./config.js";
+export type { DeepResearchConfig } from "./deep-research.js";
+export { generateCodebaseAuditWorkflow, generateDeepResearchWorkflow } from "./deep-research.js";
+export type { WorkflowAgentSnapshot, WorkflowAgentStatus, WorkflowDisplay, WorkflowDisplayOptions, WorkflowSnapshot, } from "./display.js";
+export { createToolUpdateWorkflowDisplay, createWidgetWorkflowDisplay, createWorkflowSnapshot, preview, recomputeWorkflowSnapshot, renderWorkflowLines, renderWorkflowText, } from "./display.js";
+export { isAbortError, isTimeoutError, isWorkflowError, WorkflowError, WorkflowErrorCode, wrapError, } from "./errors.js";
+export type { WorkflowLogger, WorkflowLoggerOptions } from "./logger.js";
+export { createWorkflowLogger } from "./logger.js";
+export type { ModelRoute, ModelRoutingConfig } from "./model-routing.js";
+export { buildModelRoutingInstructions, parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
+export type { PersistedRunState, RunPersistence, RunStatus } from "./run-persistence.js";
+export { createRunPersistence, generateRunId } from "./run-persistence.js";
+export type { StructuredOutputCapture, StructuredOutputToolOptions } from "./structured-output.js";
+export { createStructuredOutputTool } from "./structured-output.js";
+export type { AgentOptions, WorkflowMeta, WorkflowMetaPhase, WorkflowRunOptions, WorkflowRunResult, } from "./workflow.js";
+export { parseWorkflowScript, runWorkflow } from "./workflow.js";
+export type { ManagedRun, WorkflowManagerOptions } from "./workflow-manager.js";
+export { WorkflowManager } from "./workflow-manager.js";
+export type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
+export { createWorkflowStorage } from "./workflow-saved.js";
+export type { WorkflowToolInput, WorkflowToolOptions } from "./workflow-tool.js";
+export { createWorkflowTool } from "./workflow-tool.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+export { generateAdversarialReviewWorkflow, generateMultiPerspectiveWorkflow } from "./adversarial-review.js";
+export { WorkflowAgent } from "./agent.js";
+export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
+export * from "./config.js";
+export { generateCodebaseAuditWorkflow, generateDeepResearchWorkflow } from "./deep-research.js";
+export { createToolUpdateWorkflowDisplay, createWidgetWorkflowDisplay, createWorkflowSnapshot, preview, recomputeWorkflowSnapshot, renderWorkflowLines, renderWorkflowText, } from "./display.js";
+export { isAbortError, isTimeoutError, isWorkflowError, WorkflowError, WorkflowErrorCode, wrapError, } from "./errors.js";
+export { createWorkflowLogger } from "./logger.js";
+export { buildModelRoutingInstructions, parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
+export { createRunPersistence, generateRunId } from "./run-persistence.js";
+export { createStructuredOutputTool } from "./structured-output.js";
+export { parseWorkflowScript, runWorkflow } from "./workflow.js";
+export { WorkflowManager } from "./workflow-manager.js";
+export { createWorkflowStorage } from "./workflow-saved.js";
+export { createWorkflowTool } from "./workflow-tool.js";

package/dist/logger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Workflow logger with file persistence.
+ */
+export interface WorkflowLogger {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    getLogs(): string[];
+    persist(): string | null;
+}
+export interface WorkflowLoggerOptions {
+    /** Run ID for persistence. */
+    runId?: string;
+    /** Working directory for file paths. */
+    cwd?: string;
+    /** Whether to persist logs to disk. */
+    persist?: boolean;
+    /** Callback for each log entry. */
+    onLog?: (message: string) => void;
+}
+export declare function createWorkflowLogger(options?: WorkflowLoggerOptions): WorkflowLogger;

package/dist/logger.js

@@ -0,0 +1,67 @@
+/**
+ * Workflow logger with file persistence.
+ */
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { WORKFLOW_RUNS_DIR } from "./config.js";
+export function createWorkflowLogger(options = {}) {
+    const logs = [];
+    const persistLogs = options.persist ?? true;
+    const cwd = options.cwd ?? process.cwd();
+    const runId = options.runId ?? `run-${Date.now()}`;
+    let logFile = null;
+    const write = (level, message) => {
+        const timestamp = new Date().toISOString();
+        const entry = `[${timestamp}] [${level}] ${message}`;
+        logs.push(entry);
+        options.onLog?.(message);
+        if (persistLogs && logFile) {
+            try {
+                appendFileSync(logFile, `${entry}\n`);
+            }
+            catch {
+                // Silent fail for log persistence
+            }
+        }
+    };
+    const logger = {
+        log(message) {
+            write("INFO", message);
+        },
+        error(message) {
+            write("ERROR", message);
+        },
+        warn(message) {
+            write("WARN", message);
+        },
+        getLogs() {
+            return [...logs];
+        },
+        persist() {
+            if (!persistLogs)
+                return null;
+            try {
+                const runsDir = join(cwd, WORKFLOW_RUNS_DIR);
+                mkdirSync(runsDir, { recursive: true });
+                logFile = join(runsDir, `${runId}.log`);
+                writeFileSync(logFile, `${logs.join("\n")}\n`);
+                return logFile;
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+    // Initialize log file if persisting
+    if (persistLogs) {
+        try {
+            const runsDir = join(cwd, WORKFLOW_RUNS_DIR);
+            mkdirSync(runsDir, { recursive: true });
+            logFile = join(runsDir, `${runId}.log`);
+        }
+        catch {
+            // Silent fail
+        }
+    }
+    return logger;
+}

package/dist/model-routing.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Per-stage model routing for workflows.
+ * Allows different phases to use different models.
+ */
+export interface ModelRoute {
+    /** Phase name pattern (regex or exact match). */
+    phasePattern: string;
+    /** Model to use for this phase. */
+    model: string;
+    /** Whether to use regex matching. */
+    useRegex?: boolean;
+}
+export interface ModelRoutingConfig {
+    /** Default model for all phases. */
+    defaultModel?: string;
+    /** Per-phase model overrides. */
+    routes: ModelRoute[];
+}
+/**
+ * Resolve which model to use for a given phase.
+ */
+export declare function resolveModelForPhase(phase: string | undefined, config: ModelRoutingConfig): string | undefined;
+/**
+ * Build model routing instructions for a workflow agent.
+ */
+export declare function buildModelRoutingInstructions(phase: string | undefined, config: ModelRoutingConfig): string | undefined;
+/**
+ * Parse model routing from workflow meta phases.
+ */
+export declare function parseModelRoutingFromMeta(phases?: Array<{
+    title: string;
+    model?: string;
+}>): ModelRoutingConfig;

package/dist/model-routing.js

@@ -0,0 +1,57 @@
+/**
+ * Per-stage model routing for workflows.
+ * Allows different phases to use different models.
+ */
+/**
+ * Resolve which model to use for a given phase.
+ */
+export function resolveModelForPhase(phase, config) {
+    if (!phase || !config.routes.length) {
+        return config.defaultModel;
+    }
+    for (const route of config.routes) {
+        if (route.useRegex) {
+            try {
+                const regex = new RegExp(route.phasePattern, "i");
+                if (regex.test(phase)) {
+                    return route.model;
+                }
+            }
+            catch {
+                // Invalid regex, skip
+            }
+        }
+        else {
+            if (phase.toLowerCase().includes(route.phasePattern.toLowerCase())) {
+                return route.model;
+            }
+        }
+    }
+    return config.defaultModel;
+}
+/**
+ * Build model routing instructions for a workflow agent.
+ */
+export function buildModelRoutingInstructions(phase, config) {
+    const model = resolveModelForPhase(phase, config);
+    if (!model)
+        return undefined;
+    return `Use model: ${model}`;
+}
+/**
+ * Parse model routing from workflow meta phases.
+ */
+export function parseModelRoutingFromMeta(phases) {
+    const routes = [];
+    if (phases) {
+        for (const phase of phases) {
+            if (phase.model) {
+                routes.push({
+                    phasePattern: phase.title,
+                    model: phase.model,
+                });
+            }
+        }
+    }
+    return { routes };
+}