maskweaver 0.9.9 → 0.10.1

package/dist/cli/config-manager/npm-dist-tags.d.ts

@@ -0,0 +1,7 @@
+export interface NpmDistTags {
+    latest?: string;
+    beta?: string;
+    next?: string;
+    [tag: string]: string | undefined;
+}
+export declare function fetchNpmDistTags(packageName: string): Promise<NpmDistTags | null>;

package/dist/cli/config-manager/npm-dist-tags.js

@@ -0,0 +1,15 @@
+const NPM_FETCH_TIMEOUT_MS = 5000;
+export async function fetchNpmDistTags(packageName) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`, {
+            signal: AbortSignal.timeout(NPM_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/config-manager/plugin-name-with-version.d.ts

@@ -0,0 +1 @@
+export declare function getPluginNameWithVersion(currentVersion: string, packageName: string): Promise<string>;

package/dist/cli/config-manager/plugin-name-with-version.js

@@ -0,0 +1,21 @@
+import { fetchNpmDistTags } from "./npm-dist-tags.js";
+const PRIORITIZED_TAGS = ["latest", "beta", "next"];
+function getFallbackEntry(version, packageName) {
+    const prereleaseMatch = version.match(/-([a-zA-Z][a-zA-Z0-9-]*)(?:\.|$)/);
+    if (prereleaseMatch) {
+        return `${packageName}@${prereleaseMatch[1]}`;
+    }
+    return packageName;
+}
+export async function getPluginNameWithVersion(currentVersion, packageName) {
+    const distTags = await fetchNpmDistTags(packageName);
+    if (distTags) {
+        const allTags = new Set([...PRIORITIZED_TAGS, ...Object.keys(distTags)]);
+        for (const tag of allTags) {
+            if (distTags[tag] === currentVersion) {
+                return `${packageName}@${tag}`;
+            }
+        }
+    }
+    return getFallbackEntry(currentVersion, packageName);
+}

package/dist/cli/config-manager/version-compatibility.d.ts

@@ -0,0 +1,9 @@
+export interface VersionCompatibility {
+    canUpgrade: boolean;
+    reason?: string;
+    isDowngrade: boolean;
+    isMajorBump: boolean;
+    requiresMigration: boolean;
+}
+export declare function checkVersionCompatibility(currentVersion: string | null, newVersion: string): VersionCompatibility;
+export declare function extractVersionFromPluginEntry(entry: string): string | null;

package/dist/cli/config-manager/version-compatibility.js

@@ -0,0 +1,81 @@
+function parseVersion(version) {
+    const clean = version.replace(/^v/, "").split("-")[0];
+    return clean.split(".").map(Number);
+}
+function compareVersions(a, b) {
+    const partsA = parseVersion(a);
+    const partsB = parseVersion(b);
+    const maxLen = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLen; i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA !== numB) {
+            return numA - numB;
+        }
+    }
+    return 0;
+}
+export function checkVersionCompatibility(currentVersion, newVersion) {
+    if (!currentVersion) {
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    const cleanCurrent = currentVersion.replace(/^v/, "");
+    const cleanNew = newVersion.replace(/^v/, "");
+    try {
+        const comparison = compareVersions(cleanNew, cleanCurrent);
+        if (comparison < 0) {
+            return {
+                canUpgrade: false,
+                reason: `Downgrade from ${currentVersion} to ${newVersion} is not allowed`,
+                isDowngrade: true,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        if (comparison === 0) {
+            return {
+                canUpgrade: true,
+                reason: `Version ${newVersion} is already installed`,
+                isDowngrade: false,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        const currentMajor = cleanCurrent.split(".")[0];
+        const newMajor = cleanNew.split(".")[0];
+        const isMajorBump = currentMajor !== newMajor;
+        if (isMajorBump) {
+            return {
+                canUpgrade: true,
+                reason: `Major version upgrade from ${currentVersion} to ${newVersion} - configuration migration may be required`,
+                isDowngrade: false,
+                isMajorBump: true,
+                requiresMigration: true,
+            };
+        }
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    catch {
+        return {
+            canUpgrade: true,
+            reason: `Unable to compare versions ${currentVersion} and ${newVersion} - proceeding with caution`,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+}
+export function extractVersionFromPluginEntry(entry) {
+    const match = entry.match(/@(.+)$/);
+    return match ? match[1] : null;
+}

package/dist/cli/install.js

@@ -7,8 +7,10 @@ import { VERSION } from "../version.js";
 import { runDoctor, printDoctorReport } from "./doctor.js";
 import { writeDefaultRuntimeConfig, writeDefaultPluginConfig } from "../shared/generate-agents.js";
 const PLUGIN_NAME = "maskweaver";
+const PLUGIN_LATEST = "maskweaver@latest";
 const LEGACY_PLUGIN_NAMES = ["maskweaver/plugin", "@maskweaver/plugin"];
-const ALL_PLUGIN_NAMES = [PLUGIN_NAME, ...LEGACY_PLUGIN_NAMES];
+const ALL_PLUGIN_NAMES = [PLUGIN_NAME, PLUGIN_LATEST, ...LEGACY_PLUGIN_NAMES];
+const ALL_BARE_OR_VERSIONED = [PLUGIN_NAME, PLUGIN_LATEST];
 const CONFIG_NAME = "opencode.json";
 const colors = {
     reset: "\x1b[0m",
@@ -83,19 +85,31 @@ function getInstalledPluginEntries(config) {
     return config.plugin.filter((plugin) => ALL_PLUGIN_NAMES.includes(plugin));
 }
 function isPluginInstalled(config) {
-    return getInstalledPluginEntries(config).length > 0;
+    if (!config.plugin || !Array.isArray(config.plugin))
+        return false;
+    return config.plugin.some((p) => ALL_BARE_OR_VERSIONED.some(name => p === name || p.startsWith(`${name}@`)));
 }
 function normalizePluginEntries(config) {
     if (!config.plugin || !Array.isArray(config.plugin)) {
         return { migratedFrom: [], changed: false };
     }
     const migratedFrom = config.plugin.filter((plugin) => LEGACY_PLUGIN_NAMES.includes(plugin));
-    if (migratedFrom.length === 0) {
+    const hasBare = config.plugin.some((p) => p === PLUGIN_NAME);
+    const hasVersioned = config.plugin.some((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    if (migratedFrom.length === 0 && !hasBare && !hasVersioned) {
+        if (config.plugin.some((p) => p === PLUGIN_LATEST)) {
+            return { migratedFrom: [], changed: false };
+        }
         return { migratedFrom: [], changed: false };
     }
-    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin));
-    config.plugin = [...preserved, PLUGIN_NAME];
-    return { migratedFrom, changed: true };
+    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin) &&
+        !plugin.startsWith(`${PLUGIN_NAME}@`));
+    const existingVersioned = config.plugin.find((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    config.plugin = [...preserved, existingVersioned || PLUGIN_LATEST];
+    if (migratedFrom.length > 0 || hasBare) {
+        return { migratedFrom: [...migratedFrom, hasBare ? PLUGIN_NAME : ""].filter(Boolean), changed: true };
+    }
+    return { migratedFrom: [], changed: false };
 }
 async function installPlugin(options) {
     const isLocal = options.local || false;
@@ -120,13 +134,14 @@ async function installPlugin(options) {
             log("");
             return;
         }
-        if (config.plugin.includes(PLUGIN_NAME)) {
+        const alreadyInstalled = config.plugin.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`));
+        if (alreadyInstalled) {
             warning(`플러그인이 이미 설치되어 있습니다.`);
-            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_NAME}`);
+            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_LATEST}`);
             log("");
             return;
         }
