@tmddev/tmd 0.1.0

package/dist/utils/task-chain.js

@@ -0,0 +1,146 @@
+/**
+ * Build dependency graph from tasks
+ * Returns a map of task index to array of dependency indices
+ */
+export function buildDependencyGraph(tasks) {
+    const graph = new Map();
+    for (const task of tasks) {
+        const deps = task.dependencies ?? [];
+        graph.set(task.index, deps);
+    }
+    return graph;
+}
+/**
+ * Detect cycles in dependency graph using DFS
+ */
+export function detectCycles(graph) {
+    const visited = new Set();
+    const recStack = new Set();
+    const cycle = [];
+    function dfs(node) {
+        if (recStack.has(node)) {
+            // Found cycle
+            cycle.push(node);
+            return true;
+        }
+        if (visited.has(node)) {
+            return false;
+        }
+        visited.add(node);
+        recStack.add(node);
+        const deps = graph.get(node) ?? [];
+        for (const dep of deps) {
+            if (dfs(dep)) {
+                if (cycle.length === 0 || cycle[0] !== node) {
+                    cycle.push(node);
+                }
+                return true;
+            }
+        }
+        recStack.delete(node);
+        return false;
+    }
+    for (const node of graph.keys()) {
+        if (!visited.has(node)) {
+            if (dfs(node)) {
+                return cycle.reverse();
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Topological sort to determine execution order
+ * Returns array of arrays, where each inner array contains tasks that can run concurrently
+ */
+export function topologicalSort(tasks, graph) {
+    const inDegree = new Map();
+    const levels = [];
+    // Initialize in-degree for all tasks
+    for (const task of tasks) {
+        inDegree.set(task.index, 0);
+    }
+    // Calculate in-degrees
+    for (const task of tasks) {
+        const deps = graph.get(task.index) ?? [];
+        for (const dep of deps) {
+            const current = inDegree.get(dep) ?? 0;
+            inDegree.set(dep, current + 1);
+        }
+    }
+    // Build execution levels
+    let currentLevel = [];
+    const remaining = new Set(tasks.map(t => t.index));
+    while (remaining.size > 0) {
+        // Find tasks with no dependencies (in-degree = 0)
+        for (const taskIndex of remaining) {
+            const deps = graph.get(taskIndex) ?? [];
+            const hasUnresolvedDeps = deps.some(dep => remaining.has(dep));
+            if (!hasUnresolvedDeps) {
+                currentLevel.push(taskIndex);
+            }
+        }
+        if (currentLevel.length === 0) {
+            // Circular dependency detected (should be caught earlier, but handle gracefully)
+            break;
+        }
+        levels.push([...currentLevel]);
+        // Remove completed tasks and update in-degrees
+        for (const taskIndex of currentLevel) {
+            remaining.delete(taskIndex);
+            const deps = graph.get(taskIndex) ?? [];
+            for (const dep of deps) {
+                const current = inDegree.get(dep) ?? 0;
+                inDegree.set(dep, Math.max(0, current - 1));
+            }
+        }
+        currentLevel = [];
+    }
+    return levels;
+}
+/**
+ * Execute tasks concurrently with dependency management
+ * @param tasks Array of tasks to execute
+ * @param executeTask Function to execute a single task
+ * @param maxConcurrency Maximum number of concurrent executions
+ * @returns Array of execution results
+ */
+export async function executeConcurrently(tasks, executeTask, maxConcurrency = Infinity) {
+    const graph = buildDependencyGraph(tasks);
+    // Check for cycles
+    const cycle = detectCycles(graph);
+    if (cycle) {
+        throw new Error(`Circular dependency detected: ${cycle.map(String).join(' -> ')}`);
+    }
+    // Get execution order
+    const executionLevels = topologicalSort(tasks, graph);
+    const results = [];
+    const taskMap = new Map(tasks.map(t => [t.index, t]));
+    // Execute level by level
+    for (const level of executionLevels) {
+        const levelTasks = level.map(idx => taskMap.get(idx)).filter((task) => task !== undefined);
+        // Execute tasks in batches to respect concurrency limit
+        for (let i = 0; i < levelTasks.length; i += maxConcurrency) {
+            const batch = levelTasks.slice(i, i + maxConcurrency);
+            const batchPromises = batch.map(task => executeTask(task));
+            // Wait for all tasks in this batch to complete
+            const batchResults = await Promise.allSettled(batchPromises);
+            for (const result of batchResults) {
+                if (result.status === 'fulfilled') {
+                    results.push(result.value);
+                }
+                else {
+                    // Handle rejected promises
+                    results.push({
+                        taskIndex: -1,
+                        success: false,
+                        error: result.reason instanceof Error ? result.reason.message : String(result.reason ?? 'Unknown error'),
+                        duration: 0
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=task-chain.js.map

package/dist/utils/task-id.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate task ID in format: YYYYMMDD-description
+ */
+export declare function generateTaskId(description: string): string;
+//# sourceMappingURL=task-id.d.ts.map

package/dist/utils/task-id.js

@@ -0,0 +1,15 @@
+/**
+ * Generate task ID in format: YYYYMMDD-description
+ */
+export function generateTaskId(description) {
+    const date = new Date();
+    const datePart = date.toISOString().split('T')[0] ?? '';
+    const dateStr = datePart.replace(/-/g, '');
+    const desc = description
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .substring(0, 50);
+    return `${dateStr}-${desc}`;
+}
+//# sourceMappingURL=task-id.js.map

package/dist/utils/task-status.d.ts

@@ -0,0 +1,6 @@
+import type { TaskMetadata } from '../types.js';
+export type TaskStatus = 'planning' | 'doing' | 'checking' | 'acting' | 'completed';
+export declare function getTaskStatus(taskId: string): TaskStatus;
+export declare function updateTaskStatus(taskId: string, status: TaskStatus): void;
+export declare function getTaskMetadata(taskId: string): TaskMetadata;
+//# sourceMappingURL=task-status.d.ts.map

package/dist/utils/task-status.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getPlanDir, getDoDir, getCheckDir, getActDir, ensureDir } from './paths.js';
+export function getTaskStatus(taskId) {
+    // Check phase files to determine status
+    if (existsSync(join(getActDir(taskId), 'improvement.md'))) {
+        // Check if completed
+        const metadataPath = join(getPlanDir(taskId), 'metadata.json');
+        if (existsSync(metadataPath)) {
+            try {
+                const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
+                if (metadata.completed) {
+                    return 'completed';
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        return 'acting';
+    }
+    if (existsSync(join(getCheckDir(taskId), 'evaluation.md'))) {
+        return 'checking';
+    }
+    if (existsSync(join(getDoDir(taskId), 'execution.md'))) {
+        return 'doing';
+    }
+    if (existsSync(join(getPlanDir(taskId), 'plan.md'))) {
+        return 'planning';
+    }
+    return 'planning';
+}
+export function updateTaskStatus(taskId, status) {
+    const planDir = getPlanDir(taskId);
+    const metadataPath = join(planDir, 'metadata.json');
+    // Ensure plan directory exists before writing metadata
+    ensureDir(planDir);
+    const metadata = existsSync(metadataPath)
+        ? JSON.parse(readFileSync(metadataPath, 'utf-8'))
+        : {};
+    metadata.status = status;
+    metadata.lastUpdated = new Date().toISOString();
+    if (status === 'completed') {
+        metadata.completed = true;
+        metadata.completedAt = new Date().toISOString();
+    }
+    writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+}
+export function getTaskMetadata(taskId) {
+    const metadataPath = join(getPlanDir(taskId), 'metadata.json');
+    if (existsSync(metadataPath)) {
+        try {
+            return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+//# sourceMappingURL=task-status.js.map

package/dist/utils/task-validator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Task size validation utilities
+ * Validates that tasks are atomic and completable in 10 seconds to 10 minutes (pee-break sized)
+ */
+export type TaskSizeCategory = 'atomic' | 'medium' | 'large';
+export interface TaskSizeEstimate {
+    category: TaskSizeCategory;
+    estimatedMinutes: number;
+    confidence: 'high' | 'medium' | 'low';
+    reasons: string[];
+}
+export interface ValidationResult {
+    isValid: boolean;
+    estimate: TaskSizeEstimate;
+    suggestions?: string[];
+    warning?: string;
+}
+/**
+ * Estimates task size based on description
+ */
+export declare function estimateTaskSize(taskDescription: string): TaskSizeEstimate;
+/**
+ * Validates if task is atomic (10 seconds to 10 minutes)
+ */
+export declare function validateTaskSize(taskDescription: string): ValidationResult;
+/**
+ * Suggests how to break down a large task
+ */
+export declare function suggestTaskBreakdown(taskDescription: string, _estimate?: TaskSizeEstimate): string[];
+/**
+ * Validates multiple tasks and returns summary
+ */
+export declare function validateTasks(taskDescriptions: string[]): {
+    results: ValidationResult[];
+    summary: {
+        total: number;
+        valid: number;
+        invalid: number;
+        large: number;
+    };
+};
+//# sourceMappingURL=task-validator.d.ts.map

package/dist/utils/task-validator.js

@@ -0,0 +1,178 @@
+/**
+ * Task size validation utilities
+ * Validates that tasks are atomic and completable in 10 seconds to 10 minutes (pee-break sized)
+ */
+/**
+ * Keywords that suggest large tasks
+ */
+const LARGE_TASK_KEYWORDS = [
+    'implement',
+    'build',
+    'create system',
+    'develop',
+    'design',
+    'architecture',
+    'refactor entire',
+    'migrate',
+    'rewrite',
+];
+/**
+ * Keywords that suggest medium tasks
+ */
+const MEDIUM_TASK_KEYWORDS = [
+    'create',
+    'add',
+    'update',
+    'modify',
+    'integrate',
+    'configure',
+];
+/**
+ * Keywords that suggest atomic tasks
+ */
+const ATOMIC_TASK_KEYWORDS = [
+    'fix',
+    'update',
+    'add import',
+    'change',
+    'rename',
+    'remove',
+    'delete',
+];
+/**
+ * Conjunctions that suggest compound tasks
+ */
+const COMPOUND_INDICATORS = [' and ', ' then ', ' after ', ' followed by ', ' plus ', ' along with '];
+/**
+ * Estimates task size based on description
+ */
+export function estimateTaskSize(taskDescription) {
+    const description = taskDescription.toLowerCase().trim();
+    const reasons = [];
+    let estimatedMinutes = 2; // Default to small task
+    let category = 'atomic';
+    let confidence = 'medium';
+    // Check for compound tasks (multiple actions)
+    const hasCompound = COMPOUND_INDICATORS.some(indicator => description.includes(indicator));
+    if (hasCompound) {
+        reasons.push('Contains conjunctions suggesting multiple actions');
+        estimatedMinutes = 15;
+        category = 'large';
+        confidence = 'high';
+    }
+    // Check for large task keywords
+    const hasLargeKeyword = LARGE_TASK_KEYWORDS.some(keyword => description.includes(keyword));
+    if (hasLargeKeyword && !hasCompound) {
+        const foundKeyword = LARGE_TASK_KEYWORDS.find(k => description.includes(k));
+        reasons.push(`Contains large task keyword: "${foundKeyword ?? 'unknown'}"`);
+        estimatedMinutes = 10;
+        category = 'large';
+        confidence = 'high';
+    }
+    // Check for medium task keywords
+    const hasMediumKeyword = MEDIUM_TASK_KEYWORDS.some(keyword => description.includes(keyword));
+    if (hasMediumKeyword && !hasLargeKeyword && !hasCompound) {
+        const foundKeyword = MEDIUM_TASK_KEYWORDS.find(k => description.includes(k));
+        reasons.push(`Contains medium task keyword: "${foundKeyword ?? 'unknown'}"`);
+        estimatedMinutes = 5;
+        category = 'medium';
+        confidence = 'medium';
+    }
+    // Check description length
+    const wordCount = description.split(/\s+/).length;
+    if (wordCount > 15 && !hasCompound && !hasLargeKeyword) {
+        reasons.push(`Long description (${String(wordCount)} words) suggests complexity`);
+        estimatedMinutes = Math.min(estimatedMinutes + 3, 12);
+        if (category === 'atomic') {
+            category = 'medium';
+        }
+        confidence = 'low';
+    }
+    // Check for atomic task keywords (overrides if found)
+    const hasAtomicKeyword = ATOMIC_TASK_KEYWORDS.some(keyword => description.includes(keyword));
+    if (hasAtomicKeyword && !hasCompound && !hasLargeKeyword && wordCount <= 10) {
+        const foundKeyword = ATOMIC_TASK_KEYWORDS.find(k => description.includes(k));
+        reasons.push(`Contains atomic task keyword: "${foundKeyword ?? 'unknown'}"`);
+        estimatedMinutes = 1;
+        category = 'atomic';
+        confidence = 'high';
+    }
+    // If no specific indicators, assume small atomic task
+    if (reasons.length === 0) {
+        reasons.push('No complexity indicators found');
+        estimatedMinutes = 2;
+        category = 'atomic';
+        confidence = 'low';
+    }
+    return {
+        category,
+        estimatedMinutes,
+        confidence,
+        reasons,
+    };
+}
+/**
+ * Validates if task is atomic (10 seconds to 10 minutes)
+ */
+export function validateTaskSize(taskDescription) {
+    const estimate = estimateTaskSize(taskDescription);
+    const isValid = estimate.category === 'atomic' ||
+        (estimate.category === 'medium' && estimate.estimatedMinutes <= 10);
+    const result = {
+        isValid,
+        estimate,
+    };
+    if (!isValid) {
+        result.warning = `Task appears to be ${estimate.category} sized (estimated ${String(estimate.estimatedMinutes)} minutes), exceeding the pee-break (10 seconds to 10 minutes) guideline`;
+        result.suggestions = suggestTaskBreakdown(taskDescription, estimate);
+    }
+    return result;
+}
+/**
+ * Suggests how to break down a large task
+ */
+export function suggestTaskBreakdown(taskDescription, _estimate) {
+    const suggestions = [];
+    const description = taskDescription.toLowerCase();
+    // Check for compound tasks
+    if (description.includes(' and ')) {
+        suggestions.push('Break down by separating actions: split "X and Y" into two separate tasks');
+    }
+    if (description.includes(' then ') || description.includes(' after ')) {
+        suggestions.push('Break down by sequential steps: create separate tasks for each step');
+    }
+    // Check for implementation tasks
+    if (description.includes('implement') || description.includes('build')) {
+        suggestions.push('Break down by components: identify sub-components and create tasks for each');
+        suggestions.push('Break down by phases: separate design, implementation, and testing into different tasks');
+    }
+    // Check for system-level tasks
+    if (description.includes('system') || description.includes('architecture')) {
+        suggestions.push('Break down by modules: create tasks for each module or component');
+        suggestions.push('Break down by layers: separate frontend, backend, and integration tasks');
+    }
+    // Generic suggestions
+    if (suggestions.length === 0) {
+        suggestions.push('Break down into sequential steps');
+        suggestions.push('Identify sub-components and create separate tasks');
+        suggestions.push('Consider splitting by functionality or features');
+    }
+    // Add examples
+    suggestions.push('Examples of good atomic tasks: "Add import statement", "Update function signature", "Create test file"');
+    suggestions.push('Examples to avoid: "Implement authentication and authorization", "Create API and update frontend"');
+    return suggestions;
+}
+/**
+ * Validates multiple tasks and returns summary
+ */
+export function validateTasks(taskDescriptions) {
+    const results = taskDescriptions.map(validateTaskSize);
+    const summary = {
+        total: results.length,
+        valid: results.filter(r => r.isValid).length,
+        invalid: results.filter(r => !r.isValid).length,
+        large: results.filter(r => r.estimate.category === 'large').length,
+    };
+    return { results, summary };
+}
+//# sourceMappingURL=task-validator.js.map

package/dist/utils/tasks.d.ts

@@ -0,0 +1,27 @@
+export interface Task {
+    content: string;
+    completed: boolean;
+    index: number;
+    dependencies?: number[];
+}
+/**
+ * Extract tasks from plan.md's Tasks section
+ * Parses `- [ ]` and `- [x]` items from the ## Tasks section
+ */
+export declare function extractTasks(planPath: string): Task[];
+/**
+ * Update task status in plan.md
+ * Updates the task at given index from `- [ ]` to `- [x]` or vice versa
+ */
+export declare function updateTaskStatus(planPath: string, taskIndex: number, completed: boolean): void;
+/**
+ * Detect skill reference in task text
+ * Looks for patterns like [skill:name] or [skill:name:args]
+ */
+export declare function detectSkillReference(taskContent: string): string | null;
+/**
+ * Parse dependencies from task content
+ * Looks for patterns like [depends:task-0,task-2] or [depends:0,2]
+ */
+export declare function parseDependencies(taskContent: string): number[];
+//# sourceMappingURL=tasks.d.ts.map

package/dist/utils/tasks.js

@@ -0,0 +1,125 @@
+import { readFileSync, writeFileSync } from 'fs';
+/**
+ * Extract tasks from plan.md's Tasks section
+ * Parses `- [ ]` and `- [x]` items from the ## Tasks section
+ */
+export function extractTasks(planPath) {
+    const content = readFileSync(planPath, 'utf-8');
+    const lines = content.split('\n');
+    const tasks = [];
+    let inTasksSection = false;
+    let taskIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const trimmed = line.trim();
+        // Detect Tasks section header
+        if (trimmed.startsWith('##') && trimmed.toLowerCase().includes('tasks')) {
+            inTasksSection = true;
+            continue;
+        }
+        // Stop at next section (## header)
+        if (inTasksSection && trimmed.startsWith('##') && !trimmed.toLowerCase().includes('tasks')) {
+            break;
+        }
+        // Parse task items
+        if (inTasksSection) {
+            const taskMatch = trimmed.match(/^-\s+\[([ x])\]\s+(.+)$/);
+            if (taskMatch?.[1] && taskMatch[2]) {
+                const completed = taskMatch[1] === 'x';
+                const taskContent = taskMatch[2];
+                const dependencies = parseDependencies(taskContent);
+                const task = {
+                    content: taskContent,
+                    completed,
+                    index: taskIndex
+                };
+                if (dependencies.length > 0) {
+                    task.dependencies = dependencies;
+                }
+                tasks.push(task);
+                taskIndex++;
+            }
+        }
+    }
+    return tasks;
+}
+/**
+ * Update task status in plan.md
+ * Updates the task at given index from `- [ ]` to `- [x]` or vice versa
+ */
+export function updateTaskStatus(planPath, taskIndex, completed) {
+    const content = readFileSync(planPath, 'utf-8');
+    const lines = content.split('\n');
+    let inTasksSection = false;
+    let currentTaskIndex = 0;
+    let modified = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const trimmed = line.trim();
+        // Detect Tasks section header
+        if (trimmed.startsWith('##') && trimmed.toLowerCase().includes('tasks')) {
+            inTasksSection = true;
+            continue;
+        }
+        // Stop at next section (## header)
+        if (inTasksSection && trimmed.startsWith('##') && !trimmed.toLowerCase().includes('tasks')) {
+            break;
+        }
+        // Update task item
+        if (inTasksSection) {
+            const taskMatch = trimmed.match(/^-\s+\[([ x])\]\s+(.+)$/);
+            if (taskMatch?.[1] && taskMatch[2]) {
+                if (currentTaskIndex === taskIndex) {
+                    const newCheckbox = completed ? '[x]' : '[ ]';
+                    const taskContent = taskMatch[2];
+                    // Preserve original indentation
+                    const indent = line.match(/^(\s*)/)?.[1] ?? '';
+                    lines[i] = `${indent}- ${newCheckbox} ${taskContent}`;
+                    modified = true;
+                    break;
+                }
+                currentTaskIndex++;
+            }
+        }
+    }
+    if (modified) {
+        writeFileSync(planPath, lines.join('\n'), 'utf-8');
+    }
+}
+/**
+ * Detect skill reference in task text
+ * Looks for patterns like [skill:name] or [skill:name:args]
+ */
+export function detectSkillReference(taskContent) {
+    const skillMatch = taskContent.match(/\[skill:([^\]]+)\]/);
+    return skillMatch?.[1] ?? null;
+}
+/**
+ * Parse dependencies from task content
+ * Looks for patterns like [depends:task-0,task-2] or [depends:0,2]
+ */
+export function parseDependencies(taskContent) {
+    const dependsMatch = taskContent.match(/\[depends:([^\]]+)\]/);
+    if (!dependsMatch?.[1]) {
+        return [];
+    }
+    const deps = [];
+    const depList = dependsMatch[1].split(',');
+    for (const dep of depList) {
+        const trimmed = dep.trim();
+        // Support both "task-0" and "0" formats
+        const indexMatch = trimmed.match(/(?:task-)?(\d+)/);
+        if (indexMatch?.[1]) {
+            const index = parseInt(indexMatch[1], 10);
+            if (!isNaN(index)) {
+                deps.push(index);
+            }
+        }
+    }
+    return deps;
+}
+//# sourceMappingURL=tasks.js.map

package/dist/utils/templates.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Template generators for PDCA phase documents
+ * All templates are in English as per specification
+ */
+export declare const planTemplate = "# Plan: {{description}}\n\n## Why\n<!-- Define the problem or improvement opportunity -->\n<!-- What issue are we solving? What opportunity are we pursuing? -->\n\n## Goals\n<!-- SMART Goals: Specific, Measurable, Achievable, Relevant, Time-bound -->\n<!-- Example: \"Reduce image load time by 50% within 2 weeks\" -->\n- [ ] Goal 1:\n- [ ] Goal 2:\n\n## What Changes\n<!-- Specific changes to be made -->\n<!-- List concrete deliverables and modifications -->\n-\n\n## Impact\n<!-- Affected systems, files, processes, or stakeholders -->\n- Affected areas:\n- Dependencies:\n- Risks:\n\n## Tasks\n<!-- Implementation steps as checklist -->\n<!-- \n  Task Size Guidelines: Ten seconds to Ten minutes Task Markdown Driven Development!\n  Tasks should be atomic and completable in 10 seconds to 10 minutes (pee-break sized).\n  - Each task should be a single, focused action\n  - Avoid compound tasks (tasks with \"and\" or multiple actions)\n  - Break down large tasks into smaller atomic tasks\n  \n  Examples of good atomic tasks:\n  - \"Add import statement\"\n  - \"Update function signature\"\n  - \"Create test file\"\n  - \"Fix typo in documentation\"\n  \n  Examples of tasks to break down:\n  - \"Implement authentication and authorization\" \u2192 Break into: \"Add auth middleware\", \"Create login endpoint\", \"Add password validation\"\n  - \"Create API and update frontend\" \u2192 Break into: \"Create API endpoint\", \"Update frontend component\", \"Add API integration\"\n-->\n- [ ] 1.\n- [ ] 2.\n- [ ] 3.\n\n## OpenSpec Change\n<!-- Link to OpenSpec change proposal if applicable -->\n";
+export declare const executionTemplate = "# Execution: {{taskId}}\n\n## Actions Taken\n<!-- Document actions performed -->\n\n## Data Collected\n<!-- Record data collected during execution -->\n\n## Observations\n<!-- Note any observations or insights -->\n\n## Issues Encountered\n<!-- Document any problems or blockers -->\n\n## Time Tracking\n<!-- Track time spent if applicable -->\n";
+export declare const evaluationTemplate = "# Evaluation: {{taskId}}\n\n## Results Summary\n<!-- Summarize execution results -->\n\n## Comparison with Plan\n<!-- Compare actual results with planned objectives -->\n\n| Objective | Planned | Actual | Status |\n|-----------|---------|--------|--------|\n|           |         |        |        |\n\n## Deviations Identified\n<!-- List any deviations from the plan -->\n\n## Root Cause Analysis\n<!-- Analyze causes of deviations -->\n\n## Lessons Learned\n<!-- Document insights and learnings -->\n";
+export declare const improvementTemplate = "# Improvement Actions: {{taskId}}\n\n## Corrective Actions\n<!-- Actions to address identified issues -->\n\n## Preventive Measures\n<!-- Measures to prevent similar issues in future -->\n\n## Standardization Opportunities\n<!-- Practices that can be standardized -->\n\n## Next Cycle Planning\n<!-- Plan for next PDCA iteration -->\n";
+export declare const resourcesTemplate = "# Resources: {{description}}\n\n## People / Roles\n<!-- Who is needed for this task? -->\n-\n\n## Tools & Systems\n<!-- What tools, systems, or infrastructure is required? -->\n-\n\n## Data Requirements\n<!-- What data or information is needed? -->\n-\n\n## Time Estimate\n<!-- Estimated effort and timeline -->\n- Effort:\n- Timeline:\n";
+export declare const standardizationTemplate = "# Standardization: {{taskId}}\n\n## Successful Practices\n<!-- Document practices that worked well -->\n\n## Reusable Patterns\n<!-- Patterns that can be reused -->\n\n## Standard Operating Procedures\n<!-- Document SOPs if applicable -->\n";
+export declare function renderTemplate(template: string, vars: Record<string, string>): string;
+//# sourceMappingURL=templates.d.ts.map