@tmddev/tmd 0.1.0 → 0.2.0

package/dist/utils/pipeline.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Pipeline orchestration engine for automated PDCA execution
+ */
+import { type PipelineConfig } from './pipeline-config.js';
+export type PipelinePhase = 'do' | 'check' | 'act';
+export interface PhaseResult {
+    phase: PipelinePhase;
+    success: boolean;
+    startTime: Date;
+    endTime: Date;
+    error?: string;
+    details?: Record<string, unknown>;
+}
+export interface PipelineResult {
+    taskId: string;
+    success: boolean;
+    startTime: Date;
+    endTime: Date;
+    phases: PhaseResult[];
+    error?: string;
+}
+export interface PipelineState {
+    taskId: string;
+    currentPhase?: PipelinePhase;
+    completedPhases: PipelinePhase[];
+    lastRun?: Date;
+    lastError?: string;
+    phaseResults: PhaseResult[];
+}
+export declare class PipelineRunner {
+    private taskId;
+    private config;
+    private dryRun;
+    private state;
+    constructor(taskId: string, config: PipelineConfig, dryRun?: boolean);
+    /**
+     * Run the full pipeline from the specified phase
+     */
+    run(fromPhase?: PipelinePhase): Promise<PipelineResult>;
+    /**
+     * Validate that prerequisites for starting from a phase are met
+     */
+    private validatePrerequisites;
+    /**
+     * Execute a single phase
+     */
+    private executePhase;
+    /**
+     * Execute the Do phase
+     */
+    private executeDoPhase;
+    /**
+     * Execute skill steps
+     */
+    private executeSkillSteps;
+    /**
+     * Write execution results to execution.md and data.md
+     */
+    private writeExecutionResults;
+    /**
+     * Execute the Check phase
+     */
+    private executeCheckPhase;
+    /**
+     * Write check phase results
+     */
+    private writeCheckResults;
+    /**
+     * Execute the Act phase
+     */
+    private executeActPhase;
+    /**
+     * Get current pipeline state
+     */
+    getState(): PipelineState;
+}
+/**
+ * Get the current pipeline state for a task
+ */
+export declare function getPipelineState(taskId: string): PipelineState;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/utils/pipeline.js