-        config.plugin.push(PLUGIN_NAME);
+        config.plugin.push(PLUGIN_LATEST);
         writeConfig(configPath, config);
         let createdRuntimeConfig = false;
         let createdPluginConfig = false;
@@ -150,7 +165,7 @@ async function installPlugin(options) {
         }
         success(`플러그인이 성공적으로 설치되었습니다!`);
         log("");
-        log(`📦 설치된 플러그인: ${PLUGIN_NAME}`, "bright");
+        log(`📦 설치된 플러그인: ${PLUGIN_LATEST}`, "bright");
         log(`📍 위치: ${configPath}`, "dim");
         log("");
         log(`다음 단계:`, "bright");
@@ -190,7 +205,7 @@ async function uninstallPlugin(options) {
             log("");
             return;
         }
-        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p));
+        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p) && !p.startsWith(`${PLUGIN_NAME}@`));
         writeConfig(configPath, config);
         success(`플러그인이 성공적으로 제거되었습니다.`);
         log("");

package/dist/plugin/index.js

@@ -5,6 +5,8 @@ import * as os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { VERSION } from '../version.js';
+import { fetchNpmDistTags } from '../cli/config-manager/npm-dist-tags.js';
+import { checkVersionCompatibility } from '../cli/config-manager/version-compatibility.js';
 import { loadPluginConfig, isMaskEnabled, isToolEnabled, getDefaultMask, isAutoActivateEnabled, isVerboseLoggingEnabled, isCompletionSoundEnabled, validateConfig, } from './config/index.js';
 import { createMemorySearchTool } from './tools/memorySearch.js';
 import { createMemoryWriteTool } from './tools/memoryWrite.js';
