clementine-agent 1.0.0

package/dist/agent/tool-loop-detector.js

@@ -0,0 +1,242 @@
+/**
+ * Clementine TypeScript — Tool loop detection system.
+ *
+ * Detects when the agent gets stuck in repetitive tool-call patterns:
+ *   - generic_repeat: Same tool+input called repeatedly
+ *   - poll_no_progress: Same tool returning identical results
+ *   - ping_pong: Alternating between two tool+input combos with no result change
+ *
+ * Inspired by OpenClaw's loop detection approach.
+ */
+import { createHash } from 'node:crypto';
+import pino from 'pino';
+// ── Constants (configurable) ────────────────────────────────────────
+/** Maximum number of tool calls to keep in the sliding window. */
+const WINDOW_SIZE = 30;
+/** Entries older than this are pruned on each call. */
+const WINDOW_TTL_MS = 10 * 60 * 1000; // 10 minutes
+/** generic_repeat: Same tool+inputHash called N times. */
+const GENERIC_REPEAT_WARN = 5;
+const GENERIC_REPEAT_BLOCK = 8;
+/** poll_no_progress: Same tool returning identical resultHash N times. */
+const POLL_NO_PROGRESS_WARN = 4;
+const POLL_NO_PROGRESS_BLOCK = 7;
+/** ping_pong: Alternating between exactly two tool+inputHash combos (pairs). */
+const PING_PONG_WARN_PAIRS = 3; // 6 calls
+const PING_PONG_BLOCK_PAIRS = 5; // 10 calls
+// ── Logger ──────────────────────────────────────────────────────────
+const logger = pino({ name: 'clementine.tool-loop-detector' });
+// ── Helpers ─────────────────────────────────────────────────────────
+/** Compute a truncated SHA-256 hex digest (first 16 chars). */
+function shortHash(data) {
+    return createHash('sha256').update(data).digest('hex').slice(0, 16);
+}
+/** Composite key for a tool call: tool name + input hash. */
+function callKey(entry) {
+    return `${entry.toolName}:${entry.inputHash}`;
+}
+// ── ToolLoopDetector ────────────────────────────────────────────────
+/**
+ * Detects repetitive tool-call patterns in a sliding window.
+ *
+ * Usage:
+ *   1. Call `recordCall()` before each tool invocation — it returns a verdict.
+ *   2. Call `recordResult()` after the tool returns — it updates the last entry's resultHash.
+ *   3. Call `reset()` when rotating sessions to clear state.
+ */
+export class ToolLoopDetector {
+    window = [];
+    /**
+     * Record a new tool call, run all detectors, and return the verdict.
+     *
+     * @param toolName - Name of the tool being called
+     * @param input    - Tool input parameters
+     * @returns Loop check result with verdict and optional detector/detail info
+     */
+    recordCall(toolName, input) {
+        const now = Date.now();
+        // Prune entries older than TTL
+        this.window = this.window.filter((e) => now - e.timestamp < WINDOW_TTL_MS);
+        const inputHash = shortHash(JSON.stringify(input));
+        const entry = {
+            toolName,
+            inputHash,
+            resultHash: '', // filled in by recordResult()
+            timestamp: now,
+        };
+        this.window.push(entry);
+        // Trim to max window size (keep most recent)
+        if (this.window.length > WINDOW_SIZE) {
+            this.window = this.window.slice(this.window.length - WINDOW_SIZE);
+        }
+        // Run detectors in order of severity (block takes precedence)
+        const results = [
+            this.detectGenericRepeat(),
+            this.detectPollNoProgress(),
+            this.detectPingPong(),
+        ];
+        // Return the most severe result
+        const block = results.find((r) => r.verdict === 'block');
+        if (block) {
+            logger.warn({ detector: block.detector, detail: block.detail }, 'Tool loop blocked');
+            return block;
+        }
+        const warn = results.find((r) => r.verdict === 'warn');
+        if (warn) {
+            logger.info({ detector: warn.detector, detail: warn.detail }, 'Tool loop warning');
+            return warn;
+        }
+        return { verdict: 'ok' };
+    }
+    /**
+     * Update the most recent call entry with the result hash.
+     *
+     * @param resultText - The text output returned by the tool
+     */
+    recordResult(resultText) {
+        if (this.window.length === 0)
+            return;
+        this.window[this.window.length - 1].resultHash = shortHash(resultText);
+    }
+    /** Clear the sliding window (e.g. on session rotation). */
+    reset() {
+        this.window = [];
+    }
+    // ── Detectors ───────────────────────────────────────────────────
+    /**
+     * generic_repeat: Same tool+inputHash called N times in the window.
+     */
+    detectGenericRepeat() {
+        if (this.window.length === 0)
+            return { verdict: 'ok' };
+        const latest = this.window[this.window.length - 1];
+        const key = callKey(latest);
+        let count = 0;
+        for (const entry of this.window) {
+            if (callKey(entry) === key)
+                count++;
+        }
+        if (count >= GENERIC_REPEAT_BLOCK) {
+            return {
+                verdict: 'block',
+                detector: 'generic_repeat',
+                detail: `Tool ${latest.toolName} called ${count} times with identical input (threshold: ${GENERIC_REPEAT_BLOCK})`,
+            };
+        }
+        if (count >= GENERIC_REPEAT_WARN) {
+            return {
+                verdict: 'warn',
+                detector: 'generic_repeat',
+                detail: `Tool ${latest.toolName} called ${count} times with identical input (warn threshold: ${GENERIC_REPEAT_WARN})`,
+            };
+        }
+        return { verdict: 'ok' };
+    }
+    /**
+     * poll_no_progress: Same tool returning identical resultHash N times.
+     * Only considers entries that have a resultHash set.
+     */
+    detectPollNoProgress() {
+        if (this.window.length === 0)
+            return { verdict: 'ok' };
+        const latest = this.window[this.window.length - 1];
+        const key = callKey(latest);
+        // Gather entries with matching call key that have results
+        const withResults = this.window.filter((e) => callKey(e) === key && e.resultHash !== '');
+        if (withResults.length === 0)
+            return { verdict: 'ok' };
+        // Count how many share the most common resultHash
+        const resultCounts = new Map();
+        for (const e of withResults) {
+            resultCounts.set(e.resultHash, (resultCounts.get(e.resultHash) ?? 0) + 1);
+        }
+        const maxCount = Math.max(...resultCounts.values());
+        if (maxCount >= POLL_NO_PROGRESS_BLOCK) {
+            return {
+                verdict: 'block',
+                detector: 'poll_no_progress',
+                detail: `Tool ${latest.toolName} returned identical results ${maxCount} times (threshold: ${POLL_NO_PROGRESS_BLOCK})`,
+            };
+        }
+        if (maxCount >= POLL_NO_PROGRESS_WARN) {
+            return {
+                verdict: 'warn',
+                detector: 'poll_no_progress',
+                detail: `Tool ${latest.toolName} returned identical results ${maxCount} times (warn threshold: ${POLL_NO_PROGRESS_WARN})`,
+            };
+        }
+        return { verdict: 'ok' };
+    }
+    /**
+     * ping_pong: Alternating between exactly two tool+inputHash combos
+     * with no result change. Scans the tail of the window for the pattern.
+     */
+    detectPingPong() {
+        const w = this.window;
+        if (w.length < 4)
+            return { verdict: 'ok' };
+        // Work backwards from the end — look for A-B-A-B pattern
+        const a = callKey(w[w.length - 2]);
+        const b = callKey(w[w.length - 1]);
+        // Must be two distinct combos
+        if (a === b)
+            return { verdict: 'ok' };
+        // Count consecutive alternating pairs from the end
+        let pairs = 0;
+        let resultsStatic = true;
+        for (let i = w.length - 1; i >= 1; i -= 2) {
+            const curKey = callKey(w[i]);
+            const prevKey = callKey(w[i - 1]);
+            if (curKey === b && prevKey === a) {
+                pairs++;
+                // Check if results are changing (only for entries with results)
+                if (w[i].resultHash !== '' && w[i - 1].resultHash !== '') {
+                    // Check if the B results differ across pairs, or A results differ
+                    // We consider it "static" if same-key entries all share the same resultHash
+                }
+            }
+            else {
+                break;
+            }
+        }
+        // Verify results are static across the alternating calls
+        if (pairs >= PING_PONG_WARN_PAIRS) {
+            const startIdx = w.length - pairs * 2;
+            const aResults = new Set();
+            const bResults = new Set();
+            for (let i = startIdx; i < w.length; i += 2) {
+                if (w[i].resultHash !== '')
+                    aResults.add(w[i].resultHash);
+                if (i + 1 < w.length && w[i + 1].resultHash !== '')
+                    bResults.add(w[i + 1].resultHash);
+            }
+            // If results vary, it's not a stuck loop
+            resultsStatic = aResults.size <= 1 && bResults.size <= 1;
+        }
+        if (!resultsStatic)
+            return { verdict: 'ok' };
+        if (pairs >= PING_PONG_BLOCK_PAIRS) {
+            const toolA = w[w.length - 2].toolName;
+            const toolB = w[w.length - 1].toolName;
+            return {
+                verdict: 'block',
+                detector: 'ping_pong',
+                detail: `Alternating between ${toolA} and ${toolB} for ${pairs} pairs (${pairs * 2} calls, threshold: ${PING_PONG_BLOCK_PAIRS} pairs)`,
+            };
+        }
+        if (pairs >= PING_PONG_WARN_PAIRS) {
+            const toolA = w[w.length - 2].toolName;
+            const toolB = w[w.length - 1].toolName;
+            return {
+                verdict: 'warn',
+                detector: 'ping_pong',
+                detail: `Alternating between ${toolA} and ${toolB} for ${pairs} pairs (${pairs * 2} calls, warn threshold: ${PING_PONG_WARN_PAIRS} pairs)`,
+            };
+        }
+        return { verdict: 'ok' };
+    }
+}
+// ── Singleton ───────────────────────────────────────────────────────
+/** Shared singleton instance for the process. */
+export const toolLoopDetector = new ToolLoopDetector();
+//# sourceMappingURL=tool-loop-detector.js.map

