maskweaver 0.9.8 → 0.10.0

package/dist/plugin/index.js

@@ -594,7 +594,73 @@ function playCompletionSound(config) {
     }
 }
 let state = null;
+const OPENCODE_PACKAGES_DIR = path.join(os.homedir(), '.cache', 'opencode', 'packages');
+const MASKWEAVER_PACKAGE_GLOB = 'maskweaver@*';
+function getCacheVersion() {
+    if (!fs.existsSync(OPENCODE_PACKAGES_DIR))
+        return null;
+    const entries = fs.readdirSync(OPENCODE_PACKAGES_DIR);
+    for (const entry of entries) {
+        if (!entry.startsWith('maskweaver@'))
+            continue;
+        const pkgDir = path.join(OPENCODE_PACKAGES_DIR, entry, 'node_modules', 'maskweaver');
+        const pkgJsonPath = path.join(pkgDir, 'package.json');
+        if (!fs.existsSync(pkgJsonPath))
+            continue;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            return { version: pkg.version, pkgDir: path.join(OPENCODE_PACKAGES_DIR, entry) };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function getLatestNpmVersion() {
+    try {
+        const result = spawnSync('npm', ['view', 'maskweaver', 'version'], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10000,
+            windowsHide: true,
+        });
+        if (result.status === 0 && result.stdout) {
+            return result.stdout.trim();
+        }
+    }
+    catch { }
+    return null;
+}
+function checkAndInvalidateCache() {
+    const cached = getCacheVersion();
+    if (!cached) {
+        return { invalidated: false, cachedVersion: null, latestVersion: null };
+    }
+    if (cached.version === VERSION) {
+        return { invalidated: false, cachedVersion: cached.version, latestVersion: null };
+    }
+    const latest = getLatestNpmVersion();
+    if (latest && latest !== cached.version) {
+        try {
+            fs.rmSync(cached.pkgDir, { recursive: true, force: true });
+            return { invalidated: true, cachedVersion: cached.version, latestVersion: latest };
+        }
+        catch {
+            return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
+        }
+    }
+    return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
+}
 export const MaskweaverPlugin = async ({ client, directory, project, worktree, $, serverUrl }) => {
+    const cacheCheck = checkAndInvalidateCache();
+    if (cacheCheck.invalidated) {
+        pluginLog(client, 'warn', `Stale plugin cache detected (v${cacheCheck.cachedVersion}). Cleared — v${cacheCheck.latestVersion} will install on next restart.`);
+        pluginLog(client, 'warn', `Please restart OpenCode to activate maskweaver v${VERSION}.`);
+    }
+    else if (cacheCheck.cachedVersion && cacheCheck.cachedVersion !== VERSION) {
+        pluginLog(client, 'info', `Plugin cache v${cacheCheck.cachedVersion} — current is v${VERSION}. Restart recommended.`);
+    }
     const pluginConfig = loadPluginConfig(directory, { client, verbose: false });
     const configErrors = validateConfig(pluginConfig);
     if (configErrors.length > 0) {

package/dist/plugin/tools/weave.js

@@ -17,7 +17,7 @@ import { preparePhaseExecution, formatExecutionPlan, runAIVerification, generate
 import { archiveChange } from '../../weave/stages/archive.js';
 import { generateStatusReport, handleUserResponse } from '../../weave/stages/handoff.js';
 import { analyzeCodebase, runGraphifyAnalysis, readMapResult } from '../../weave/stages/map.js';
-import { interview as interviewStage } from '../../weave/stages/intake.js';
+import { interview as interviewStage, listInterviewStates } from '../../weave/stages/intake.js';
 import { executeBuildLoop, generateBuildState, generateBuildId, loadBuildState } from '../../weave/stages/build.js';
 import { WeaveOrchestrator } from '../../weave/orchestrator.js';
 import { getPhaseManager } from '../../weave/phase-manager.js';
@@ -1778,8 +1778,22 @@ async function handleMap(args, basePath) {
 async function handleInterview(args, basePath) {
     const docsPath = args.docsPath || 'docs';
     const lines = [];
+    const existingStates = listInterviewStates(basePath);
+    const canResume = existingStates.some(s => s.status === 'in_progress');
     lines.push('## 💬 Interview');
     lines.push('');
+    if (canResume && !args.resumeId) {
+        lines.push('### 📋 Existing Interviews');
+        lines.push('');
+        for (const state of existingStates) {
+            const statusIcon = state.status === 'in_progress' ? '🔄' : '✅';
+            lines.push(`- ${statusIcon} \`${state.id}\` — ${state.rounds} rounds, **${state.status}**`);
+        }
+        lines.push('');
+        lines.push('To resume an interview, use: `weave command=interview resumeId="<id>"`');
+        lines.push('To start fresh: `weave command=interview`');
+        lines.push('');
+    }
     const mapResult = await readMapResult(basePath);
     if (mapResult) {
         lines.push(`📍 Map available: \`${mapResult.mapPath}\``);
@@ -1797,14 +1811,56 @@ async function handleInterview(args, basePath) {
             docsPath,
             basePath,
             mapResult,
+            resumeId: args.resumeId,
         });
-        lines.push(`### Documents Analyzed`);
+        lines.push('### 📄 Documents Analyzed');
         lines.push(`- ${interviewResult.intake.documents.length} document(s) analyzed`);
         lines.push(`- ${interviewResult.intake.features.length} feature(s) identified`);
         lines.push('');
+        if (interviewResult.intake.features.length > 0) {
+            lines.push('**Features:**');
+            for (const feature of interviewResult.intake.features) {
+                lines.push(`  - ${feature}`);
+            }
+            lines.push('');
+        }
+        if (interviewResult.ambiguityScore) {
+            const score = interviewResult.ambiguityScore;
+            const milestoneIcon = score.milestone === 'ready' ? '✅'
+                : score.milestone === 'refined' ? '🟡'
+                    : score.milestone === 'progress' ? '🟠'
+                        : '🔴';
+            lines.push('### 📊 Ambiguity Score');
+            lines.push('');
+            lines.push(`**${milestoneIcon} ${(score.overallScore * 100).toFixed(1)}% Ambiguity [${score.milestone.toUpperCase()}]**`);
+            lines.push(`_${score.milestoneDescription}_`);
+            lines.push('');
+            lines.push('| Component | Clarity | Weight |');
+            lines.push('|-----------|---------|--------|');
+            const components = [
+                score.breakdown.goalClarity,
+                score.breakdown.constraintClarity,
+                score.breakdown.successCriteriaClarity,
+            ];
+            if (score.breakdown.contextClarity) {
+                components.push(score.breakdown.contextClarity);
+            }
+            for (const comp of components) {
+                const bar = '█'.repeat(Math.round(comp.clarityScore * 10)) + '░'.repeat(10 - Math.round(comp.clarityScore * 10));
+                lines.push(`| ${comp.name} | ${bar} ${(comp.clarityScore * 100).toFixed(0)}% | ${(comp.weight * 100).toFixed(0)}% |`);
+            }
+            lines.push('');
+            lines.push(`**Weakest area:** ${score.weakestArea}`);
+            if (score.nextMilestone) {
+                lines.push(`**Next milestone:** ${score.nextMilestone.label} (<= ${(score.nextMilestone.threshold * 100).toFixed(0)}%) — ${score.nextMilestone.description}`);
+            }
+            lines.push('');
+            lines.push(`**Ready for Seed:** ${score.isReadyForSeed ? '✅ Yes' : '❌ No (ambiguity > 20%)'}`);
+            lines.push(`**Ready for Gherkin:** ${score.readinessForGherkin ? '✅ Yes' : '❌ No (ambiguity > 30%)'}`);
+            lines.push('');
+        }
         if (interviewResult.intake.structuralChanges && interviewResult.intake.structuralChanges.length > 0) {
             lines.push('### ⚠️ Structural Changes Detected');
-            lines.push('The following structural changes were identified from codebase analysis:');
             lines.push('');
             for (const sc of interviewResult.intake.structuralChanges) {
                 const icon = sc.breaking ? '🔴' : '🟡';
@@ -1814,13 +1870,73 @@ async function handleInterview(args, basePath) {
                 lines.push(`  - Status: ${sc.agreed ? '✅ Agreed' : '⏳ Pending approval'}`);
             }
             lines.push('');
-            lines.push('To proceed, agree to structural changes via `weave command=approve`.');
+        }
+        if (interviewResult.generatedScenarios && interviewResult.generatedScenarios.length > 0) {
+            lines.push('### 🥒 Generated Gherkin Scenarios');
             lines.push('');
+            const byFeature = new Map();
+            for (const scenario of interviewResult.generatedScenarios) {
+                const existing = byFeature.get(scenario.feature) || [];
+                existing.push(scenario);
+                byFeature.set(scenario.feature, existing);
+            }
+            for (const [feature, scenarios] of byFeature) {
+                lines.push(`**Feature: ${feature}**`);
+                lines.push('');
+                for (const scenario of scenarios) {
+                    lines.push(`  \`\`\`gherkin`);
+                    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(`  \`\`\``);
+                    lines.push('');
+                }
+            }
+        }
+        if (interviewResult.intake.questions.length > 0) {
+            lines.push('### ❓ Questions');
+            lines.push('');
+            lines.push('Answer the following questions to reduce ambiguity and generate better Gherkin scenarios:');
+            lines.push('');
+            for (const q of interviewResult.intake.questions) {
+                const typeLabel = q.questionType === 'gherkin-given' ? '[GIVEN]'
+                    : q.questionType === 'gherkin-when' ? '[WHEN]'
+                        : q.questionType === 'gherkin-then' ? '[THEN]'
+                            : q.questionType === 'edge-case' ? '[EDGE]'
+                                : q.questionType === 'constraint' ? '[CONSTRAINT]'
+                                    : '';
+                lines.push(`**Q${q.id.replace('Q', '')}:** ${typeLabel ? typeLabel + ' ' : ''}${q.question}`);
+                if (q.targetFeature) {
+                    lines.push(`  → Target: _${q.targetFeature}_`);
+                }
+                if (q.options && q.options.length > 0) {
+                    lines.push(`  Options: ${q.options.join(' | ')}`);
+                }
+                if (q.required) {
+                    lines.push(`  ⚠️ _Required_`);
+                }
+                lines.push('');
+            }
+        }
+        if (interviewResult.isMultiRound) {
+            lines.push('---');
+            lines.push('');
+            lines.push(`**Interview Round ${(interviewResult.interviewState?.currentRound || 1)} complete.**`);
+            lines.push('More questions exist to refine requirements. Answer the remaining questions above and run `weave command=interview` again.');
+            lines.push(`Interview ID: \`${interviewResult.interviewState?.interviewId}\``);
+            lines.push('');
+        }
+        else if (interviewResult.satisfied) {
+            lines.push('---');
+            lines.push('');
+            lines.push('✅ **Requirements are clear. Ready to generate specification and plan.**');
+            lines.push('');
+            lines.push('Next: `weave command=design docsPath="docs/"` to create the plan with full Gherkin acceptance criteria.');
         }
-        lines.push('### Questions');
-        lines.push('Review the features and technical requirements above.');
-        lines.push('');
-        lines.push('Next: `weave command=design docsPath="docs/"` to create the plan.');
     }
     catch (e) {
         return `Error during interview: ${e.message || e}`;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.9.8";
+export declare const VERSION = "0.9.9";
 export declare function getVersionString(): string;

package/dist/version.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.9.8';
+export const VERSION = '0.9.9';
 export function getVersionString() {
     return `Maskweaver v${VERSION}`;
 }

package/dist/weave/stages/intake-ambiguity.d.ts

@@ -0,0 +1,5 @@
+import type { GherkinScenario } from '../types.js';
+import type { AmbiguityScore, IntakeResult } from './intake-types.js';
+export declare const AMBIGUITY_THRESHOLD = 0.2;
+export declare const GHERKIN_READINESS_THRESHOLD = 0.3;
+export declare function scoreAmbiguity(features: string[], techReqs: IntakeResult['technicalRequirements'], answers: Record<string, string>, gherkinScenarios?: GherkinScenario[], isBrownfield?: boolean, codebaseMapAvailable?: boolean): AmbiguityScore;

package/dist/weave/stages/intake-ambiguity.js

@@ -0,0 +1,200 @@
+export const AMBIGUITY_THRESHOLD = 0.20;
+export const GHERKIN_READINESS_THRESHOLD = 0.30;
+const GOAL_CLARITY_WEIGHT = 0.40;
+const CONSTRAINT_CLARITY_WEIGHT = 0.30;
+const SUCCESS_CRITERIA_CLARITY_WEIGHT = 0.30;
+const BROWNFIELD_CONTEXT_WEIGHT = 0.15;
+const BROWNFIELD_GOAL_WEIGHT = 0.35;
+const BROWNFIELD_CONSTRAINT_WEIGHT = 0.25;
+const BROWNFIELD_CRITERIA_WEIGHT = 0.25;
+const MILESTONE_DEFINITIONS = [
+    { maxScore: 1.0, label: 'initial', description: '핵심 요구사항만 파악됨. 제약조건과 성공 기준이 큰 공백.' },
+    { maxScore: 0.40, label: 'progress', description: '대부분 요구사항 파악. 일부 세부사항과 경계 조건 누락.' },
+    { maxScore: 0.30, label: 'refined', description: '성공 기준 일부 정의됨. 경계 조건과 비기능 요구사항 보강 필요.' },
+    { maxScore: AMBIGUITY_THRESHOLD, label: 'ready', description: '모든 기준이 구체적이고 테스트 가능. Seed 생성 준비 완료.' },
+];
+function getMilestone(score) {
+    for (const m of MILESTONE_DEFINITIONS) {
+        if (score <= m.maxScore)
+            return { label: m.label, description: m.description };
+    }
+    return { label: 'initial', description: MILESTONE_DEFINITIONS[0].description };
+}
+function getNextMilestone(score) {
+    for (let i = MILESTONE_DEFINITIONS.length - 1; i >= 0; i--) {
+        const m = MILESTONE_DEFINITIONS[i];
+        if (score > m.maxScore) {
+            return { threshold: m.maxScore, label: m.label, description: m.description };
+        }
+    }
+    return undefined;
+}
+function buildJustification(category, score) {
+    const pct = (score * 100).toFixed(0);
+    switch (category) {
+        case 'goal':
+            if (score >= 0.70)
+                return `목표가 명확하고 Gherkin 시나리오로 변환 가능 (${pct}%)`;
+            if (score >= 0.40)
+                return `특징이 식별되었으나 세부사항 부족 (${pct}%)`;
+            return `목표 정의가 불충분. 더 많은 질문 필요 (${pct}%)`;
+        case 'constraint':
+            if (score >= 0.60)
+                return `제약조건이 잘 정의됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `기술 스택은 파악되었으나 경계 조건 정의 필요 (${pct}%)`;
+            return `제약조건 정의가 필요함 (${pct}%)`;
+        case 'criteria':
+            if (score >= 0.70)
+                return `성공 기준이 Gherkin 시나리오로 충분히 정의됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `일부 인수 조건 존재하나 보강 필요 (${pct}%)`;
+            return `인수 조건이 정의되지 않음 (${pct}%)`;
+        case 'context':
+            if (score >= 0.60)
+                return `기존 코드베이스 맥락이 충분히 파악됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `코드베이스 맵은 있으나 세부 이해 부족 (${pct}%)`;
+            return `기존 코드베이스 맥락 파악이 필요함 (${pct}%)`;
+        default:
+            return `Clarity: ${pct}%`;
+    }
+}
+export function scoreAmbiguity(features, techReqs, answers, gherkinScenarios, isBrownfield = false, codebaseMapAvailable = false) {
+    const answerCount = Object.keys(answers).length;
+    const answerDepth = Object.values(answers).reduce((sum, a) => sum + Math.min(a.length / 100, 1.0), 0);
+    const hasFeatures = features.length > 0;
+    const featureDetailScore = hasFeatures
+        ? Math.min(features.reduce((sum, f) => sum + Math.min(f.length / 30, 1.0), 0) / Math.max(features.length, 1), 1.0)
+        : 0;
+    let goalClarityScore = 0.0;
+    if (hasFeatures)
+        goalClarityScore += 0.25;
+    if (featureDetailScore > 0.3)
+        goalClarityScore += 0.15;
+    if (answerCount >= 3)
+        goalClarityScore += 0.15;
+    if (answerDepth >= 1.5)
+        goalClarityScore += 0.15;
+    if (gherkinScenarios && gherkinScenarios.length > 0)
+        goalClarityScore += 0.15;
+    if (answers && (answers['priority'] || Object.keys(answers).some(k => k.includes('우선순위') || k.includes('priority')))) {
+        goalClarityScore += 0.15;
+    }
+    let constraintClarityScore = 0.0;
+    const hasTechStack = (techReqs?.frontend?.length ?? 0) > 0 || (techReqs?.backend?.length ?? 0) > 0;
+    if (hasTechStack)
+        constraintClarityScore += 0.30;
+    if ((techReqs?.database?.length ?? 0) > 0)
+        constraintClarityScore += 0.15;
+    if (answerCount >= 5)
+        constraintClarityScore += 0.15;
+    if (answers && Object.keys(answers).some(k => k.includes('예외') || k.includes('edge') || k.includes('에러'))) {
+        constraintClarityScore += 0.20;
+    }
+    if (answers && Object.keys(answers).some(k => k.includes('제약') || k.includes('constraint') || k.includes('제한'))) {
+        constraintClarityScore += 0.20;
+    }
+    let successCriteriaClarityScore = 0.0;
+    if (gherkinScenarios && gherkinScenarios.length > 0) {
+        const gherkinThenCount = gherkinScenarios.reduce((sum, s) => sum + s.then.length, 0);
+        successCriteriaClarityScore += Math.min(gherkinThenCount * 0.10, 0.30);
+        if (gherkinScenarios.some(s => s.given.length > 0))
+            successCriteriaClarityScore += 0.15;
+        if (gherkinScenarios.some(s => s.when.length > 0))
+            successCriteriaClarityScore += 0.15;
+        if (gherkinScenarios.length >= features.length * 2)
+            successCriteriaClarityScore += 0.15;
+    }
+    if (answerCount >= 7)
+        successCriteriaClarityScore += 0.10;
+    if (answers && Object.keys(answers).some(k => k.includes('성공') || k.includes('측정') || k.includes('metric'))) {
+        successCriteriaClarityScore += 0.15;
+    }
+    let contextClarityScore = 0.0;
+    if (isBrownfield && codebaseMapAvailable) {
+        contextClarityScore += 0.40;
+        if (answers && Object.keys(answers).some(k => k.includes('기존') || k.includes('existing') || k.includes('구조'))) {
+            contextClarityScore += 0.30;
+        }
+        if (answers && Object.keys(answers).some(k => k.includes('마이그레이션') || k.includes('migration') || k.includes('리팩토링') || k.includes('refactor'))) {
+            contextClarityScore += 0.30;
+        }
+    }
+    goalClarityScore = Math.min(1.0, Math.max(0.0, goalClarityScore));
+    constraintClarityScore = Math.min(1.0, Math.max(0.0, constraintClarityScore));
+    successCriteriaClarityScore = Math.min(1.0, Math.max(0.0, successCriteriaClarityScore));
+    contextClarityScore = Math.min(1.0, Math.max(0.0, contextClarityScore));
+    const goalComponent = {
+        name: 'Goal Clarity',
+        clarityScore: goalClarityScore,
+        weight: isBrownfield ? BROWNFIELD_GOAL_WEIGHT : GOAL_CLARITY_WEIGHT,
+        justification: buildJustification('goal', goalClarityScore),
+        thresholds: [
+            { label: 'Features identified', minScore: 0.25, description: '특징이 식별되었는가?' },
+            { label: 'Features detailed', minScore: 0.40, description: '특징에 세부사항이 있는가?' },
+            { label: 'Questions answered', minScore: 0.55, description: '인터뷰 질문에 답했는가?' },
+            { label: 'Gherkin ready', minScore: 0.70, description: 'Gherkin 시나리오로 변환 가능한가?' },
+        ],
+    };
+    const constraintComponent = {
+        name: 'Constraint Clarity',
+        clarityScore: constraintClarityScore,
+        weight: isBrownfield ? BROWNFIELD_CONSTRAINT_WEIGHT : CONSTRAINT_CLARITY_WEIGHT,
+        justification: buildJustification('constraint', constraintClarityScore),
+        thresholds: [
+            { label: 'Tech stack known', minScore: 0.30, description: '기술 스택이 파악되었는가?' },
+            { label: 'Edge cases covered', minScore: 0.50, description: '경계 조건이 다루어졌는가?' },
+            { label: 'All constraints clear', minScore: 0.80, description: '모든 제약조건이 명확한가?' },
+        ],
+    };
+    const criteriaComponent = {
+        name: 'Success Criteria Clarity',
+        clarityScore: successCriteriaClarityScore,
+        weight: isBrownfield ? BROWNFIELD_CRITERIA_WEIGHT : SUCCESS_CRITERIA_CLARITY_WEIGHT,
+        justification: buildJustification('criteria', successCriteriaClarityScore),
+        thresholds: [
+            { label: 'Basic AC exists', minScore: 0.30, description: '기본 인수 조건이 있는가?' },
+            { label: 'Gherkin When/Then', minScore: 0.50, description: 'When/Then 시나리오가 있는가?' },
+            { label: 'Full scenario coverage', minScore: 0.75, description: '충분한 시나리오 커버리지가 있는가?' },
+        ],
+    };
+    const breakdown = {
+        goalClarity: goalComponent,
+        constraintClarity: constraintComponent,
+        successCriteriaClarity: criteriaComponent,
+    };
+    if (isBrownfield && codebaseMapAvailable) {
+        breakdown.contextClarity = {
+            name: 'Context Clarity',
+            clarityScore: contextClarityScore,
+            weight: BROWNFIELD_CONTEXT_WEIGHT,
+            justification: buildJustification('context', contextClarityScore),
+            thresholds: [
+                { label: 'Map available', minScore: 0.30, description: '코드베이스 맵이 있는가?' },
+                { label: 'Patterns understood', minScore: 0.60, description: '기존 패턴이 파악되었는가?' },
+            ],
+        };
+    }
+    const weightedClarity = Object.values(breakdown).reduce((sum, comp) => {
+        if (!comp)
+            return sum;
+        return sum + comp.clarityScore * comp.weight;
+    }, 0);
+    const overallScore = Math.round((1.0 - weightedClarity) * 10000) / 10000;
+    const components = [goalComponent, constraintComponent, criteriaComponent];
+    if (breakdown.contextClarity)
+        components.push(breakdown.contextClarity);
+    const weakest = components.reduce((min, c) => c.clarityScore < min.clarityScore ? c : min, components[0]);
+    const milestone = getMilestone(overallScore);
+    return {
+        overallScore,
+        breakdown,
+        isReadyForSeed: overallScore <= AMBIGUITY_THRESHOLD,
+        readinessForGherkin: overallScore <= GHERKIN_READINESS_THRESHOLD,
+        milestone: milestone.label,
+        milestoneDescription: milestone.description,
+        weakestArea: weakest.name,
+        nextMilestone: getNextMilestone(overallScore),
+    };
+}

package/dist/weave/stages/intake-persistence.d.ts

@@ -0,0 +1,9 @@
+import type { InterviewState } from './intake-types.js';
+export declare function getInterviewDir(basePath: string): string;
+export declare function saveInterviewState(basePath: string, state: InterviewState): void;
+export declare function loadInterviewState(basePath: string, interviewId?: string): InterviewState | null;
+export declare function listInterviewStates(basePath: string): Array<{
+    id: string;
+    status: string;
+    rounds: number;
+}>;

package/dist/weave/stages/intake-persistence.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function getInterviewDir(basePath) {
+    const dir = path.join(basePath, '.opencode', 'weave', 'interview');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function interviewStatePath(basePath, interviewId) {
+    return path.join(getInterviewDir(basePath), `${interviewId}.json`);
+}
+function getLatestInterviewId(basePath) {
+    const dir = getInterviewDir(basePath);
+    try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+        if (files.length === 0)
+            return null;
+        return files[files.length - 1].replace('.json', '');
+    }
+    catch {
+        return null;
+    }
+}
+export function saveInterviewState(basePath, state) {
+    const filePath = interviewStatePath(basePath, state.interviewId);
+    state.updatedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+export function loadInterviewState(basePath, interviewId) {
+    const id = interviewId || getLatestInterviewId(basePath);
+    if (!id)
+        return null;
+    const filePath = interviewStatePath(basePath, id);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function listInterviewStates(basePath) {
+    const dir = getInterviewDir(basePath);
+    const results = [];
+    try {
+        for (const file of fs.readdirSync(dir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+                const state = JSON.parse(content);
+                results.push({
+                    id: state.interviewId,
+                    status: state.status,
+                    rounds: state.rounds.length,
+                });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return results;
+}

package/dist/weave/stages/intake-questions.d.ts

@@ -0,0 +1,6 @@
+import type { MapResult, GherkinScenario } from '../types.js';
+import type { Question, IntakeResult, AmbiguityScore } from './intake-types.js';
+export declare function generateQuestions(features: string[], techReqs: IntakeResult['technicalRequirements']): Question[];
+export declare function generateInterviewQuestions(features: string[], techReqs: IntakeResult['technicalRequirements'], map: MapResult | null): Question[];
+export declare function generateGherkinQuestions(features: string[], existingQuestions: Question[], existingAnswers: Record<string, string>, ambiguity: AmbiguityScore): Question[];
+export declare function generateAcceptanceCriteriaFromAnswers(features: string[], answers: Record<string, string>, doneWhenMap: Record<string, string>): GherkinScenario[];

package/dist/weave/stages/intake-questions.js

@@ -0,0 +1,195 @@
+export function generateQuestions(features, techReqs) {
+    const questions = [];
+    let qId = 1;
+    if (!techReqs.frontend || techReqs.frontend.length === 0) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '프론트엔드 기술',
+            question: '프론트엔드 프레임워크 선호도가 있으신가요?',
+            options: ['React', 'Vue', 'Next.js', 'Vanilla JS', '상관없음'],
+            required: true,
+        });
+    }
+    if (!techReqs.database || techReqs.database.length === 0) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '데이터 저장',
+            question: '데이터를 어디에 저장할까요?',
+            options: ['로컬 스토리지 (오프라인)', '서버 DB (PostgreSQL/MySQL)', '클라우드 (Supabase/Firebase)'],
+            required: true,
+        });
+    }
+    if (features.length > 3) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '우선순위',
+            question: '가장 먼저 완성해야 하는 기능은 무엇인가요?',
+            options: features.slice(0, 5),
+            required: true,
+        });
+    }
+    return questions;
+}
+export function generateInterviewQuestions(features, techReqs, map) {
+    const questions = generateQuestions(features, techReqs);
+    if (map && map.structuralIssues.length > 0) {
+        const critical = map.structuralIssues.filter(i => i.severity === 'critical');
+        const warnings = map.structuralIssues.filter(i => i.severity === 'warning');
+        if (critical.length > 0) {
+            questions.unshift({
+                id: 'MAP-CRITICAL',
+                topic: '구조적 문제',
+                question: `코드베이스에서 ${critical.length}개의 Critical 이슈가 발견되었습니다. 계속 진행할까요?`,
+                options: ['이슈를 먼저 해결', '진행하되 build 단계에서 해결', '지금은 무시'],
+                required: true,
+            });
+        }
+        if (warnings.length > 0) {
+            questions.push({
+                id: 'MAP-WARNINGS',
+                topic: '권장 구조 변경',
+                question: `${warnings.length}개의 경고가 있습니다. 구조 변경 권장사항을 검토하시겠습니까?`,
+                options: ['검토', '나중에 검토', '무시'],
+                required: false,
+            });
+        }
+    }
+    if (features.length > 0) {
+        questions.push({
+            id: 'EXISTING-CODE',
+            topic: '기존 코드 활용',
+            question: '기존 코드베이스의 구조나 패턴을 유지하면서 구현하시겠습니까?',
+            options: ['최대한 기존 구조 유지', '필요시 구조 변경', '새로 작성'],
+            required: true,
+        });
+    }
+    return questions;
+}
+export function generateGherkinQuestions(features, existingQuestions, existingAnswers, ambiguity) {
+    const questions = [];
+    let qId = existingQuestions.length + 1;
+    if (ambiguity.weakestArea === 'Success Criteria Clarity' || ambiguity.overallScore > 0.3) {
+        for (let i = 0; i < Math.min(features.length, 3); i++) {
+            const feature = features[i];
+            const givenAnswered = Object.keys(existingAnswers).some(k => k.includes(`given-${i}`) || k.includes(`전제-${i}`));
+            if (!givenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - Given',
+                    question: `"${feature}" 기능을 사용하기 전에 어떤 전제조건이 필요합니까? (예: 로그인 되어 있어야 한다, 데이터가 존재해야 한다)`,
+                    required: true,
+                    questionType: 'gherkin-given',
+                    targetFeature: feature,
+                });
+            }
+            const whenAnswered = Object.keys(existingAnswers).some(k => k.includes(`when-${i}`) || k.includes(`행동-${i}`));
+            if (!whenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - When',
+                    question: `"${feature}" 기능을 실행하기 위해 사용자가 어떤 행동을 하나요? (예: 버튼을 클릭한다, 값을 입력하고 제출한다)`,
+                    required: true,
+                    questionType: 'gherkin-when',
+                    targetFeature: feature,
+                });
+            }
+            const thenAnswered = Object.keys(existingAnswers).some(k => k.includes(`then-${i}`) || k.includes(`결과-${i}`));
+            if (!thenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - Then',
+                    question: `"${feature}" 기능 실행 후 어떤 결과가 나와야 하나요? (예: 성공 메시지가 표시된다, 데이터가 저장된다, 화면이 갱신된다)`,
+                    required: true,
+                    questionType: 'gherkin-then',
+                    targetFeature: feature,
+                });
+            }
+        }
+    }
+    if (ambiguity.weakestArea === 'Constraint Clarity' || ambiguity.breakdown.constraintClarity.clarityScore < 0.5) {
+        const edgeAnswered = Object.keys(existingAnswers).some(k => k.includes('edge') || k.includes('예외') || k.includes('에러'));
+        if (!edgeAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '경계 조건',
+                question: '비정상적인 상황(네트워크 오류, 잘못된 입력, 권한 없음 등)에서 어떻게 동작해야 하나요?',
+                required: true,
+                questionType: 'edge-case',
+            });
+        }
+        const constraintAnswered = Object.keys(existingAnswers).some(k => k.includes('constraint') || k.includes('제약') || k.includes('제한'));
+        if (!constraintAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '제약조건',
+                question: '기술적/비기능적 제약조건이 있나요? (지원 브라우저, 성능 목표, 보안 요구사항, 데이터 제한 등)',
+                required: false,
+                questionType: 'constraint',
+            });
+        }
+    }
+    if (ambiguity.weakestArea === 'Goal Clarity' || ambiguity.breakdown.goalClarity.clarityScore < 0.5) {
+        const successAnswered = Object.keys(existingAnswers).some(k => k.includes('성공') || k.includes('측정') || k.includes('metric'));
+        if (!successAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '성공 지표',
+                question: '이 프로젝트의 성공을 어떻게 측정할 수 있을까요? (예: 사용자 100명 가입, 페이지 로드 2초 이내, 테스트 통과율 95%)',
+                required: false,
+                questionType: 'clarification',
+            });
+        }
+    }
+    return questions;
+}
+function findAnswer(answers, ...keys) {
+    for (const [k, v] of Object.entries(answers)) {
+        for (const key of keys) {
+            if (k.toLowerCase().includes(key.toLowerCase()))
+                return v;
+        }
+    }
+    return undefined;
+}
+export function generateAcceptanceCriteriaFromAnswers(features, answers, doneWhenMap) {
+    const scenarios = [];
+    for (let i = 0; i < features.length; i++) {
+        const feature = features[i];
+        const doneWhen = doneWhenMap[feature] || `유저가 ${feature} 기능을 사용할 수 있다`;
+        const givenAnswer = findAnswer(answers, `given-${i}`, `전제-${i}`, feature, 'given');
+        const whenAnswer = findAnswer(answers, `when-${i}`, `행동-${i}`, feature, 'when');
+        const thenAnswer = findAnswer(answers, `then-${i}`, `결과-${i}`, feature, 'then');
+        const happyGiven = givenAnswer ? [givenAnswer] : [`${feature} 관련 기능이 구현되어 있다`];
+        const happyWhen = whenAnswer ? [whenAnswer] : [`유저가 ${feature} 기능을 사용한다`];
+        const happyThen = thenAnswer
+            ? [thenAnswer, doneWhen].filter((v, idx, arr) => arr.indexOf(v) === idx)
+            : [doneWhen];
+        scenarios.push({
+            feature,
+            scenario: `${feature} - 정상 동작`,
+            given: happyGiven,
+            when: happyWhen,
+            then: happyThen,
+        });
+        const edgeAnswer = findAnswer(answers, 'edge', '에러', '예외', 'edge-cases');
+        if (edgeAnswer) {
+            scenarios.push({
+                feature,
+                scenario: `${feature} - 에러 처리`,
+                given: [`${feature} 관련 기능이 구현되어 있다`, '비정상적인 상황이 발생한다'],
+                when: ['오류 조건이 발생한다'],
+                then: [edgeAnswer],
+            });
+        }
+        else {
+            scenarios.push({
+                feature,
+                scenario: `${feature} - 에러 처리`,
+                given: [`${feature} 관련 기능이 구현되어 있다`],
+                when: [`유저가 ${feature} 기능을 비정상적으로 사용한다`],
+                then: ['적절한 에러 메시지가 표시된다'],
+            });
+        }
+    }
+    return scenarios;
+}

package/dist/weave/stages/intake-types.d.ts

@@ -0,0 +1,116 @@
+import type { WeaveEvent, EnvironmentAnalysis, MapResult, StructuralChange, ConsentPrompt, GherkinScenario } from '../types.js';
+export interface IntakeOptions {
+    docsPath: string;
+    onEvent?: (event: WeaveEvent) => void;
+}
+export interface IntakeResult {
+    documents: DocumentAnalysis[];
+    features: string[];
+    domainTerms: {
+        term: string;
+        description?: string;
+    }[];
+    technicalRequirements: {
+        frontend?: string[];
+        backend?: string[];
+        database?: string[];
+        other?: string[];
+    };
+    questions: Question[];
+    similarProjects?: string[];
+    environment?: EnvironmentAnalysis;
+    codebaseMapPath?: string;
+    structuralChanges?: StructuralChange[];
+    consentPrompts?: ConsentPrompt[];
+    ambiguityScore?: AmbiguityScore;
+    generatedScenarios?: GherkinScenario[];
+}
+export interface DocumentAnalysis {
+    path: string;
+    title: string;
+    sections: string[];
+    keyPoints: string[];
+}
+export interface Question {
+    id: string;
+    topic: string;
+    question: string;
+    options?: string[];
+    required: boolean;
+    questionType?: 'clarification' | 'gherkin-given' | 'gherkin-when' | 'gherkin-then' | 'edge-case' | 'constraint' | 'priority' | 'technical';
+    targetFeature?: string;
+}
+export interface AmbiguityComponent {
+    name: string;
+    clarityScore: number;
+    weight: number;
+    justification: string;
+    thresholds: {
+        label: string;
+        minScore: number;
+        description: string;
+    }[];
+}
+export interface AmbiguityBreakdown {
+    goalClarity: AmbiguityComponent;
+    constraintClarity: AmbiguityComponent;
+    successCriteriaClarity: AmbiguityComponent;
+    contextClarity?: AmbiguityComponent;
+}
+export interface AmbiguityScore {
+    overallScore: number;
+    breakdown: AmbiguityBreakdown;
+    isReadyForSeed: boolean;
+    readinessForGherkin: boolean;
+    milestone: 'initial' | 'progress' | 'refined' | 'ready';
+    milestoneDescription: string;
+    weakestArea: string;
+    nextMilestone?: {
+        threshold: number;
+        label: string;
+        description: string;
+    };
+}
+export interface InterviewRound {
+    roundNumber: number;
+    questions: Question[];
+    answers: Record<string, string>;
+    ambiguityBefore?: AmbiguityScore;
+    ambiguityAfter?: AmbiguityScore;
+    gherkinGenerated?: GherkinScenario[];
+    timestamp: string;
+}
+export interface InterviewState {
+    interviewId: string;
+    status: 'in_progress' | 'completed' | 'aborted';
+    initialContext: string;
+    rounds: InterviewRound[];
+    currentRound: number;
+    features: string[];
+    isBrownfield: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InterviewOptions {
+    docsPath: string;
+    basePath?: string;
+    mapResult?: MapResult | null;
+    onEvent?: (event: WeaveEvent) => void;
+    resumeId?: string;
+    userAnswers?: Record<string, string>;
+    skipGherkinQuestions?: boolean;
+}
+export interface InterviewResult {
+    intake: IntakeResult;
+    agreedStructuralChanges: StructuralChange[];
+    userAnswers: Record<string, string>;
+    satisfied: boolean;
+    ambiguityScore?: AmbiguityScore;
+    generatedScenarios?: GherkinScenario[];
+    interviewState?: InterviewState;
+    isMultiRound?: boolean;
+}
+export interface IntakeWithAnalysisOptions extends IntakeOptions {
+    skipEnvironmentAnalysis?: boolean;
+    warningsOnly?: boolean;
+}

package/dist/weave/stages/intake-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,60 +1,13 @@
-import type { WeaveEvent, EnvironmentAnalysis, MapResult, StructuralChange, ConsentPrompt } from '../types.js';
-export interface IntakeOptions {
-    docsPath: string;
-    onEvent?: (event: WeaveEvent) => void;
-}
-export interface IntakeResult {
-    documents: DocumentAnalysis[];
-    features: string[];
-    domainTerms: {
-        term: string;
-        description?: string;
-    }[];
-    technicalRequirements: {
-        frontend?: string[];
-        backend?: string[];
-        database?: string[];
-        other?: string[];
-    };
-    questions: Question[];
-    similarProjects?: string[];
-    environment?: EnvironmentAnalysis;
-    codebaseMapPath?: string;
-    structuralChanges?: StructuralChange[];
-    consentPrompts?: ConsentPrompt[];
-}
-export interface DocumentAnalysis {
-    path: string;
-    title: string;
-    sections: string[];
-    keyPoints: string[];
-}
-export interface Question {
-    id: string;
-    topic: string;
-    question: string;
-    options?: string[];
-    required: boolean;
-}
+import type { MapResult, StructuralChange, ConsentPrompt } from '../types.js';
+export type { IntakeOptions, IntakeResult, DocumentAnalysis, Question, AmbiguityComponent, AmbiguityBreakdown, AmbiguityScore, InterviewRound, InterviewState, InterviewOptions, InterviewResult, IntakeWithAnalysisOptions, } from './intake-types.js';
+export { scoreAmbiguity } from './intake-ambiguity.js';
+export { generateQuestions, generateInterviewQuestions, generateGherkinQuestions, generateAcceptanceCriteriaFromAnswers, } from './intake-questions.js';
+export { saveInterviewState, loadInterviewState, listInterviewStates, getInterviewDir, } from './intake-persistence.js';
+import type { IntakeResult } from './intake-types.js';
 export declare function injectMapContext(map: MapResult | null, features: string[]): Promise<{
     structuralChanges: StructuralChange[];
     consentPrompts: ConsentPrompt[];
 }>;
-export interface InterviewOptions {
-    docsPath: string;
-    basePath?: string;
-    mapResult?: MapResult | null;
-    onEvent?: (event: WeaveEvent) => void;
-}
-export interface InterviewResult {
-    intake: IntakeResult;
-    agreedStructuralChanges: StructuralChange[];
-    userAnswers: Record<string, string>;
-    satisfied: boolean;
-}
-export declare function interview(options: InterviewOptions): Promise<InterviewResult>;
-export interface IntakeWithAnalysisOptions extends IntakeOptions {
-    skipEnvironmentAnalysis?: boolean;
-    warningsOnly?: boolean;
-}
+import type { IntakeOptions, IntakeWithAnalysisOptions, InterviewOptions, InterviewResult } from './intake-types.js';
 export declare function intake(options: IntakeOptions | IntakeWithAnalysisOptions): Promise<IntakeResult>;
+export declare function interview(options: InterviewOptions): Promise<InterviewResult>;

package/dist/weave/stages/intake.js

@@ -2,6 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { analyzeEnvironment } from '../environment/index.js';
 import { readMapResult } from './map.js';
+export { scoreAmbiguity } from './intake-ambiguity.js';
+export { generateQuestions, generateInterviewQuestions, generateGherkinQuestions, generateAcceptanceCriteriaFromAnswers, } from './intake-questions.js';
+export { saveInterviewState, loadInterviewState, listInterviewStates, getInterviewDir, } from './intake-persistence.js';
 const DOC_EXTENSIONS = ['.md', '.txt', '.yaml', '.yml', '.json'];
 const INDEX_FILES = ['index.md', 'README.md', 'readme.md'];
 function discoverDocuments(basePath) {
@@ -44,18 +47,8 @@ function analyzeDocument(filePath) {
     for (const bullet of bulletMatches.slice(0, 10)) {
         keyPoints.push(bullet.replace(/^[-*]\s+/, ''));
     }
-    return {
-        path: filePath,
-        title,
-        sections,
-        keyPoints,
-    };
+    return { path: filePath, title, sections, keyPoints };
 }
-const FEATURE_PATTERNS = [
-    /(?:기능|feature|functionality)[:：]\s*(.+)/gi,
-    /(?:할 수 있다|can|should|must)\s+(.+)/gi,
-    /(?:구현|implement|build|create)\s+(.+)/gi,
-];
 function extractFeatures(documents) {
     const features = new Set();
     for (const doc of documents) {
@@ -105,38 +98,6 @@ function detectTechnicalRequirements(documents) {
     }
     return result;
 }
-function generateQuestions(features, techReqs) {
-    const questions = [];
-    let qId = 1;
-    if (!techReqs.frontend || techReqs.frontend.length === 0) {
-        questions.push({
-            id: `Q${qId++}`,
-            topic: '프론트엔드 기술',
-            question: '프론트엔드 프레임워크 선호도가 있으신가요?',
-            options: ['React', 'Vue', 'Next.js', 'Vanilla JS', '상관없음'],
-            required: true,
-        });
-    }
-    if (!techReqs.database || techReqs.database.length === 0) {
-        questions.push({
-            id: `Q${qId++}`,
-            topic: '데이터 저장',
-            question: '데이터를 어디에 저장할까요?',
-            options: ['로컬 스토리지 (오프라인)', '서버 DB (PostgreSQL/MySQL)', '클라우드 (Supabase/Firebase)'],
-            required: true,
-        });
-    }
-    if (features.length > 3) {
-        questions.push({
-            id: `Q${qId++}`,
-            topic: '우선순위',
-            question: '가장 먼저 완성해야 하는 기능은 무엇인가요?',
-            options: features.slice(0, 5),
-            required: true,
-        });
-    }
-    return questions;
-}
 async function searchSimilarProjects(features, techStack) {
     const results = [];
     try {
@@ -147,33 +108,22 @@ async function searchSimilarProjects(features, techStack) {
             console.log('[Intake] Memory database not initialized, skipping similar project search');
             return results;
         }
-        const provider = memoryModule.createProvider({
-            type: 'text-only',
-        });
+        const provider = memoryModule.createProvider({ type: 'text-only' });
         let searchResults = [];
         if (provider) {
             const embeddingResult = await provider.embed([query]);
             const embedding = embeddingResult[0];
-            searchResults = memoryModule.hybridSearch(query, embedding, {
-                limit: 5,
-                minScore: 0.3,
-            });
+            searchResults = memoryModule.hybridSearch(query, embedding, { limit: 5, minScore: 0.3 });
         }
         else {
             console.log('[Intake] Provider not available, using text search only');
             const textResults = db.searchByText(query, 5);
-            searchResults = textResults.map((r) => ({
-                chunk: r.chunk,
-                score: r.score || 0.5,
-            }));
+            searchResults = textResults.map((r) => ({ chunk: r.chunk, score: r.score || 0.5 }));
         }
         for (const result of searchResults) {
             const { chunk, score } = result;
             const pathParts = chunk.path.split(/[/\\]/);
-            const projectName = pathParts.find((p) => !p.startsWith('.') &&
-                p !== 'memory' &&
-                p !== 'daily' &&
-                !p.endsWith('.md')) || 'Previous Project';
+            const projectName = pathParts.find((p) => !p.startsWith('.') && p !== 'memory' && p !== 'daily' && !p.endsWith('.md')) || 'Previous Project';
             const relevantFeatures = features.filter(f => chunk.text.toLowerCase().includes(f.toLowerCase().slice(0, 10)));
             if (relevantFeatures.length > 0 || score > 0.5) {
                 results.push({
@@ -200,7 +150,7 @@ export async function injectMapContext(map, features) {
             continue;
         const area = issue.area;
         const promptId = `consent-${area.replace(/[^a-z0-9]/gi, '-').toLowerCase()}`;
-        const change = {
+        structuralChanges.push({
             area,
             currentState: issue.description,
             proposedChange: issue.suggestion,
@@ -209,8 +159,7 @@ export async function injectMapContext(map, features) {
             affectedFiles: issue.affectedFiles,
             breaking: issue.severity === 'critical',
             agreed: false,
-        };
-        structuralChanges.push(change);
+        });
         consentPrompts.push({
             id: promptId,
             topic: area,
@@ -219,78 +168,15 @@ export async function injectMapContext(map, features) {
             rationale: `"${issue.title}" — ${issue.description}`,
             impact: issue.severity === 'critical' ? 'high' : 'medium',
             breaking: issue.severity === 'critical',
-            options: [
-                '승인 — 지금 수정',
-                '승인 — build 단계에서 수정',
-                '보류 — 이후 재검토',
-                '무시 — 현재 구조 유지',
-            ],
+            options: ['승인 — 지금 수정', '승인 — build 단계에서 수정', '보류 — 이후 재검토', '무시 — 현재 구조 유지'],
             agreed: false,
         });
     }
     return { structuralChanges, consentPrompts };
 }
-function generateInterviewQuestions(features, techReqs, map) {
-    const questions = generateQuestions(features, techReqs);
-    if (map && map.structuralIssues.length > 0) {
-        const critical = map.structuralIssues.filter(i => i.severity === 'critical');
-        const warnings = map.structuralIssues.filter(i => i.severity === 'warning');
-        if (critical.length > 0) {
-            questions.unshift({
-                id: 'MAP-CRITICAL',
-                topic: '구조적 문제',
-                question: `코드베이스에서 ${critical.length}개의 Critical 이슈가 발견되었습니다. 계속 진행할까요?`,
-                options: ['이슈를 먼저 해결', '진행하되 build 단계에서 해결', '지금은 무시'],
-                required: true,
-            });
-        }
-        if (warnings.length > 0) {
-            questions.push({
-                id: 'MAP-WARNINGS',
-                topic: '권장 구조 변경',
-                question: `${warnings.length}개의 경고가 있습니다. 구조 변경 권장사항을 검토하시겠습니까?`,
-                options: ['검토', '나중에 검토', '무시'],
-                required: false,
-            });
-        }
-    }
-    if (features.length > 0) {
-        questions.push({
-            id: 'EXISTING-CODE',
-            topic: '기존 코드 활용',
-            question: '기존 코드베이스의 구조나 패턴을 유지하면서 구현하시겠습니까?',
-            options: ['최대한 기존 구조 유지', '필요시 구조 변경', '새로 작성'],
-            required: true,
-        });
-    }
-    return questions;
-}
-export async function interview(options) {
-    const basePath = options.basePath || process.cwd();
-    const intakeResult = await intake({
-        docsPath: options.docsPath,
-        onEvent: options.onEvent,
-    });
-    const map = options.mapResult !== undefined
-        ? options.mapResult
-        : await readMapResult(basePath);
-    const { structuralChanges, consentPrompts } = await injectMapContext(map, intakeResult.features);
-    const enhancedQuestions = generateInterviewQuestions(intakeResult.features, intakeResult.technicalRequirements, map);
-    const intakeWithMap = {
-        ...intakeResult,
-        codebaseMapPath: map ? map.mapPath : undefined,
-        structuralChanges: structuralChanges.length > 0 ? structuralChanges : undefined,
-        consentPrompts: consentPrompts.length > 0 ? consentPrompts : undefined,
-    };
-    const hasUnansweredQuestions = enhancedQuestions.length > 0;
-    const hasPendingConsent = consentPrompts.length > 0 && consentPrompts.some(cp => !cp.agreed);
-    return {
-        intake: intakeWithMap,
-        agreedStructuralChanges: structuralChanges.filter(sc => sc.agreed),
-        userAnswers: {},
-        satisfied: !hasUnansweredQuestions && !hasPendingConsent,
-    };
-}
+import { scoreAmbiguity } from './intake-ambiguity.js';
+import { generateQuestions, generateInterviewQuestions, generateGherkinQuestions, generateAcceptanceCriteriaFromAnswers } from './intake-questions.js';
+import { saveInterviewState, loadInterviewState } from './intake-persistence.js';
 export async function intake(options) {
     const { docsPath } = options;
     const extendedOptions = options;
@@ -347,6 +233,7 @@ export async function intake(options) {
     const { structuralChanges } = mapResult
         ? await injectMapContext(mapResult, features)
         : { structuralChanges: [] };
+    const baselineAmbiguity = scoreAmbiguity(features, technicalRequirements, {}, undefined, mapResult !== null, mapResult !== null);
     return {
         documents,
         features,
@@ -357,5 +244,102 @@ export async function intake(options) {
         environment,
         codebaseMapPath: mapResult?.mapPath,
         structuralChanges: structuralChanges.length > 0 ? structuralChanges : undefined,
+        ambiguityScore: baselineAmbiguity,
+    };
+}
+export async function interview(options) {
+    const basePath = options.basePath || process.cwd();
+    const now = new Date().toISOString();
+    let interviewState = options.resumeId
+        ? loadInterviewState(basePath, options.resumeId)
+        : (!options.userAnswers ? loadInterviewState(basePath) : null);
+    const intakeResult = await intake({ docsPath: options.docsPath, onEvent: options.onEvent });
+    const map = options.mapResult !== undefined
+        ? options.mapResult
+        : await readMapResult(basePath);
+    const { structuralChanges, consentPrompts } = await injectMapContext(map, intakeResult.features);
+    const existingAnswers = interviewState
+        ? Object.assign({}, ...interviewState.rounds.map(r => r.answers))
+        : {};
+    const roundAnswers = options.userAnswers || {};
+    const allAnswers = { ...existingAnswers, ...roundAnswers };
+    const isBrownfield = map !== null;
+    const doneWhenMap = {};
+    for (const feature of intakeResult.features) {
+        doneWhenMap[feature] = `유저가 ${feature.toLowerCase().replace(/[을를이가은는]/g, '')}할 수 있다`;
+    }
+    const generatedScenarios = Object.keys(allAnswers).length > 0
+        ? generateAcceptanceCriteriaFromAnswers(intakeResult.features, allAnswers, doneWhenMap)
+        : undefined;
+    const ambiguityScore = scoreAmbiguity(intakeResult.features, intakeResult.technicalRequirements, allAnswers, generatedScenarios, isBrownfield, map !== null);
+    const baseQuestions = generateQuestions(intakeResult.features, intakeResult.technicalRequirements);
+    const mapQuestions = generateInterviewQuestions(intakeResult.features, intakeResult.technicalRequirements, map);
+    const seenIds = new Set();
+    const mergedQuestions = [...baseQuestions, ...mapQuestions].filter(q => {
+        if (seenIds.has(q.id))
+            return false;
+        seenIds.add(q.id);
+        return true;
+    });
+    let gherkinQuestions = (!options.skipGherkinQuestions && !ambiguityScore.isReadyForSeed)
+        ? generateGherkinQuestions(intakeResult.features, mergedQuestions, allAnswers, ambiguityScore)
+        : [];
+    const enhancedQuestions = mergedQuestions.filter(q => !Object.keys(allAnswers).some(k => k.toLowerCase().includes(q.id.toLowerCase())
+        || k.toLowerCase().includes((q.targetFeature || '').toLowerCase())));
+    const allQuestions = [...enhancedQuestions, ...gherkinQuestions];
+    const interviewId = interviewState?.interviewId
+        || `interview_${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    const roundNumber = interviewState ? interviewState.rounds.length + 1 : 1;
+    const currentRound = {
+        roundNumber,
+        questions: allQuestions,
+        answers: roundAnswers,
+        ambiguityBefore: interviewState?.rounds[interviewState.rounds.length - 1]?.ambiguityAfter,
+        ambiguityAfter: ambiguityScore,
+        gherkinGenerated: generatedScenarios,
+        timestamp: now,
+    };
+    if (interviewState) {
+        interviewState.rounds.push(currentRound);
+        interviewState.currentRound = roundNumber;
+        interviewState.status = ambiguityScore.isReadyForSeed ? 'completed' : 'in_progress';
+        interviewState.features = intakeResult.features;
+        interviewState.isBrownfield = isBrownfield;
+        interviewState.updatedAt = now;
+    }
+    else {
+        interviewState = {
+            interviewId,
+            status: ambiguityScore.isReadyForSeed ? 'completed' : 'in_progress',
+            initialContext: intakeResult.features.join(', '),
+            rounds: [currentRound],
+            currentRound: 1,
+            features: intakeResult.features,
+            isBrownfield,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    saveInterviewState(basePath, interviewState);
+    const intakeWithEverything = {
+        ...intakeResult,
+        codebaseMapPath: map ? map.mapPath : undefined,
+        structuralChanges: structuralChanges.length > 0 ? structuralChanges : undefined,
+        consentPrompts: consentPrompts.length > 0 ? consentPrompts : undefined,
+        ambiguityScore,
+        generatedScenarios,
+        questions: allQuestions,
+    };
+    const hasUnansweredQuestions = allQuestions.some(q => q.required);
+    const hasPendingConsent = consentPrompts.length > 0 && consentPrompts.some(cp => !cp.agreed);
+    return {
+        intake: intakeWithEverything,
+        agreedStructuralChanges: structuralChanges.filter(sc => sc.agreed),
+        userAnswers: allAnswers,
+        satisfied: ambiguityScore.isReadyForSeed && !hasUnansweredQuestions && !hasPendingConsent,
+        ambiguityScore,
+        generatedScenarios,
+        interviewState,
+        isMultiRound: !ambiguityScore.isReadyForSeed || hasUnansweredQuestions || hasPendingConsent,
     };
 }

package/dist/weave/stages/plan.js

@@ -494,9 +494,19 @@ export async function plan(options) {
     }
     catch {
     }
+    const intakeScenarios = intake.generatedScenarios;
     for (const phase of weavePlan.phases) {
         if (!phase.acceptanceCriteria || phase.acceptanceCriteria.length === 0) {
-            phase.acceptanceCriteria = generateGherkinForPhase(phase);
+            const matchingScenarios = intakeScenarios
+                ? intakeScenarios.filter(s => s.feature.toLowerCase().includes(phase.name.toLowerCase())
+                    || phase.name.toLowerCase().includes(s.feature.toLowerCase().slice(0, 10)))
+                : [];
+            if (matchingScenarios.length > 0) {
+                phase.acceptanceCriteria = matchingScenarios;
+            }
+            else {
+                phase.acceptanceCriteria = generateGherkinForPhase(phase);
+            }
         }
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maskweaver",
-  "version": "0.9.8",
+  "version": "0.10.0",
   "description": "AI Expert Persona System - Give your AI coding assistant expert personalities (가면술사)",
   "type": "module",
   "main": "./dist/index.js",