@@ -595,10 +597,10 @@ 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;
+function getCachedPackageVersion() {
+    if (!fs.existsSync(OPENCODE_PACKAGES_DIR)) {
+        return { version: null, pkgDir: null };
+    }
     const entries = fs.readdirSync(OPENCODE_PACKAGES_DIR);
     for (const entry of entries) {
         if (!entry.startsWith('maskweaver@'))
@@ -615,51 +617,88 @@ function getCacheVersion() {
             continue;
         }
     }
-    return null;
+    return { version: null, pkgDir: 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;
+async function fetchLatestFromRegistry() {
+    return fetchNpmDistTags('maskweaver');
 }
-function checkAndInvalidateCache() {
-    const cached = getCacheVersion();
-    if (!cached) {
-        return { invalidated: false, cachedVersion: null, latestVersion: null };
+async function checkForUpdates() {
+    const cached = getCachedPackageVersion();
+    const installedVersion = cached.version;
+    const latestTags = await fetchLatestFromRegistry();
+    const latestVersion = latestTags?.latest ?? null;
+    if (!installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion: null,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: null,
+        };
     }
-    if (cached.version === VERSION) {
-        return { invalidated: false, cachedVersion: cached.version, latestVersion: null };
+    if (installedVersion === VERSION) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: 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 };
-        }
+    if (!latestVersion || latestVersion === installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
+    }
+    const compatibility = checkVersionCompatibility(installedVersion, latestVersion);
+    const currentIsLatest = installedVersion === latestVersion;
+    if (currentIsLatest) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
     }
-    return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
+    return {
+        updateAvailable: true,
+        installedVersion,
+        latestVersion,
+        isDowngrade: compatibility.isDowngrade,
+        isMajorBump: compatibility.isMajorBump,
+        requiresMigration: compatibility.requiresMigration,
+        message: `Update available: v${installedVersion} → v${latestVersion}${compatibility.requiresMigration ? ' (major upgrade — migration may be required)' : ''}.`,
+    };
 }
 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}.`);
+    const updateCheck = await checkForUpdates();
+    if (updateCheck.updateAvailable) {
+        if (updateCheck.isDowngrade) {
+            pluginLog(client, 'warn', `Downgrade detected (v${updateCheck.installedVersion} → v${updateCheck.latestVersion}) — not allowed. Please use opencode --upgrade.`);
+        }
+        else {
+            pluginLog(client, 'warn', `Update available: maskweaver v${updateCheck.installedVersion} → v${updateCheck.latestVersion}`);
+            if (updateCheck.requiresMigration) {
+                pluginLog(client, 'warn', `Major version upgrade — configuration migration may be required.`);
+            }
+            pluginLog(client, 'info', `Run \`opencode --upgrade\` or \`npm update -g maskweaver\` to update.`);
+        }
     }
-    else if (cacheCheck.cachedVersion && cacheCheck.cachedVersion !== VERSION) {
-        pluginLog(client, 'info', `Plugin cache v${cacheCheck.cachedVersion} — current is v${VERSION}. Restart recommended.`);
+    else if (updateCheck.message) {
+        pluginLog(client, 'info', updateCheck.message);
     }
     const pluginConfig = loadPluginConfig(directory, { client, verbose: false });
     const configErrors = validateConfig(pluginConfig);

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.9";
+export declare const VERSION = "0.10.1";
 export declare function getVersionString(): string;

package/dist/version.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.9.9';
+export const VERSION = '0.10.1';
 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;