package/dist/agent/workflow-runner.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Clementine TypeScript — Workflow Runner.
+ *
+ * Parses workflow definition files (markdown + YAML frontmatter),
+ * validates the step DAG, and executes steps using the existing
+ * PlanOrchestrator primitives (computeWaves + settledWithLimit).
+ */
+import type { PersonalAssistant } from './assistant.js';
+import type { WorkflowDefinition, WorkflowRunEntry } from '../types.js';
+export interface WorkflowProgressUpdate {
+    stepId: string;
+    status: 'waiting' | 'running' | 'done' | 'failed' | 'skipped';
+    description: string;
+    durationMs?: number;
+}
+export interface WorkflowRunResult {
+    status: 'ok' | 'error' | 'partial';
+    output: string;
+    entry: WorkflowRunEntry;
+}
+/**
+ * Parse a single workflow markdown file into a WorkflowDefinition.
+ */
+export declare function parseWorkflow(filePath: string): WorkflowDefinition;
+/**
+ * Parse all workflow files in a directory.
+ */
+export declare function parseAllWorkflows(dir: string): WorkflowDefinition[];
+export declare class WorkflowRunner {
+    private assistant;
+    constructor(assistant: PersonalAssistant);
+    run(workflow: WorkflowDefinition, inputs: Record<string, string>, onProgress?: (updates: WorkflowProgressUpdate[]) => void): Promise<WorkflowRunResult>;
+    private buildSynthesisPrompt;
+    private fallbackOutput;
+}
+//# sourceMappingURL=workflow-runner.d.ts.map

