maskweaver 0.9.6 → 0.9.7

package/dist/weave/gherkin.js

@@ -0,0 +1,307 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+export function parseGherkinText(text) {
+    const lines = text.split(/\r?\n/).map(l => l.trim());
+    let feature = '';
+    let description = '';
+    const scenarios = [];
+    let current = null;
+    let inFeature = false;
+    for (const line of lines) {
+        if (!line || line.startsWith('#'))
+            continue;
+        const featureMatch = /^Feature:\s*(.+)$/i.exec(line);
+        if (featureMatch) {
+            feature = featureMatch[1].trim();
+            inFeature = true;
+            current = null;
+            continue;
+        }
+        if (!inFeature)
+            continue;
+        const scenarioMatch = /^Scenario:\s*(.+)$/i.exec(line);
+        if (scenarioMatch) {
+            if (current)
+                scenarios.push(current);
+            current = { name: scenarioMatch[1].trim(), given: [], when: [], then: [] };
+            continue;
+        }
+        if (!current) {
+            if (!scenarioMatch && feature && !line.startsWith('Given') && !line.startsWith('When') && !line.startsWith('Then') && !line.startsWith('And')) {
+                description += (description ? ' ' : '') + line;
+            }
+            continue;
+        }
+        const stepMatch = /^(Given|When|Then|And)\s+(.+)$/i.exec(line);
+        if (stepMatch) {
+            const keyword = stepMatch[1].toLowerCase();
+            const step = stepMatch[2].trim();
+            switch (keyword) {
+                case 'given':
+                    current.given.push(step);
+                    break;
+                case 'when':
+                    current.when.push(step);
+                    break;
+                case 'then':
+                    current.then.push(step);
+                    break;
+                case 'and':
+                    if (current.then.length > 0)
+                        current.then.push(step);
+                    else if (current.when.length > 0)
+                        current.when.push(step);
+                    else
+                        current.given.push(step);
+                    break;
+            }
+        }
+    }
+    if (current)
+        scenarios.push(current);
+    if (!feature && scenarios.length === 0)
+        return null;
+    return { feature: feature || 'Untitled', description, scenarios };
+}
+export function parseGherkinBlock(block) {
+    const parsed = parseGherkinText(block);
+    if (!parsed)
+        return [];
+    return parsed.scenarios.map(scenario => ({
+        feature: parsed.feature,
+        scenario: scenario.name,
+        given: scenario.given,
+        when: scenario.when,
+        then: scenario.then,
+    }));
+}
+export function formatGherkinScenario(scenario) {
+    const lines = [];
+    lines.push(`  Scenario: ${scenario.scenario}`);
+    for (const g of scenario.given)
+        lines.push(`    Given ${g}`);
+    for (const w of scenario.when)
+        lines.push(`    When ${w}`);
+    for (const t of scenario.then)
+        lines.push(`    Then ${t}`);
+    return lines.join('\n');
+}
+export function formatGherkinFeature(featureName, scenarios) {
+    const lines = [];
+    lines.push(`Feature: ${featureName}`);
+    lines.push('');
+    for (const scenario of scenarios) {
+        lines.push(formatGherkinScenario(scenario));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatGherkinForTask(task) {
+    if (!task.acceptanceCriteria || task.acceptanceCriteria.length === 0)
+        return '';
+    return formatGherkinFeature(task.name, task.acceptanceCriteria);
+}
+export function formatGherkinChecklist(scenarios) {
+    const lines = [];
+    for (const scenario of scenarios) {
+        lines.push(`- [ ] ${scenario.scenario}`);
+        for (const t of scenario.then) {
+            lines.push(`    - Then ${t}`);
+        }
+    }
+    return lines.join('\n');
+}
+const FEATURES_DIR = '.opencode/weave/features';
+function getFeaturesDir(basePath) {
+    return path.join(basePath, FEATURES_DIR);
+}
+export async function ensureFeaturesDir(basePath) {
+    const dir = getFeaturesDir(basePath);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function writeFeatureFile(basePath, phaseId, phaseName, scenarios) {
+    if (scenarios.length === 0)
+        return '';
+    const dir = await ensureFeaturesDir(basePath);
+    const fileName = `${phaseId.toLowerCase()}.feature`;
+    const filePath = path.join(dir, fileName);
+    const content = formatGherkinFeature(phaseName, scenarios);
+    await writeFile(filePath, content, 'utf-8');
+    return path.relative(basePath, filePath).replace(/\\/g, '/');
+}
+export async function writeAllFeatureFiles(basePath, phases) {
+    const results = new Map();
+    for (const phase of phases) {
+        const allScenarios = collectPhaseScenarios(phase);
+        if (allScenarios.length === 0)
+            continue;
+        const featurePath = await writeFeatureFile(basePath, phase.id, phase.name, allScenarios);
+        if (featurePath) {
+            results.set(phase.id, featurePath);
+        }
+    }
+    return results;
+}
+function collectPhaseScenarios(phase) {
+    const scenarios = [];
+    if (phase.acceptanceCriteria) {
+        scenarios.push(...phase.acceptanceCriteria);
+    }
+    for (const task of phase.tasks) {
+        if (task.acceptanceCriteria) {
+            scenarios.push(...task.acceptanceCriteria);
+        }
+    }
+    return scenarios;
+}
+export function generateGherkinForPhase(phase) {
+    return [
+        {
+            feature: phase.name,
+            scenario: `${phase.name} - 정상 동작`,
+            given: [`${phase.name} 관련 기능이 구현되어 있다`],
+            when: [`유저가 ${phase.name} 기능을 사용한다`],
+            then: [`${phase.doneWhen}`],
+        },
+        {
+            feature: phase.name,
+            scenario: `${phase.name} - 에러 처리`,
+            given: [`${phase.name} 관련 기능이 구현되어 있다`],
+            when: [`유저가 ${phase.name} 기능을 비정상적으로 사용한다`],
+            then: ['적절한 에러 메시지가 표시된다'],
+        },
+    ];
+}
+export function generateGherkinForTask(task, phase) {
+    return {
+        feature: phase.name,
+        scenario: task.name,
+        given: [`${phase.name} 기능의 기본 환경이 준비되어 있다`],
+        when: [`${task.name}을/를 실행한다`],
+        then: [task.testCase || phase.doneWhen],
+    };
+}
+export function detectBDDFramework(projectPath) {
+    const checks = [
+        () => detectCucumber(projectPath),
+        () => detectJestCucumber(projectPath),
+        () => detectPytestBdd(projectPath),
+    ];
+    for (const check of checks) {
+        const result = check();
+        if (result.detected)
+            return result;
+    }
+    const featureDir = findFeatureDir(projectPath);
+    if (featureDir) {
+        return {
+            detected: true,
+            framework: 'unknown',
+            testCommand: null,
+            featureDir,
+        };
+    }
+    return { detected: false, framework: null, testCommand: null, featureDir: null };
+}
+function detectCucumber(projectPath) {
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return { detected: false, framework: null, testCommand: null, featureDir: null };
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        if (deps['@cucumber/cucumber']) {
+            const featureDir = findFeatureDir(projectPath) || 'features';
+            return {
+                detected: true,
+                framework: 'cucumber',
+                testCommand: `npx cucumber-js`,
+                featureDir,
+            };
+        }
+    }
+    catch { }
+    return { detected: false, framework: null, testCommand: null, featureDir: null };
+}
+function detectJestCucumber(projectPath) {
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return { detected: false, framework: null, testCommand: null, featureDir: null };
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        if (deps['jest-cucumber'] || deps['@jest-cucumber/core']) {
+            const featureDir = findFeatureDir(projectPath) || 'features';
+            return {
+                detected: true,
+                framework: 'jest-cucumber',
+                testCommand: `npx jest`,
+                featureDir,
+            };
+        }
+    }
+    catch { }
+    return { detected: false, framework: null, testCommand: null, featureDir: null };
+}
+function detectPytestBdd(projectPath) {
+    const indicators = [
+        path.join(projectPath, 'pyproject.toml'),
+        path.join(projectPath, 'requirements.txt'),
+    ];
+    for (const indicator of indicators) {
+        if (!fs.existsSync(indicator))
+            continue;
+        try {
+            const content = fs.readFileSync(indicator, 'utf-8');
+            if (content.includes('pytest-bdd')) {
+                const featureDir = findFeatureDir(projectPath) || 'features';
+                return {
+                    detected: true,
+                    framework: 'pytest-bdd',
+                    testCommand: 'pytest',
+                    featureDir,
+                };
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    return { detected: false, framework: null, testCommand: null, featureDir: null };
+}
+function findFeatureDir(projectPath) {
+    const candidates = ['features', 'test/features', 'tests/features', 'specs/features'];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(projectPath, candidate))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function generateGherkinVerificationPrompt(phase, task) {
+    const scenarios = task?.acceptanceCriteria || phase.acceptanceCriteria || [];
+    if (scenarios.length === 0)
+        return '';
+    const lines = [];
+    lines.push('### Acceptance Criteria (Gherkin)');
+    lines.push('');
+    lines.push('Verify each scenario is satisfied by the implementation:');
+    lines.push('');
+    for (const scenario of scenarios) {
+        lines.push(`**${scenario.scenario}**`);
+        for (const g of scenario.given)
+            lines.push(`- Given: ${g}`);
+        for (const w of scenario.when)
+            lines.push(`- When: ${w}`);
+        for (const t of scenario.then)
+            lines.push(`- Then: ${t}`);
+        lines.push('');
+    }
+    lines.push('For each scenario, check:');
+    lines.push('1. Are all "Given" preconditions met?');
+    lines.push('2. Can the "When" action be performed?');
+    lines.push('3. Do all "Then" expected outcomes hold?');
+    return lines.join('\n');
+}

package/dist/weave/phase-manager.js

@@ -149,6 +149,25 @@ function serializePlan(plan) {
         if (phase.completedAt) {
             lines.push(`    completed_at: ${yamlEscapeString(phase.completedAt)}`);
         }
+        if (phase.featurePath) {
+            lines.push(`    feature_path: ${yamlEscapeString(phase.featurePath)}`);
+        }
+        if (phase.acceptanceCriteria && phase.acceptanceCriteria.length > 0) {
+            lines.push('    acceptance_criteria:');
+            for (const ac of phase.acceptanceCriteria) {
+                lines.push(`      - feature: ${yamlEscapeString(ac.feature)}`);
+                lines.push(`        scenario: ${yamlEscapeString(ac.scenario)}`);
+                lines.push('        given:');
+                for (const g of ac.given)
+                    lines.push(`          - ${yamlEscapeString(g)}`);
+                lines.push('        when:');
+                for (const w of ac.when)
+                    lines.push(`          - ${yamlEscapeString(w)}`);
+                lines.push('        then:');
+                for (const t of ac.then)
+                    lines.push(`          - ${yamlEscapeString(t)}`);
+            }
+        }
         lines.push('    checklist:');
         for (const item of phase.checklist) {
             lines.push(`      - ${yamlEscapeString(item)}`);
@@ -185,6 +204,22 @@ function serializePlan(plan) {
             if (task.acceptanceRefs && task.acceptanceRefs.length > 0) {
                 lines.push(`        acceptance_refs: [${task.acceptanceRefs.map(ref => yamlEscapeString(ref)).join(', ')}]`);
             }
+            if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+                lines.push('        acceptance_criteria:');
+                for (const ac of task.acceptanceCriteria) {
+                    lines.push(`          - feature: ${yamlEscapeString(ac.feature)}`);
+                    lines.push(`            scenario: ${yamlEscapeString(ac.scenario)}`);
+                    lines.push('            given:');
+                    for (const g of ac.given)
+                        lines.push(`              - ${yamlEscapeString(g)}`);
+                    lines.push('            when:');
+                    for (const w of ac.when)
+                        lines.push(`              - ${yamlEscapeString(w)}`);
+                    lines.push('            then:');
+                    for (const t of ac.then)
+                        lines.push(`              - ${yamlEscapeString(t)}`);
+                }
+            }
             if (task.maskUsed) {
                 lines.push(`        mask_used: ${yamlEscapeString(task.maskUsed)}`);
             }
@@ -202,6 +237,27 @@ function serializePlan(plan) {
     }
     return lines.join('\n');
 }
+function deserializeGherkinList(raw) {
+    if (!raw || !Array.isArray(raw))
+        return undefined;
+    const scenarios = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const feature = item.feature || '';
+        const scenario = item.scenario || '';
+        if (!feature && !scenario)
+            continue;
+        scenarios.push({
+            feature,
+            scenario,
+            given: Array.isArray(item.given) ? item.given.filter((g) => typeof g === 'string') : [],
+            when: Array.isArray(item.when) ? item.when.filter((w) => typeof w === 'string') : [],
+            then: Array.isArray(item.then) ? item.then.filter((t) => typeof t === 'string') : [],
+        });
+    }
+    return scenarios.length > 0 ? scenarios : undefined;
+}
 export class PhaseManager {
     basePath;
     plan = null;
@@ -550,6 +606,7 @@ export class PhaseManager {
                     dependsOn: t.depends_on || t.dependsOn,
                     verify: t.verify,
                     acceptanceRefs: t.acceptance_refs || t.acceptanceRefs,
+                    acceptanceCriteria: deserializeGherkinList(t.acceptance_criteria || t.acceptanceCriteria),
                     retryCount: t.retry_count || t.retryCount || 0,
                     maxRetries: t.max_retries || t.maxRetries || 5,
                     lastError: t.last_error || t.lastError,
@@ -561,6 +618,8 @@ export class PhaseManager {
                 startedAt: p.started_at || p.startedAt,
                 completedAt: p.completed_at || p.completedAt,
                 masksUsed: p.masks_used || p.masksUsed,
+                acceptanceCriteria: deserializeGherkinList(p.acceptance_criteria || p.acceptanceCriteria),
+                featurePath: p.feature_path || p.featurePath,
             })),
         };
     }

package/dist/weave/stages/build.js

@@ -204,6 +204,22 @@ function generateBrief(task, phase, plan, agentTier, mask) {
             lines.push(`- [${v.kind}] ${v.value}`);
         lines.push(``);
     }
+    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+        lines.push(`### Acceptance Criteria (Gherkin)`);
+        lines.push(``);
+        lines.push(`Every scenario MUST pass before this task can be marked as completed.`);
+        lines.push(``);
+        for (const scenario of task.acceptanceCriteria) {
+            lines.push(`**Scenario: ${scenario.scenario}**`);
+            for (const g of scenario.given)
+                lines.push(`  Given ${g}`);
+            for (const w of scenario.when)
+                lines.push(`  When ${w}`);
+            for (const t of scenario.then)
+                lines.push(`  Then ${t}`);
+            lines.push(``);
+        }
+    }
     if (plan.structuralChanges && plan.structuralChanges.length > 0) {
         const agreed = plan.structuralChanges.filter(sc => sc.agreed);
         if (agreed.length > 0) {

package/dist/weave/stages/execute.d.ts

@@ -36,7 +36,7 @@ export declare function execute(options: ExecuteOptions): Promise<ExecuteResult>
 export interface VerificationLayer {
     name: string;
     order: number;
-    type: 'build' | 'test' | 'visual' | 'api' | 'accessibility';
+    type: 'build' | 'test' | 'visual' | 'api' | 'accessibility' | 'gherkin';
     enabled: boolean;
 }
 export interface VerificationResult {
@@ -55,6 +55,13 @@ export interface AIVerificationOptions {
     enablePlaywright?: boolean;
     enableDevTools?: boolean;
     mode?: 'quick' | 'full';
+    gherkinScenarios?: Array<{
+        feature: string;
+        scenario: string;
+        given: string[];
+        when: string[];
+        then: string[];
+    }>;
 }
 export declare function runAIVerification(options: AIVerificationOptions): Promise<{
     passed: boolean;

package/dist/weave/stages/execute.js

@@ -2,6 +2,7 @@ import { getOrchestrator } from '../orchestrator.js';
 import { getPhaseManager } from '../phase-manager.js';
 import { searchTroubleshooting } from '../knowledge/global.js';
 import { analyzeParallelOpportunities, formatParallelAnalysis } from '../bridge.js';
+import { detectBDDFramework } from '../gherkin.js';
 import { spawn } from 'node:child_process';
 import * as path from 'node:path';
 import { copyFile, mkdir } from 'node:fs/promises';
@@ -177,6 +178,50 @@ export function formatExecutionPlan(plan) {
         lines.push(formatParallelAnalysis(parallelAnalysis));
         lines.push('');
     }
+    const allScenarios = plan.taskPlans
+        .filter(tp => tp.task.acceptanceCriteria && tp.task.acceptanceCriteria.length > 0)
+        .flatMap(tp => tp.task.acceptanceCriteria);
+    if (allScenarios.length > 0) {
+        lines.push('### Acceptance Criteria (Gherkin)');
+        lines.push('');
+        lines.push('Each task MUST satisfy its acceptance criteria before marking as passed.');
+        lines.push('');
+        for (const tp of plan.taskPlans) {
+            if (!tp.task.acceptanceCriteria || tp.task.acceptanceCriteria.length === 0)
+                continue;
+            lines.push(`**${tp.task.name}** (${tp.task.id}):`);
+            for (const scenario of tp.task.acceptanceCriteria) {
+                lines.push(`  - Scenario: ${scenario.scenario}`);
+                for (const g of scenario.given)
+                    lines.push(`    - Given ${g}`);
+                for (const w of scenario.when)
+                    lines.push(`    - When ${w}`);
+                for (const t of scenario.then)
+                    lines.push(`    - Then ${t}`);
+            }
+            lines.push('');
+        }
+    }
+    const basePathForDetect = plan.taskPlans[0]?.task?.files?.[0]
+        ? path.dirname(plan.taskPlans[0].task.files[0])
+        : undefined;
+    if (allScenarios.length > 0 && basePathForDetect) {
+        try {
+            const bdd = detectBDDFramework(basePathForDetect);
+            if (bdd.detected) {
+                lines.push('### BDD Framework Detected');
+                lines.push('');
+                lines.push(`- Framework: ${bdd.framework}`);
+                if (bdd.testCommand)
+                    lines.push(`- Test command: \`${bdd.testCommand}\``);
+                if (bdd.featureDir)
+                    lines.push(`- Feature directory: \`${bdd.featureDir}\``);
+                lines.push('');
+            }
+        }
+        catch {
+        }
+    }
     lines.push('### Instructions');
     lines.push('');
     lines.push('For each task above, delegate using `Task(<agent_tier>)` with the specified mask.');
@@ -254,6 +299,9 @@ export async function runAIVerification(options) {
                 case 'accessibility':
                     result = await runAccessibilityVerification(options);
                     break;
+                case 'gherkin':
+                    result = await runGherkinVerification(options);
+                    break;
                 default:
                     continue;
             }
@@ -293,6 +341,7 @@ function getVerificationLayers(options) {
         { name: 'Screenshot', order: 6, type: 'visual', enabled: options.enableScreenshots ?? false },
         { name: 'APICheck', order: 7, type: 'api', enabled: !!options.devServerUrl },
         { name: 'Accessibility', order: 8, type: 'accessibility', enabled: false },
+        { name: 'GherkinAcceptance', order: 9, type: 'gherkin', enabled: (options.gherkinScenarios?.length ?? 0) > 0 },
     ];
 }
 async function runShellCommand(cmd, cwd, options) {
@@ -606,6 +655,62 @@ async function runAccessibilityVerification(options) {
     logs.push('[A11y] Would run axe-core accessibility scan');
     return { passed: true, logs, layer: 'Accessibility', duration: 0 };
 }
+async function runGherkinVerification(options) {
+    const startTime = Date.now();
+    const scenarios = options.gherkinScenarios || [];
+    const logs = [];
+    if (scenarios.length === 0) {
+        return { passed: true, logs: ['[Gherkin] No scenarios to verify'], layer: 'GherkinAcceptance', duration: 0 };
+    }
+    logs.push(`[Gherkin] Verifying ${scenarios.length} acceptance scenario(s)...`);
+    const bdd = detectBDDFramework(options.projectPath);
+    if (bdd.detected && bdd.testCommand) {
+        logs.push(`[Gherkin] BDD framework detected: ${bdd.framework}`);
+        logs.push(`[Gherkin] Running: ${bdd.testCommand}`);
+        const result = await runShellCommand(bdd.testCommand, options.projectPath);
+        if (result.stdout) {
+            for (const line of result.stdout.split(/\r?\n/).slice(-10)) {
+                if (line.trim())
+                    logs.push(`  > ${line}`);
+            }
+        }
+        if (result.exitCode === 0) {
+            logs.push(`[Gherkin] BDD tests passed`);
+            return { passed: true, logs, layer: 'GherkinAcceptance', duration: result.durationMs };
+        }
+        logs.push(`[Gherkin] BDD tests failed (exit=${result.exitCode})`);
+        if (result.stderr) {
+            for (const line of result.stderr.split(/\r?\n/).slice(-5)) {
+                if (line.trim())
+                    logs.push(`  > ${line}`);
+            }
+        }
+        return {
+            passed: false,
+            error: `${scenarios.length} Gherkin scenario(s) failed BDD verification`,
+            logs,
+            layer: 'GherkinAcceptance',
+            duration: result.durationMs,
+        };
+    }
+    logs.push(`[Gherkin] No BDD framework detected. Generating AI verification checklist.`);
+    logs.push('');
+    logs.push('## Acceptance Scenarios to Verify:');
+    logs.push('');
+    for (const scenario of scenarios) {
+        logs.push(`**Scenario: ${scenario.scenario}**`);
+        for (const g of scenario.given)
+            logs.push(`  Given ${g}`);
+        for (const w of scenario.when)
+            logs.push(`  When ${w}`);
+        for (const t of scenario.then)
+            logs.push(`  Then ${t}`);
+        logs.push('');
+    }
+    logs.push('[Gherkin] AI should verify each scenario by examining the implementation.');
+    logs.push('[Gherkin] If any "Then" assertion is not satisfied, report failure.');
+    return { passed: true, logs, layer: 'GherkinAcceptance', duration: Date.now() - startTime };
+}
 export function generateVerificationReport(results) {
     const lines = [
         '## AI Verification Results\n',

package/dist/weave/stages/plan.js

@@ -1,6 +1,7 @@
 import { getPhaseManager } from '../phase-manager.js';
 import { getEffectiveGdcConfig, runGdcMachineCommand, getGraphNodeIds, getGraphEdges, countGdcCheckIssues, } from '../gdc.js';
 import { generateOpenSpecArtifacts, ensureOpenSpecWorkspace } from './openspec.js';
+import { generateGherkinForPhase, generateGherkinForTask, writeAllFeatureFiles, } from '../gherkin.js';
 const PHASE_SIZE_GUIDE = {
     tooSmall: ['변수명 변경', '오타 수정'],
     justRight: ['UI 컴포넌트 하나', '저장 기능', 'API 엔드포인트 하나'],
@@ -406,6 +407,9 @@ export async function plan(options) {
                     : undefined;
                 const shardScope = shardOriginalPhases.map(phase => phase.name).join(', ');
                 const shardHours = shardOriginalPhases.reduce((sum, phase) => sum + (phase.estimatedHours || 3), 0);
+                for (const phase of shardOriginalPhases) {
+                    phase.acceptanceCriteria = generateGherkinForPhase(phase);
+                }
                 const shardPlan = await manager.createPlan({
                     planName: shardPlanName,
                     projectName,
@@ -490,6 +494,22 @@ export async function plan(options) {
     }
     catch {
     }
+    for (const phase of weavePlan.phases) {
+        if (!phase.acceptanceCriteria || phase.acceptanceCriteria.length === 0) {
+            phase.acceptanceCriteria = generateGherkinForPhase(phase);
+        }
+    }
+    try {
+        const featurePaths = await writeAllFeatureFiles(basePath || process.cwd(), weavePlan.phases);
+        for (const [phaseId, featurePath] of featurePaths) {
+            const phase = weavePlan.phases.find(p => p.id === phaseId);
+            if (phase)
+                phase.featurePath = featurePath;
+        }
+        await manager.savePlan(weavePlan);
+    }
+    catch {
+    }
     const summary = generatePlanSummary(weavePlan, estimatedTotalHours);
     return {
         plan: weavePlan,
@@ -508,6 +528,8 @@ function generateDefaultPhaseTasks(phase, gdc) {
         .flatMap(nodeId => gdc?.nodeFileMap?.get(nodeId) || [])
         .filter(Boolean)
         .slice(0, 8);
+    const implCriteria = generateGherkinForTask({ id: `${baseId}-T1`, name: `${title} 구현`, testCase: phase.doneWhen }, phase);
+    const testCriteria = generateGherkinForTask({ id: `${baseId}-T2`, name: `${title} 테스트 추가/수정`, testCase: '관련 테스트가 통과한다' }, phase);
     return [
         {
             id: `${baseId}-T1`,
@@ -523,6 +545,7 @@ function generateDefaultPhaseTasks(phase, gdc) {
                 `phase:${phase.id}`,
                 `done_when:${phase.doneWhen}`,
             ],
+            acceptanceCriteria: [implCriteria],
             maxRetries: 3,
         },
         {
@@ -538,6 +561,7 @@ function generateDefaultPhaseTasks(phase, gdc) {
                 { kind: 'command', value: 'gdc check --machine' },
             ],
             acceptanceRefs: [`phase:${phase.id}:tests`],
+            acceptanceCriteria: [testCriteria],
             maxRetries: 2,
         },
         {