@@ -0,0 +1,580 @@
+/**
+ * Pipeline orchestration engine for automated PDCA execution
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import chalk from 'chalk';
+import { getPlanDir, getDoDir, getCheckDir, getActDir, ensureDir } from './paths.js';
+import { getTaskStatus, updateTaskStatus } from './task-status.js';
+import { parseSuccessCriteria } from './pipeline-config.js';
+import { executeStep } from './step-executor.js';
+import { extractTasks, updateTaskStatus as updatePlanTaskStatus, detectSkillReference } from './tasks.js';
+import { extractGoals, extractResults, compareGoalsAndResults } from './comparison.js';
+import { identifyDeviations, analyzeRootCauses, recommendAdjustments } from './analysis.js';
+import { parseEvaluationResults, parseDeviationAnalysis, identifySuccesses, identifyFailures, identifyUnresolvedIssues } from './act-processing.js';
+import { extractSuccessfulPractices, generateStandardizationRecommendations, formatStandardizationDocument } from './standardization.js';
+import { executionTemplate, evaluationTemplate, improvementTemplate, renderTemplate } from './templates.js';
+import { getSkillDir } from './paths.js';
+export class PipelineRunner {
+    taskId;
+    config;
+    dryRun;
+    state;
+    constructor(taskId, config, dryRun = false) {
+        this.taskId = taskId;
+        this.config = config;
+        this.dryRun = dryRun;
+        this.state = {
+            taskId,
+            completedPhases: [],
+            phaseResults: []
+        };
+    }
+    /**
+     * Run the full pipeline from the specified phase
+     */
+    async run(fromPhase) {
+        const startTime = new Date();
+        const phases = ['do', 'check', 'act'];
+        const startIndex = fromPhase ? phases.indexOf(fromPhase) : 0;
+        if (startIndex === -1) {
+            return {
+                taskId: this.taskId,
+                success: false,
+                startTime,
+                endTime: new Date(),
+                phases: [],
+                error: `Invalid phase: ${fromPhase ?? ''}`
+            };
+        }
+        // Validate prerequisites
+        const prereqError = this.validatePrerequisites(fromPhase);
+        if (prereqError) {
+            return {
+                taskId: this.taskId,
+                success: false,
+                startTime,
+                endTime: new Date(),
+                phases: [],
+                error: prereqError
+            };
+        }
+        const phaseResults = [];
+        let success = true;
+        let lastError;
+        const phasesToRun = phases.slice(startIndex);
+        for (const phase of phasesToRun) {
+            const phaseConfig = this.config.phases[phase];
+            if (!phaseConfig.auto) {
+                console.log(chalk.yellow(`  Skipping ${phase} phase (auto: false)`));
+                continue;
+            }
+            console.log(chalk.blue(`\n  Phase: ${phase.toUpperCase()}`));
+            this.state.currentPhase = phase;
+            const phaseResult = await this.executePhase(phase);
+            phaseResults.push(phaseResult);
+            if (!phaseResult.success) {
+                success = false;
+                lastError = phaseResult.error;
+                console.log(chalk.red(`  Phase ${phase} failed: ${phaseResult.error ?? ''}`));
+                break;
+            }
+            this.state.completedPhases.push(phase);
+            console.log(chalk.green(`  Phase ${phase} completed`));
+        }
+        this.state.lastRun = new Date();
+        this.state.phaseResults = phaseResults;
+        if (!success && lastError != null) {
+            this.state.lastError = lastError;
+        }
+        return {
+            taskId: this.taskId,
+            success,
+            startTime,
+            endTime: new Date(),
+            phases: phaseResults,
+            ...(lastError != null ? { error: lastError } : {})
+        };
+    }
+    /**
+     * Validate that prerequisites for starting from a phase are met
+     */
+    validatePrerequisites(fromPhase) {
+        const planPath = join(getPlanDir(this.taskId), 'plan.md');
+        if (!existsSync(planPath)) {
+            return `Plan not found for task: ${this.taskId}`;
+        }
+        if (fromPhase === 'check') {
+            const executionPath = join(getDoDir(this.taskId), 'execution.md');
+            if (!existsSync(executionPath)) {
+                return `Execution not found for task: ${this.taskId}. Run Do phase first.`;
+            }
+        }
+        if (fromPhase === 'act') {
+            const evaluationPath = join(getCheckDir(this.taskId), 'evaluation.md');
+            if (!existsSync(evaluationPath)) {
+                return `Evaluation not found for task: ${this.taskId}. Run Check phase first.`;
+            }
+        }
+        return null;
+    }
+    /**
+     * Execute a single phase
+     */
+    async executePhase(phase) {
+        const startTime = new Date();
+        try {
+            switch (phase) {
+                case 'do':
+                    return await this.executeDoPhase(startTime);
+                case 'check':
+                    return await this.executeCheckPhase(startTime);
+                case 'act':
+                    return await this.executeActPhase(startTime);
+                default:
+                    return {
+                        phase,
+                        success: false,
+                        startTime,
+                        endTime: new Date(),
+                        error: `Unknown phase: ${String(phase)}`
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                phase,
+                success: false,
+                startTime,
+                endTime: new Date(),
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Execute the Do phase
+     */
+    async executeDoPhase(startTime) {
+        const planPath = join(getPlanDir(this.taskId), 'plan.md');
+        const doDir = getDoDir(this.taskId);
+        const phaseConfig = this.config.phases.do;
+        if (!this.dryRun) {
+            ensureDir(doDir);
+        }
+        // Extract tasks
+        const tasks = extractTasks(planPath);
+        const incompleteTasks = tasks.filter(t => !t.completed);
+        if (incompleteTasks.length === 0) {
+            console.log(chalk.yellow('    All tasks already completed'));
+            return {
+                phase: 'do',
+                success: true,
+                startTime,
+                endTime: new Date(),
+                details: { tasksCompleted: tasks.length, totalTasks: tasks.length }
+            };
+        }
+        console.log(chalk.gray(`    Tasks to execute: ${String(incompleteTasks.length)}/${String(tasks.length)}`));
+        // Initialize execution.md
+        const executionPath = join(doDir, 'execution.md');
+        const dataPath = join(doDir, 'data.md');
+        if (!this.dryRun) {
+            if (!existsSync(executionPath)) {
+                writeFileSync(executionPath, renderTemplate(executionTemplate, { taskId: this.taskId }));
+            }
+            if (!existsSync(dataPath)) {
+                writeFileSync(dataPath, '# Data Collection\n\n');
+            }
+        }
+        // Execute tasks
+        const stepResults = [];
+        const actionsTaken = [];
+        const dataCollected = [];
+        const observations = [];
+        const issues = [];
+        const context = {
+            taskId: this.taskId,
+            workingDir: process.cwd(),
+            dryRun: this.dryRun
+        };
+        for (const task of incompleteTasks) {
+            console.log(chalk.gray(`    [${String(task.index)}] ${task.content.substring(0, 50)}${task.content.length > 50 ? '...' : ''}`));
+            // Check for skill reference
+            const skillRef = detectSkillReference(task.content);
+            if (skillRef) {
+                const skillResult = await this.executeSkillSteps(skillRef, context);
+                stepResults.push(...skillResult.results);
+                if (skillResult.output) {
+                    dataCollected.push(`Skill ${skillRef}: ${skillResult.output}`);
+                }
+                if (!skillResult.success) {
+                    issues.push(`Task ${String(task.index)} skill execution failed: ${skillResult.error ?? ''}`);
+                    continue;
+                }
+            }
+            // Mark task as complete
+            if (!this.dryRun) {
+                updatePlanTaskStatus(planPath, task.index, true);
+            }
+            actionsTaken.push(`Completed task ${String(task.index)}: ${task.content}`);
+        }
+        // Check success criteria
+        const updatedTasks = this.dryRun ? tasks : extractTasks(planPath);
+        const completedCount = updatedTasks.filter(t => t.completed).length;
+        const criteriaResult = parseSuccessCriteria(phaseConfig.successCriteria, updatedTasks.length, completedCount);
+        if (!criteriaResult.passed) {
+            return {
+                phase: 'do',
+                success: false,
+                startTime,
+                endTime: new Date(),
+                ...(criteriaResult.reason != null ? { error: criteriaResult.reason } : {}),
+                details: { tasksCompleted: completedCount, totalTasks: updatedTasks.length }
+            };
+        }
+        // Write execution results
+        if (!this.dryRun) {
+            this.writeExecutionResults(executionPath, dataPath, {
+                actionsTaken,
+                dataCollected,
+                observations,
+                issues,
+                stepResults
+            });
+            updateTaskStatus(this.taskId, 'doing');
+        }
+        return {
+            phase: 'do',
+            success: true,
+            startTime,
+            endTime: new Date(),
+            details: {
+                tasksCompleted: completedCount,
+                totalTasks: updatedTasks.length,
+                stepsExecuted: stepResults.length
+            }
+        };
+    }
+    /**
+     * Execute skill steps
+     */
+    async executeSkillSteps(skillName, context) {
+        const skillDir = getSkillDir(skillName);
+        const stepsPath = join(skillDir, 'steps.yaml');
+        if (!existsSync(stepsPath)) {
+            return {
+                success: false,
+                results: [],
+                error: `Skill steps not found: ${skillName}`
+            };
+        }
+        try {
+            const stepsData = yaml.load(readFileSync(stepsPath, 'utf-8'));
+            const steps = (stepsData != null && typeof stepsData === 'object' && 'steps' in stepsData ? (stepsData.steps ?? []) : []);
+            const results = [];
+            const outputs = [];
+            for (const step of steps) {
+                const result = await executeStep(step, context);
+                results.push(result);
+                if (result.output) {
+                    outputs.push(result.output);
+                }
+                if (!result.success) {
+                    return {
+                        success: false,
+                        results,
+                        output: outputs.join('\n'),
+                        ...(result.error != null ? { error: result.error } : {})
+                    };
+                }
+            }
+            return {
+                success: true,
+                results,
+                output: outputs.join('\n')
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                results: [],
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Write execution results to execution.md and data.md
+     */
+    writeExecutionResults(executionPath, dataPath, results) {
+        let content = readFileSync(executionPath, 'utf-8');
+        const timestamp = new Date().toISOString();
+        // Add actions taken
+        if (results.actionsTaken.length > 0) {
+            const actionsSection = `\n## Actions Taken\n\n${results.actionsTaken.map(a => `- [${timestamp}] ${a}`).join('\n')}\n`;
+            content = content.replace(/(## Actions Taken\n<!-- Document actions performed -->\n)/, actionsSection);
+        }
+        // Add data collected
+        if (results.dataCollected.length > 0) {
+            const dataSection = `\n## Data Collected\n\n${results.dataCollected.map(d => `- ${d}`).join('\n')}\n`;
+            content = content.replace(/(## Data Collected\n<!-- Record data collected during execution -->\n)/, dataSection);
+        }
+        // Add observations
+        if (results.observations.length > 0) {
+            const obsSection = `\n## Observations\n\n${results.observations.map(o => `- ${o}`).join('\n')}\n`;
+            content = content.replace(/(## Observations\n<!-- Note any observations or insights -->\n)/, obsSection);
+        }
+        // Add issues
+        if (results.issues.length > 0) {
+            const issuesSection = `\n## Issues Encountered\n\n${results.issues.map(i => `- ${i}`).join('\n')}\n`;
+            content = content.replace(/(## Issues Encountered\n<!-- Document any problems or blockers -->\n)/, issuesSection);
+        }
+        writeFileSync(executionPath, content);
+        // Write step results to data.md
+        if (results.stepResults.length > 0) {
+            const stepData = results.stepResults.map((r, i) => ({
+                step: i + 1,
+                success: r.success,
+                duration: r.duration,
+                output: r.output?.substring(0, 200)
+            }));
+            const dataContent = readFileSync(dataPath, 'utf-8');
+            writeFileSync(dataPath, dataContent + '\n## Step Execution Results\n\n```yaml\n' + yaml.dump(stepData) + '```\n');
+        }
+    }
+    /**
+     * Execute the Check phase
+     */
+    async executeCheckPhase(startTime) {
+        await Promise.resolve();
+        const planPath = join(getPlanDir(this.taskId), 'plan.md');
+        const executionPath = join(getDoDir(this.taskId), 'execution.md');
+        const dataPath = join(getDoDir(this.taskId), 'data.md');
+        const checkDir = getCheckDir(this.taskId);
+        const phaseConfig = this.config.phases.check;
+        if (!this.dryRun) {
+            ensureDir(checkDir);
+        }
+        // Extract goals and results
+        const goals = extractGoals(planPath);
+        const results = extractResults(executionPath, dataPath);
+        console.log(chalk.gray(`    Goals found: ${String(goals.length)}`));
+        console.log(chalk.gray(`    Results found: ${String(results.length)}`));
+        // Perform comparison
+        const comparisons = compareGoalsAndResults(goals, results);
+        // Calculate statistics
+        const totalGoals = comparisons.length;
+        const metGoals = comparisons.filter(c => c.status === 'met').length;
+        const unmetGoals = comparisons.filter(c => c.status === 'unmet').length;
+        const partialGoals = comparisons.filter(c => c.status === 'partial').length;
+        console.log(chalk.gray(`    Goals met: ${String(metGoals)}/${String(totalGoals)}`));
+        if (unmetGoals > 0) {
+            console.log(chalk.yellow(`    Goals unmet: ${String(unmetGoals)}`));
+        }
+        // Identify deviations
+        const deviations = identifyDeviations(comparisons);
+        let rootCauses = [];
+        let recommendations = [];
+        if (phaseConfig.analyze && deviations.length > 0) {
+            rootCauses = analyzeRootCauses(deviations);
+        }
+        if (phaseConfig.recommend && deviations.length > 0) {
+            recommendations = recommendAdjustments(deviations, rootCauses);
+        }
+        // Check success criteria
+        const criteria = phaseConfig.successCriteria;
+        if (criteria) {
+            if (!criteria.allowUnmetGoals && unmetGoals > 0) {
+                return {
+                    phase: 'check',
+                    success: false,
+                    startTime,
+                    endTime: new Date(),
+                    error: `${String(unmetGoals)} goal(s) not met`,
+                    details: { totalGoals, metGoals, unmetGoals, partialGoals }
+                };
+            }
+        }
+        // Write evaluation and deviation documents
+        if (!this.dryRun) {
+            this.writeCheckResults(checkDir, {
+                comparisons,
+                deviations,
+                rootCauses,
+                recommendations,
+                totalGoals,
+                metGoals,
+                unmetGoals
+            });
+            updateTaskStatus(this.taskId, 'checking');
+        }
+        return {
+            phase: 'check',
+            success: true,
+            startTime,
+            endTime: new Date(),
+            details: { totalGoals, metGoals, unmetGoals, partialGoals, deviations: deviations.length }
+        };
+    }
+    /**
+     * Write check phase results
+     */
+    writeCheckResults(checkDir, data) {
+        // Generate evaluation.md
+        let evaluationContent = renderTemplate(evaluationTemplate, { taskId: this.taskId });
+        // Add comparison table
+        evaluationContent += '\n## Comparison with Plan\n\n';
+        evaluationContent += '| Goal | Planned | Actual | Status | Deviation |\n';
+        evaluationContent += '|------|---------|--------|--------|-----------|\n';
+        for (const comp of data.comparisons) {
+            const goal = comp.goal.description.substring(0, 50) + (comp.goal.description.length > 50 ? '...' : '');
+            const planned = comp.goal.targetValue !== undefined ? String(comp.goal.targetValue) : 'N/A';
+            const actual = comp.result?.value !== undefined ? String(comp.result.value) : 'No data';
+            const status = comp.status === 'met' ? 'Met' : comp.status === 'unmet' ? 'Unmet' : comp.status;
+            const deviation = comp.deviation !== undefined ? comp.deviation.toFixed(2) : 'N/A';
+            evaluationContent += `| ${goal} | ${planned} | ${actual} | ${status} | ${deviation} |\n`;
+        }
+        evaluationContent += '\n## Results Summary\n\n';
+        evaluationContent += `- Total goals: ${String(data.totalGoals)}\n`;
+        evaluationContent += `- Goals met: ${String(data.metGoals)}\n`;
+        evaluationContent += `- Goals unmet: ${String(data.unmetGoals)}\n`;
+        if (data.recommendations.length > 0) {
+            evaluationContent += '\n## Recommendations\n\n';
+            for (const rec of data.recommendations) {
+                evaluationContent += `- **${rec.action}** (${rec.priority}): ${rec.description}\n`;
+            }
+        }
+        writeFileSync(join(checkDir, 'evaluation.md'), evaluationContent);
+        // Generate deviation.md
+        let deviationContent = '# Deviation Analysis\n\n';
+        if (data.deviations.length === 0) {
+            deviationContent += 'No deviations found. All goals were met.\n';
+        }
+        else {
+            deviationContent += '## Deviations Identified\n\n';
+            for (const dev of data.deviations) {
+                deviationContent += `### ${dev.description}\n`;
+                deviationContent += `- Type: ${dev.type}\n`;
+                deviationContent += `- Severity: ${dev.severity}\n\n`;
+            }
+            if (data.rootCauses.length > 0) {
+                deviationContent += '## Root Cause Analysis\n\n';
+                for (const cause of data.rootCauses) {
+                    deviationContent += `### ${cause.category}\n`;
+                    deviationContent += `${cause.description}\n\n`;
+                }
+            }
+        }
+        writeFileSync(join(checkDir, 'deviation.md'), deviationContent);
+    }
+    /**
+     * Execute the Act phase
+     */
+    async executeActPhase(startTime) {
+        await Promise.resolve();
+        const evaluationPath = join(getCheckDir(this.taskId), 'evaluation.md');
+        const deviationPath = join(getCheckDir(this.taskId), 'deviation.md');
+        const actDir = getActDir(this.taskId);
+        const phaseConfig = this.config.phases.act;
+        if (!this.dryRun) {
+            ensureDir(actDir);
+        }
+        // Parse check results
+        const evaluationResults = parseEvaluationResults(evaluationPath);
+        const deviationAnalysis = existsSync(deviationPath)
+            ? parseDeviationAnalysis(deviationPath)
+            : { deviations: [], rootCauses: [] };
+        // Identify successes and failures
+        const successes = identifySuccesses(evaluationResults);
+        const failures = identifyFailures(deviationAnalysis, evaluationResults);
+        const unresolvedIssues = identifyUnresolvedIssues(evaluationResults, deviationAnalysis);
+        console.log(chalk.gray(`    Successes: ${String(successes.length)}`));
+        console.log(chalk.gray(`    Failures: ${String(failures.length)}`));
+        console.log(chalk.gray(`    Unresolved: ${String(unresolvedIssues.length)}`));
+        if (!this.dryRun) {
+            // Generate improvement.md
+            let improvementContent = renderTemplate(improvementTemplate, { taskId: this.taskId });
+            if (failures.length > 0) {
+                improvementContent += '\n## Corrective Actions\n\n';
+                for (const failure of failures) {
+                    improvementContent += `- **${failure.goal}**: ${failure.lesson ?? failure.deviation}\n`;
+                }
+                improvementContent += '\n## Lessons Learned\n\n';
+                for (const failure of failures) {
+                    if (failure.lesson) {
+                        improvementContent += `- ${failure.lesson}\n`;
+                    }
+                }
+            }
+            writeFileSync(join(actDir, 'improvement.md'), improvementContent);
+            // Generate standardization.md if enabled
+            if (phaseConfig.standardize && successes.length > 0) {
+                const practices = extractSuccessfulPractices(successes);
+                const recommendations = generateStandardizationRecommendations(practices);
+                const standardizationContent = formatStandardizationDocument(practices, recommendations);
+                writeFileSync(join(actDir, 'standardization.md'), standardizationContent);
+            }
+            // Generate next-cycle-items.md if enabled
+            if (phaseConfig.carryForward && unresolvedIssues.length > 0) {
+                let nextCycleContent = `# Next Cycle Planning Items\n\n`;
+                nextCycleContent += `Items from task ${this.taskId}:\n\n`;
+                for (const issue of unresolvedIssues) {
+                    nextCycleContent += `- [ ] ${issue.description} (Priority: ${issue.priority})\n`;
+                }
+                writeFileSync(join(actDir, 'next-cycle-items.md'), nextCycleContent);
+            }
+            // Update status
+            if (phaseConfig.completeOnSuccess) {
+                updateTaskStatus(this.taskId, 'completed');
+                console.log(chalk.green('    Task marked as completed'));
+            }
+            else {
+                updateTaskStatus(this.taskId, 'acting');
+            }
+        }
+        return {
+            phase: 'act',
+            success: true,
+            startTime,
+            endTime: new Date(),
+            details: {
+                successes: successes.length,
+                failures: failures.length,
+                unresolvedIssues: unresolvedIssues.length
+            }
+        };
+    }
+    /**
+     * Get current pipeline state
+     */
+    getState() {
+        return { ...this.state };
+    }
+}
+/**
+ * Get the current pipeline state for a task
+ */
+export function getPipelineState(taskId) {
+    const status = getTaskStatus(taskId);
+    const completedPhases = [];
+    if (existsSync(join(getDoDir(taskId), 'execution.md'))) {
+        completedPhases.push('do');
+    }
+    if (existsSync(join(getCheckDir(taskId), 'evaluation.md'))) {
+        completedPhases.push('check');
+    }
+    if (existsSync(join(getActDir(taskId), 'improvement.md'))) {
+        completedPhases.push('act');
+    }
+    const currentPhase = status === 'doing' ? 'do'
+        : status === 'checking' ? 'check'
+            : status === 'acting' ? 'act'
+                : undefined;
+    return {
+        taskId,
+        ...(currentPhase != null ? { currentPhase } : {}),
+        completedPhases,
+        phaseResults: []
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/utils/skills.d.ts

@@ -1,3 +1,11 @@
-export declare function createSkill(description: string, taskId: string): string | null;
-export declare function executeSkill(skillName: string, _taskId: string, parallel?: boolean, maxConcurrency?: number): Promise<void>;
+export interface CreateSkillOptions {
+    taskId?: string;
+    tags?: string[];
+}
+/**
+ * Create a skill from a plan (tmd plan --skill). Generates name from description.
+ * Options.tags is applied when provided; options.taskId is used as createdFrom when provided.
+ */
+export declare function createSkill(description: string, taskId: string, options?: CreateSkillOptions): string | null;
+export declare function executeSkill(skillName: string, taskId: string, parallel?: boolean, maxConcurrency?: number, params?: Record<string, string>): Promise<void>;
 //# sourceMappingURL=skills.d.ts.map