package/dist/agent/workflow-runner.js

@@ -0,0 +1,317 @@
+/**
+ * Clementine TypeScript — Workflow Runner.
+ *
+ * Parses workflow definition files (markdown + YAML frontmatter),
+ * validates the step DAG, and executes steps using the existing
+ * PlanOrchestrator primitives (computeWaves + settledWithLimit).
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import matter from 'gray-matter';
+import pino from 'pino';
+import { computeWaves, settledWithLimit } from './orchestrator.js';
+import { resolveStaticVariables, resolveStepOutputs } from './workflow-variables.js';
+import { BASE_DIR } from '../config.js';
+const logger = pino({ name: 'clementine.workflow' });
+const MAX_CONCURRENT_STEPS = 3;
+const RESULT_TRUNCATE_CHARS = 4000;
+// ── Parsing ─────────────────────────────────────────────────────────
+/**
+ * Parse a single workflow markdown file into a WorkflowDefinition.
+ */
+export function parseWorkflow(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const parsed = matter(raw);
+    const data = parsed.data;
+    if (data.type !== 'workflow') {
+        throw new Error(`File is not a workflow (type="${data.type}"): ${filePath}`);
+    }
+    const name = String(data.name ?? path.basename(filePath, '.md'));
+    const description = String(data.description ?? '');
+    const enabled = data.enabled !== false;
+    // Trigger
+    const triggerRaw = data.trigger ?? {};
+    const trigger = {
+        schedule: triggerRaw.schedule ? String(triggerRaw.schedule) : undefined,
+        manual: triggerRaw.manual !== false,
+    };
+    // Inputs
+    const inputs = {};
+    if (data.inputs && typeof data.inputs === 'object') {
+        for (const [key, val] of Object.entries(data.inputs)) {
+            const v = val;
+            inputs[key] = {
+                type: (v.type === 'number' ? 'number' : 'string'),
+                default: v.default != null ? String(v.default) : undefined,
+                description: v.description ? String(v.description) : undefined,
+            };
+        }
+    }
+    // Steps
+    const stepsRaw = data.steps;
+    if (!Array.isArray(stepsRaw) || stepsRaw.length === 0) {
+        throw new Error(`Workflow "${name}" has no steps: ${filePath}`);
+    }
+    const steps = stepsRaw.map((s, i) => ({
+        id: String(s.id ?? `step-${i + 1}`),
+        prompt: String(s.prompt ?? ''),
+        dependsOn: Array.isArray(s.dependsOn) ? s.dependsOn.map(String) : [],
+        model: s.model ? String(s.model) : undefined,
+        tier: Number(s.tier ?? 1),
+        maxTurns: Number(s.maxTurns ?? 15),
+        workDir: s.workDir ? String(s.workDir) : undefined,
+    }));
+    // Synthesis
+    const synthesis = data.synthesis?.prompt
+        ? { prompt: String(data.synthesis.prompt) }
+        : undefined;
+    return {
+        name,
+        description,
+        enabled,
+        trigger,
+        inputs,
+        steps,
+        synthesis,
+        sourceFile: filePath,
+    };
+}
+/**
+ * Parse all workflow files in a directory.
+ */
+export function parseAllWorkflows(dir) {
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter(f => f.endsWith('.md'));
+    const workflows = [];
+    for (const file of files) {
+        try {
+            workflows.push(parseWorkflow(path.join(dir, file)));
+        }
+        catch (err) {
+            logger.warn({ err, file }, `Failed to parse workflow: ${file}`);
+        }
+    }
+    return workflows;
+}
+// ── Validation ──────────────────────────────────────────────────────
+function validateWorkflow(workflow) {
+    const errors = [];
+    const stepIds = new Set(workflow.steps.map(s => s.id));
+    // Check unique IDs
+    if (stepIds.size !== workflow.steps.length) {
+        errors.push('Duplicate step IDs found');
+    }
+    // Check dependencies exist
+    for (const step of workflow.steps) {
+        for (const dep of step.dependsOn) {
+            if (!stepIds.has(dep)) {
+                errors.push(`Step "${step.id}" depends on unknown step "${dep}"`);
+            }
+            if (dep === step.id) {
+                errors.push(`Step "${step.id}" depends on itself`);
+            }
+        }
+        if (!step.prompt.trim()) {
+            errors.push(`Step "${step.id}" has an empty prompt`);
+        }
+    }
+    // Check for cycles (computeWaves will throw on cycles)
+    try {
+        const planSteps = workflow.steps.map(s => ({
+            id: s.id,
+            description: s.id,
+            prompt: s.prompt,
+            dependsOn: s.dependsOn,
+            maxTurns: s.maxTurns,
+            tier: s.tier,
+        }));
+        computeWaves(planSteps);
+    }
+    catch {
+        errors.push('Circular dependency detected in steps');
+    }
+    return errors;
+}
+// ── Run log ─────────────────────────────────────────────────────────
+function getRunLogDir() {
+    const dir = path.join(BASE_DIR, 'workflows', 'runs');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function appendRunLog(entry) {
+    const safe = entry.workflowName.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const filePath = path.join(getRunLogDir(), `${safe}.jsonl`);
+    try {
+        appendFileSync(filePath, JSON.stringify(entry) + '\n');
+    }
+    catch (err) {
+        logger.warn({ err, workflow: entry.workflowName }, 'Failed to write workflow run log');
+    }
+}
+// ── WorkflowRunner ──────────────────────────────────────────────────
+export class WorkflowRunner {
+    assistant;
+    constructor(assistant) {
+        this.assistant = assistant;
+    }
+    async run(workflow, inputs, onProgress) {
+        const runId = randomUUID().slice(0, 8);
+        const startTime = Date.now();
+        logger.info({ workflow: workflow.name, runId, inputs }, 'Starting workflow');
+        // 1. Validate
+        const errors = validateWorkflow(workflow);
+        if (errors.length > 0) {
+            const entry = {
+                workflowName: workflow.name,
+                runId,
+                startedAt: new Date(startTime).toISOString(),
+                finishedAt: new Date().toISOString(),
+                status: 'error',
+                durationMs: Date.now() - startTime,
+                inputs,
+                stepResults: [],
+                error: `Validation failed: ${errors.join('; ')}`,
+            };
+            appendRunLog(entry);
+            return { status: 'error', output: `Workflow validation failed:\n${errors.join('\n')}`, entry };
+        }
+        // 2. Merge inputs with defaults
+        const resolvedInputs = {};
+        for (const [key, def] of Object.entries(workflow.inputs)) {
+            resolvedInputs[key] = inputs[key] ?? def.default ?? '';
+        }
+        // Also pass through any extra inputs not in the schema
+        for (const [key, val] of Object.entries(inputs)) {
+            if (!(key in resolvedInputs))
+                resolvedInputs[key] = val;
+        }
+        // 3. Resolve static variables in all step prompts
+        const resolvedSteps = workflow.steps.map(s => ({
+            ...s,
+            prompt: resolveStaticVariables(s.prompt, resolvedInputs, workflow.name),
+        }));
+        // 4. Compute execution waves
+        const planSteps = resolvedSteps.map(s => ({
+            id: s.id,
+            description: s.id,
+            prompt: s.prompt,
+            dependsOn: s.dependsOn,
+            maxTurns: s.maxTurns,
+            tier: s.tier,
+            model: s.model,
+        }));
+        const waves = computeWaves(planSteps);
+        // 5. Initialize progress
+        const statuses = new Map();
+        for (const step of resolvedSteps) {
+            statuses.set(step.id, { stepId: step.id, status: 'waiting', description: step.id });
+        }
+        onProgress?.([...statuses.values()]);
+        // 6. Execute waves
+        const stepResults = new Map();
+        const stepEntries = [];
+        let hasFailures = false;
+        for (const wave of waves) {
+            // Mark running
+            for (const step of wave) {
+                statuses.set(step.id, { stepId: step.id, status: 'running', description: step.id });
+            }
+            onProgress?.([...statuses.values()]);
+            // Run wave
+            const settled = await settledWithLimit(wave.map(step => async () => {
+                const resolvedStep = resolvedSteps.find(s => s.id === step.id);
+                // Resolve step output references
+                const prompt = resolveStepOutputs(resolvedStep.prompt, stepResults, RESULT_TRUNCATE_CHARS);
+                const stepStart = Date.now();
+                const result = await this.assistant.runPlanStep(step.id, prompt, {
+                    tier: resolvedStep.tier,
+                    maxTurns: resolvedStep.maxTurns,
+                    model: resolvedStep.model,
+                });
+                return { stepId: step.id, result, durationMs: Date.now() - stepStart };
+            }), MAX_CONCURRENT_STEPS);
+            // Collect results
+            for (let i = 0; i < wave.length; i++) {
+                const step = wave[i];
+                const outcome = settled[i];
+                if (outcome.status === 'fulfilled') {
+                    const { result, durationMs } = outcome.value;
+                    const output = result || '[No output produced]';
+                    stepResults.set(step.id, output);
+                    statuses.set(step.id, {
+                        stepId: step.id, status: 'done', description: step.id, durationMs,
+                    });
+                    stepEntries.push({
+                        stepId: step.id, status: 'done', durationMs,
+                        outputPreview: output.slice(0, 200),
+                    });
+                }
+                else {
+                    const errMsg = `[FAILED: ${outcome.reason}]`;
+                    stepResults.set(step.id, errMsg);
+                    hasFailures = true;
+                    statuses.set(step.id, {
+                        stepId: step.id, status: 'failed', description: step.id,
+                    });
+                    stepEntries.push({ stepId: step.id, status: 'failed', durationMs: 0 });
+                    logger.error({ stepId: step.id, err: outcome.reason }, 'Workflow step failed');
+                }
+            }
+            onProgress?.([...statuses.values()]);
+        }
+        // 7. Synthesis
+        let finalOutput;
+        if (workflow.synthesis?.prompt) {
+            const synthPrompt = this.buildSynthesisPrompt(workflow, stepResults);
+            try {
+                finalOutput = await this.assistant.runPlanStep('__synthesis__', synthPrompt, {
+                    tier: 2, maxTurns: 5, disableTools: true,
+                });
+            }
+            catch (err) {
+                logger.warn({ err }, 'Workflow synthesis failed — concatenating results');
+                finalOutput = this.fallbackOutput(stepResults);
+            }
+        }
+        else {
+            finalOutput = this.fallbackOutput(stepResults);
+        }
+        // 8. Log
+        const entry = {
+            workflowName: workflow.name,
+            runId,
+            startedAt: new Date(startTime).toISOString(),
+            finishedAt: new Date().toISOString(),
+            status: hasFailures ? 'partial' : 'ok',
+            durationMs: Date.now() - startTime,
+            inputs: resolvedInputs,
+            stepResults: stepEntries,
+            outputPreview: finalOutput.slice(0, 500),
+        };
+        appendRunLog(entry);
+        logger.info({ workflow: workflow.name, runId, status: entry.status, durationMs: entry.durationMs }, 'Workflow completed');
+        return { status: entry.status, output: finalOutput, entry };
+    }
+    buildSynthesisPrompt(workflow, stepResults) {
+        const parts = [`## Workflow: ${workflow.name}\n`];
+        parts.push('## Step results:');
+        for (const step of workflow.steps) {
+            const result = stepResults.get(step.id) ?? '[no result]';
+            const truncated = result.length > RESULT_TRUNCATE_CHARS
+                ? result.slice(0, RESULT_TRUNCATE_CHARS) + '\n...[truncated]'
+                : result;
+            parts.push(`### ${step.id}\n${truncated}`);
+        }
+        parts.push(`\n## Instructions:\n${workflow.synthesis.prompt}`);
+        return parts.join('\n');
+    }
+    fallbackOutput(stepResults) {
+        return Array.from(stepResults.entries())
+            .map(([id, result]) => `**${id}:**\n${result.slice(0, 500)}`)
+            .join('\n\n');
+    }
+}
+//# sourceMappingURL=workflow-runner.js.map

package/dist/agent/workflow-variables.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Clementine TypeScript — Workflow template variable resolution.
+ *
+ * Pure functions for resolving {{...}} placeholders in workflow step prompts.
+ */
+/**
+ * Resolve static variables (available before any step executes).
+ * Handles: {{input.*}}, {{env.*}}, {{date}}, {{time}}, {{workflow.*}}
+ */
+export declare function resolveStaticVariables(template: string, inputs: Record<string, string>, workflowName: string): string;
+/**
+ * Resolve step output references after dependencies complete.
+ * Handles: {{steps.research.output}}
+ */
+export declare function resolveStepOutputs(template: string, stepResults: Map<string, string>, truncateChars?: number): string;
+//# sourceMappingURL=workflow-variables.d.ts.map

package/dist/agent/workflow-variables.js

@@ -0,0 +1,62 @@
+/**
+ * Clementine TypeScript — Workflow template variable resolution.
+ *
+ * Pure functions for resolving {{...}} placeholders in workflow step prompts.
+ */
+import { OWNER_NAME, ASSISTANT_NAME } from '../config.js';
+/**
+ * Resolve static variables (available before any step executes).
+ * Handles: {{input.*}}, {{env.*}}, {{date}}, {{time}}, {{workflow.*}}
+ */
+export function resolveStaticVariables(template, inputs, workflowName) {
+    const now = new Date();
+    const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+    const timeStr = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+    return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+        const trimmed = key.trim();
+        // {{input.topic}} → inputs['topic']
+        if (trimmed.startsWith('input.')) {
+            const inputKey = trimmed.slice(6);
+            return inputs[inputKey] ?? match;
+        }
+        // {{env.OWNER_NAME}} → config values
+        if (trimmed.startsWith('env.')) {
+            const envKey = trimmed.slice(4);
+            if (envKey === 'OWNER_NAME')
+                return OWNER_NAME || match;
+            if (envKey === 'ASSISTANT_NAME')
+                return ASSISTANT_NAME || match;
+            return match;
+        }
+        // {{workflow.name}} → workflow name
+        if (trimmed.startsWith('workflow.')) {
+            const field = trimmed.slice(9);
+            if (field === 'name')
+                return workflowName;
+            return match;
+        }
+        // {{date}}, {{time}}
+        if (trimmed === 'date')
+            return dateStr;
+        if (trimmed === 'time')
+            return timeStr;
+        // Leave unresolved (might be a step output reference)
+        return match;
+    });
+}
+/**
+ * Resolve step output references after dependencies complete.
+ * Handles: {{steps.research.output}}
+ */
+export function resolveStepOutputs(template, stepResults, truncateChars = 4000) {
+    return template.replace(/\{\{steps\.([^.]+)\.output\}\}/g, (_match, stepId) => {
+        const output = stepResults.get(stepId);
+        if (output === undefined)
+            return `[step "${stepId}" has no output]`;
+        if (output.length > truncateChars) {
+            return output.slice(0, truncateChars) + '\n...[truncated]';
+        }
+        return output;
+    });
+}
+//# sourceMappingURL=workflow-variables.js.map