@planu/cli 4.11.2 → 4.11.3

package/dist/tools/create-spec/post-creation.js

@@ -137,7 +137,23 @@ const TECH_STACK_PATTERNS = [
 ];
 /** Returns true if description references any known technology or version. */
 function hasTechStackReferences(description) {
-    return TECH_STACK_PATTERNS.some((p) => p.test(description));
+    return TECH_STACK_PATTERNS.some((pattern) => hasAffirmedPattern(description, pattern));
+}
+const NEGATIVE_CONTEXT_RE = /\b(?:no|not|never|without|exclude|excluding|forbid|forbidden|remove|avoid|must not|should not|do not|does not|don't|doesn't|out[- ]of[- ]scope|unsupported|unrelated|false positive)\b/i;
+const INCIDENTAL_CONTEXT_RE = /\b(?:example|for example|e\.g\.|quoted|regression|bug caused by|incorrectly inferred|must not infer)\b/i;
+function hasAffirmedPattern(description, pattern) {
+    const withoutQuotedText = description
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`[^`]+`/g, ' ')
+        .replace(/"[^"]+"|'[^']+'/g, ' ');
+    return withoutQuotedText.split(/(?:\r?\n|[.;!?]+)/).some((segment) => {
+        const match = new RegExp(pattern.source, pattern.flags.replace('g', '')).exec(segment);
+        if (!match) {
+            return false;
+        }
+        const prefix = segment.slice(0, match.index);
+        return !NEGATIVE_CONTEXT_RE.test(prefix) && !INCIDENTAL_CONTEXT_RE.test(prefix);
+    });
 }
 // === Serverless platform detection ===
 const SERVERLESS_PLATFORMS = ['vercel', 'netlify', 'lambda', 'cloudflare-workers', 'deno-deploy'];
@@ -185,12 +201,12 @@ export async function generatePostCreationSuggestions(projectPath, description,
     if (isServerlessKnowledge(knowledge)) {
         suggestions.push({
             tool: 'scan_project',
-            reason: '[SERVERLESS WARNING] Module-level mutable state resets on cold starts. Avoid in-memory caches, singletons, or shared mutable variables for cross-request data — use Redis or a database instead.',
+            reason: '[SERVERLESS WARNING] Module-level mutable state may reset on cold starts. Confirm the required state lifetime and storage strategy before implementation.',
         });
     }
-    // Item 4: Suggest templates when description matches known patterns
+    // Item 4: Suggest templates only when the user explicitly requests one.
     for (const { pattern, category } of TEMPLATE_PATTERNS) {
-        if (pattern.test(description)) {
+        if (hasAffirmedPattern(description, pattern) && explicitlyRequestsTemplate(description)) {
             suggestions.push({
                 tool: 'apply_template',
                 reason: `Description matches "${category}" pattern. Consider using an ${category} template.`,
@@ -205,6 +221,9 @@ export async function generatePostCreationSuggestions(projectPath, description,
     });
     return suggestions;
 }
+function explicitlyRequestsTemplate(description) {
+    return /\b(?:use|apply|start from|base (?:this|it) on)\s+(?:an?\s+)?(?:[\w-]+\s+)?template\b/i.test(description);
+}
 /** Formats a structured post-creation suggestion for human-readable next steps. */
 export function formatPostCreationSuggestion(suggestion) {
     const templateSuffix = suggestion.templateCategory !== undefined ? ` (${suggestion.templateCategory})` : '';

package/dist/tools/create-spec.js

@@ -7,14 +7,12 @@ import { formatSuccess, addNextSteps, toolResult, interactiveResult } from './re
 import { writeFile, mkdir, rm, readFile, stat as fsStat, rename, link as hardLink, } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
 import { dirname as pathDirname, isAbsolute as pathIsAbsolute, join as pathJoin, relative as pathRelative, sep as pathSeparator, } from 'node:path';
-import { estimateSpec } from '../engine/estimator.js';
 import { checkSpecReadiness } from '../engine/readiness-checker.js';
 import { buildSpecContext, buildSplitResult } from './create-spec/spec-builder.js';
 import { validateConstitution } from './create-spec/constitution-validator.js';
 import { setupGitBranch, checkContradictions, fireSpecCreatedHook, generatePostCreationSuggestions, formatPostCreationSuggestion, runAutopilotAsync, getAsyncAnalysisPath, } from './create-spec/post-creation.js';
 import { notifyStoreChange } from '../engine/doc-generator/portal/regen-hook.js';
 import { compactObj } from '../engine/compact-obj.js';
-import { buildCreateSpecSummary } from '../engine/human-summary.js';
 import { runAutoPostCreatePipeline } from './create-spec/auto-pipeline.js';
 import { extractCriteria, generateLeanSpecContent, } from '../engine/spec-format/lean-spec-generator.js';
 import { generateLeanTechnicalContent, } from '../engine/spec-format/lean-technical-generator.js';
@@ -22,7 +20,7 @@ import { extractFilesFromSpecBody } from '../engine/spec-format/technical-md-pop
 import { buildUnifiedSpecContent } from '../engine/spec-format/unified-spec-builder.js';
 import { appendImplementationContractIfMissing } from '../engine/implementation-contract/index.js';
 import { validateEnglishOnlySpecText } from '../engine/spec-language/english-only.js';
-import { ApiKeyResolver, FallbackGenerator, OpusGenerator, } from '../engine/spec-generator/index.js';
+import { FallbackGenerator } from '../engine/spec-generator/index.js';
 import { analyzeProjectForSpec, getEmptyAutopilotResult, } from './create-spec/autopilot-analyzer.js';
 import { AutopilotSummaryCollector } from '../engine/autopilot/summary-collector.js';
 import { trackCost } from '../engine/cost-tracking/operation-tracker.js';
@@ -33,10 +31,7 @@ import { resolveProjectIdOrAutoDetect } from './resolve-project-id.js';
 import { hashProjectPath } from '../storage/base-store.js';
 import { findSimilarSpecs } from '../engine/spec-searcher.js';
 import { scoreSpecQuality } from '../engine/spec-quality-scorer.js';
-import { enrichEstimationWithVelocity } from './create-spec/adapters/velocity-estimation.js';
-import { enrichEstimationWithCalibration } from './create-spec/adapters/calibration-estimation.js';
 import { runPriorDecisionsHint } from './create-spec/adapters/prior-decisions-hint.js';
-import { suggestOutOfScope } from '../engine/scope-boundaries/index.js';
 import { adviseSimilarSpecs } from '../engine/complexity-budget/index.js';
 import { issuePlannerToken } from '../engine/reviewer-tokens/issuer.js';
 import { generateInteractiveQuestions } from './create-spec/question-generator.js';
@@ -115,10 +110,9 @@ async function resolveTechnicalFiles(input) {
         .join('\n\n');
     const extracted = await extractFilesFromSpecBody(generatedSource, input.projectPath);
     if (extracted !== null && hasFileEntries(extracted)) {
-        return mergeTechnicalFiles(extracted, input.autopilot.suggestedFiles);
-    }
-    if (input.fallbackReason !== undefined && hasFileEntries(input.autopilot.suggestedFiles)) {
-        return input.autopilot.suggestedFiles;
+        return input.fallbackReason === undefined
+            ? mergeTechnicalFiles(extracted, input.autopilot.suggestedFiles)
+            : extracted;
     }
     return { create: [], modify: [], test: [] };
 }
@@ -141,8 +135,9 @@ async function groundTechnicalFiles(input) {
             const pathInUserInput = userInput.includes(file.path.toLowerCase());
             const exists = await pathExists(pathJoin(input.projectPath, file.path));
             const fromAutopilot = autopilotPaths.has(file.path);
-            const derivedTest = section === 'test' && isDerivedFromGroundedSource(file.path, input.files.modify);
-            if (pathInUserInput || exists || fromAutopilot || derivedTest) {
+            const derivedTest = section === 'test' && isDerivedFromGroundedSource(file.path, grounded.modify);
+            const directProjectEvidence = fromAutopilot && exists;
+            if (pathInUserInput || directProjectEvidence || derivedTest) {
                 grounded[section].push(file);
                 records.push({
                     path: file.path,
@@ -150,8 +145,9 @@ async function groundTechnicalFiles(input) {
                     source: pathInUserInput ? 'user_input' : 'project_evidence',
                     evidence: [
                         ...(pathInUserInput ? ['create_spec.description'] : []),
-                        ...(exists ? [`file:${file.path}`] : []),
-                        ...(fromAutopilot ? ['autopilot.suggestedFiles'] : []),
+                        ...(directProjectEvidence
+                            ? [`file:${file.path}`, 'autopilot.semantic-file-match']
+                            : []),
                         ...(derivedTest ? ['derived-test-path'] : []),
                     ],
                     confidence: pathInUserInput || exists ? 'high' : 'medium',
@@ -224,24 +220,9 @@ function buildAdvisoryCompat() {
         canonicalField: 'advisorySignals',
     };
 }
-/** SPEC-612: resolve outOfScope items (provided by user, or auto-suggested from description). */
-function resolveOutOfScope(description, provided) {
-    if (provided !== undefined && provided.length > 0) {
-        return { items: provided, message: null };
-    }
-    try {
-        const auto = suggestOutOfScope(description).allSuggestions.slice(0, 3);
-        if (auto.length > 0) {
-            return {
-                items: auto,
-                message: `Auto-suggested outOfScope items based on description keywords: ${auto.join(', ')}`,
-            };
-        }
-    }
-    catch {
-        /* best-effort */
-    }
-    return { items: [], message: null };
+/** Persist only out-of-scope items supplied explicitly by the caller. */
+function resolveOutOfScope(provided) {
+    return provided?.filter((item) => item.trim().length > 0) ?? [];
 }
 /** SPEC-614 AC4: suggest complexity category based on similar historical specs (best-effort). */
 async function runComplexityAdvice(projectId, currentSpecId, tags, targetCriteriaCount) {
@@ -867,8 +848,6 @@ export async function handleCreateSpec(inputParams, server) {
                         }
                         params = clarificationResult.params;
                     }
-                    // Create spec directory and write lean files (SPEC-461)
-                    await measureStep('mkdir-specDir', () => mkdir(specDir, { recursive: true }));
                     const filteredCriteria = filterGroundedCriteria(autopilot.suggestedCriteria);
                     const technologyContract = await readTechnologySelectionContract(params.projectPath ?? '');
                     const contractNote = technologyContract
@@ -889,10 +868,7 @@ export async function handleCreateSpec(inputParams, server) {
                             .filter(Boolean)
                             .join('\n')
                         : '';
-                    const anthropicKey = await new ApiKeyResolver().resolveAnthropicKey(params.projectPath ?? '');
-                    const specGenerator = anthropicKey !== undefined
-                        ? new OpusGenerator({ apiKey: anthropicKey })
-                        : new FallbackGenerator();
+                    const specGenerator = new FallbackGenerator();
                     const generatedSpec = await measureStep('generateSpecBody', () => specGenerator.generate({
                         title: spec.title,
                         description: `${description}${contractNote}`,
@@ -913,18 +889,32 @@ export async function handleCreateSpec(inputParams, server) {
                     const groundingCriteria = buildCriterionGroundingRecords({
                         criteria: [...baseCriteria, ...filteredCriteria],
                         userInput: description,
-                        projectEvidence: [
-                            ...autopilot.detectedPatterns.map((pattern) => `detected-pattern:${pattern}`),
-                            ...autopilot.suggestedFiles.modify.map((file) => `file:${file.path}`),
-                            ...autopilot.suggestedFiles.create.map((file) => `file:${file.path}`),
-                            ...autopilot.suggestedFiles.test.map((file) => `file:${file.path}`),
-                        ],
                         generatedEvidence: [
                             generatedSpec.generation.modelId ?? generatedSpec.generation.method,
                         ],
                     });
                     const contractCriteria = getContractCriteria(groundingCriteria);
                     const advisoryCriteria = getAdvisoryCriteria(groundingCriteria).map((record) => record.text);
+                    if (contractCriteria.length === 0) {
+                        return {
+                            ok: false,
+                            earlyReturn: {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: 'create_spec did not persist a spec because no acceptance criterion was grounded in the user request. ' +
+                                            'Needs decision: provide at least one explicit, verifiable criterion as a checkbox or Given/When/Then outcome.',
+                                    },
+                                ],
+                                isError: true,
+                                structuredContent: {
+                                    error: 'MISSING_GROUNDED_ACCEPTANCE_CRITERIA',
+                                    missingDecision: 'Provide at least one explicit, verifiable acceptance criterion.',
+                                    persisted: false,
+                                },
+                            },
+                        };
+                    }
                     const actionableMetrics = calculateActionableSpecMetrics({
                         criteria: [...baseCriteria, ...filteredCriteria],
                         groundingRecords: groundingCriteria,
@@ -942,7 +932,7 @@ export async function handleCreateSpec(inputParams, server) {
                         userInput: description,
                         autopilot,
                     }));
-                    const outOfScopeResolved = resolveOutOfScope(description, params.outOfScope);
+                    const outOfScope = resolveOutOfScope(params.outOfScope);
                     const scenarioTestPaths = groundedTechnical.files.test.map((file) => file.path);
                     const leanSpec = generateLeanSpecContent({
                         spec,
@@ -952,7 +942,7 @@ export async function handleCreateSpec(inputParams, server) {
                             text: record.text,
                             done: false,
                         })),
-                        groundingCriteria,
+                        groundingCriteria: contractCriteria,
                         groundingTechnicalReferences: groundedTechnical.records,
                         acFormat: params.acFormat,
                         scenarioTestPaths,
@@ -972,15 +962,8 @@ export async function handleCreateSpec(inputParams, server) {
                         description: generatedSpec.specBody,
                         criteria: contractCriteria.map((record) => ({ text: record.text, done: false })),
                         files: groundedTechnical.files,
-                        outOfScope: outOfScopeResolved.items,
-                        verificationCommands: [
-                            ...(scenarioTestPaths.length > 0
-                                ? [`pnpm vitest run ${scenarioTestPaths.join(' ')}`]
-                                : []),
-                            'pnpm typecheck',
-                            'pnpm lint',
-                            'pnpm test',
-                        ],
+                        outOfScope,
+                        verificationCommands: [],
                     });
                     const genericOutputGate = checkGenericSpecOutput(unifiedSpec);
                     if (!genericOutputGate.passed) {
@@ -1008,6 +991,7 @@ export async function handleCreateSpec(inputParams, server) {
                         };
                     }
                     try {
+                        await measureStep('mkdir-specDir', () => mkdir(specDir, { recursive: true }));
                         // SPEC-713: measure file write — this is the critical persistence step.
                         await measureStep('writeFile-specPath', () => writeFile(specPath, unifiedSpec, 'utf-8'));
                         await measureStep('commit-idempotency-evidence', () => commitIdempotencyEvidence(resolvedPath, idempotencyKey, idempotencyClaim, spec, specPath));
@@ -1020,11 +1004,10 @@ export async function handleCreateSpec(inputParams, server) {
                         await rm(specDir, { recursive: true, force: true });
                         throw writeErr;
                     }
-                    // SPEC-612: Auto-suggest outOfScope when user did not provide any
-                    if (outOfScopeResolved.items.length > 0) {
-                        spec.outOfScope = outOfScopeResolved.items;
+                    // Persist only explicit out-of-scope input.
+                    if (outOfScope.length > 0) {
+                        spec.outOfScope = outOfScope;
                     }
-                    const outOfScopeSuggestionMsg = outOfScopeResolved.message;
                     // Persist spec in storage
                     // SPEC-713: measure specStore.createSpec — file lock + JSON rewrite
                     await measureStep('specStore-createSpec', () => specStore.createSpec(projectId, spec));
@@ -1050,7 +1033,6 @@ export async function handleCreateSpec(inputParams, server) {
                                 ...groundedTechnical.advisoryFiles.map((file) => file.path),
                             ],
                             actionableMetrics,
-                            outOfScopeSuggestionMsg,
                         },
                     };
                 }); // end withTotalBudget critical path
@@ -1081,7 +1063,7 @@ export async function handleCreateSpec(inputParams, server) {
                 // Destructure critical path results for use in post-creation enrichment
                 const { spec, specDir: _specDir, specPath, 
                 // SPEC-1010 Bug A: no longer surfaced in the response payload (SSR back-migration).
-                technicalPath: _technicalPath, estimation, splitSuggestion, duplicate, projectId, agentTeamPlan, knowledge, clarificationSession, constitutionCheck, autopilot, filteredCriteria, advisoryCriteria, actionableMetrics, outOfScopeSuggestionMsg, } = criticalResult.value.data;
+                technicalPath: _technicalPath, estimation, splitSuggestion, duplicate, projectId, agentTeamPlan, knowledge, clarificationSession, constitutionCheck, autopilot, filteredCriteria, advisoryCriteria, actionableMetrics, } = criticalResult.value.data;
                 // -----------------------------------------------------------------------
                 // Post-creation enrichment (outside 25s ceiling — best-effort, budgeted)
                 // -----------------------------------------------------------------------
@@ -1098,21 +1080,6 @@ export async function handleCreateSpec(inputParams, server) {
                 // SPEC-713: withBudget 2s — scans all specs for contradiction keywords
                 const contradictionResult = await withBudget('checkContradictions', 2_000, () => measureStep('checkContradictions', () => checkContradictions(projectId, spec.id, description)));
                 const contradictionHint = unwrapBudget(contradictionResult, undefined);
-                // SPEC-555: Enrich estimation with calendar days (best-effort, non-blocking)
-                // SPEC-713: withBudget 2s
-                const velocityResult = await withBudget('velocityEnrichment', 2_000, () => measureStep('velocityEnrichment', () => enrichEstimationWithVelocity(params.projectPath ?? '', estimation.devHours)));
-                const velocityEnrichment = unwrapBudget(velocityResult, {
-                    calendarDays: null,
-                    velocityNote: 'velocity data unavailable',
-                });
-                // SPEC-506: Apply persisted calibration multiplier (best-effort, non-blocking)
-                // SPEC-713: withBudget 2s
-                const calibrationResult = await withBudget('calibrationEnrichment', 2_000, () => measureStep('calibrationEnrichment', () => enrichEstimationWithCalibration(params.projectPath ?? '', estimation.devHours, spec.scope, spec.type)));
-                const calibrationEnrichment = unwrapBudget(calibrationResult, {
-                    calibratedHours: estimation.devHours,
-                    applied: false,
-                    calibrationNote: null,
-                });
                 // Build result (SPEC-461: lean — no progress, HTML, diagrams, scope filters)
                 const result = {
                     // SPEC-781: async analysis running in background (external project data)
@@ -1134,15 +1101,6 @@ export async function handleCreateSpec(inputParams, server) {
                     // ## Technical; the file is never written and the field would point to
                     // a non-existent path. Internal Spec record still carries it for
                     // backwards-compat with stored data — that field is removed in PR-C.
-                    estimation: {
-                        devHours: calibrationEnrichment.calibratedHours,
-                        reviewHours: estimation.reviewHours,
-                        totalCostUsd: estimation.totalCostUsd,
-                        recommendedModel: estimation.recommendedModel,
-                        executionMode: estimation.tokenOptimization.mode,
-                        calendarDays: velocityEnrichment.calendarDays,
-                        velocityNote: velocityEnrichment.velocityNote,
-                    },
                     duplicateWarning: duplicate
                         ? ti('spec.duplicateTitle', { title: spec.title, slug: spec.slug })
                         : undefined,
@@ -1156,7 +1114,7 @@ export async function handleCreateSpec(inputParams, server) {
                             clarificationAnswersUsed: Object.keys(clarificationSession.answers).length,
                         }
                         : {
-                            clarificationNote: 'Spec created directly from description — Planu inferred requirements from project context.',
+                            clarificationNote: 'Spec created directly from the supplied description; no clarification session was linked.',
                         }),
                     message: ti('tools.create_spec.success', { id: spec.id, title: spec.title }),
                     ...(contradictionHint ? { contradictionHint } : {}),
@@ -1181,7 +1139,6 @@ export async function handleCreateSpec(inputParams, server) {
                 }
                 const splitResult = buildSplitResult(splitSuggestion, knowledge?.experienceLevel);
                 if (splitResult) {
-                    result.splitSuggestion = splitResult;
                     advisorySignals.push(makeAdvisorySignal({
                         key: 'split-suggestion',
                         kind: 'complexity',
@@ -1191,7 +1148,6 @@ export async function handleCreateSpec(inputParams, server) {
                         confidence: 0.5,
                         surface: 'structuredContent',
                         value: splitResult,
-                        deprecatedAlias: 'splitSuggestion',
                     }));
                 }
                 // Dispatch hook event (fire-and-forget)
@@ -1200,21 +1156,6 @@ export async function handleCreateSpec(inputParams, server) {
                 runAutopilotAsync(spec.id, params.projectPath ?? '', description);
                 // SPEC-713: Track warnings from budgeted post-creation steps
                 const budgetWarnings = [];
-                // Auto-estimation (best-effort, fire-and-forget)
-                // SPEC-713: withBudget 2s — estimation is sync, specStore.updateSpec is a single JSON write
-                const autoEstimationResult = await withBudget('auto-estimation', 2_000, async () => {
-                    const autoEstimation = estimateSpec(spec);
-                    await measureStep('specStore-updateSpec', () => specStore.updateSpec(projectId, spec.id, { estimation: autoEstimation.estimation }));
-                    return autoEstimation;
-                });
-                if (!autoEstimationResult.exceeded) {
-                    const ae = autoEstimationResult.value;
-                    result.autoEstimation = {
-                        confidence: ae.confidence,
-                        reasoning: ae.reasoning,
-                        similarSpecs: ae.similarSpecs,
-                    };
-                }
                 // SPEC-461: No per-spec HTML reports — lean format
                 // SPEC-713: Run post-creation checks in parallel to reduce total wall-clock time.
                 // Each has an individual budget; results are merged into `result` after settlement.
@@ -1376,9 +1317,6 @@ export async function handleCreateSpec(inputParams, server) {
                     `| Target | ${spec.target} |`,
                     `| Status | ${spec.status} |`,
                     `| Tags | ${spec.tags.join(', ')} |`,
-                    `| Dev hours | ${String(estimation.devHours)}h |`,
-                    `| Review hours | ${String(estimation.reviewHours)}h |`,
-                    `| Cost | $${String(estimation.totalCostUsd)} |`,
                 ];
                 if (spec.gitBranch) {
                     lines.push(`| Branch | \`${spec.gitBranch}\` |`);
@@ -1406,20 +1344,6 @@ export async function handleCreateSpec(inputParams, server) {
                     : formatSuccess(ti('tools.create_spec.success', { id: spec.id, title: spec.title }), lines.join('\n'));
                 // SPEC-469: Build autopilot summary from analyzer results
                 const collector = new AutopilotSummaryCollector();
-                // SPEC-612: Record outOfScope auto-suggestion in autopilot summary
-                if (outOfScopeSuggestionMsg !== null) {
-                    collector.pushOk('scope-boundaries', outOfScopeSuggestionMsg);
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'out-of-scope-suggestions',
-                        kind: 'out-of-scope',
-                        message: outOfScopeSuggestionMsg,
-                        source: 'heuristic',
-                        evidence: ['scope-boundaries suggester'],
-                        confidence: 0.45,
-                        surface: 'structuredContent',
-                        value: spec.outOfScope ?? [],
-                    }));
-                }
                 if (autopilot.detectedPatterns.length > 0) {
                     collector.pushOk('pattern-detection', `Detected patterns: ${autopilot.detectedPatterns.join(', ')}`);
                     advisorySignals.push(makeAdvisorySignal({
@@ -1459,17 +1383,13 @@ export async function handleCreateSpec(inputParams, server) {
                     }));
                 }
                 if (filteredCriteria.length > 0) {
-                    collector.pushOk('criteria-enrichment', `Added ${String(filteredCriteria.length)} acceptance criteria from project context`);
+                    collector.pushOk('criteria-enrichment', `Evaluated ${String(filteredCriteria.length)} proposed criteria; only directly grounded items entered the contract`);
                 }
                 if (pipelineResult.challengeSummary) {
                     collector.pushOk('challenge', `Challenge analysis complete: ${pipelineResult.challengeSummary}`);
                 }
                 if (pipelineResult.readinessScore !== null) {
-                    // SPEC-629: append Opus hint for difficulty >= 3 specs
-                    const opusHint = spec.difficulty >= 3
-                        ? ` — difficulty ${String(spec.difficulty)}: use Opus to add exact file paths + function names`
-                        : '';
-                    collector.pushOk('readiness', `Readiness score: ${String(pipelineResult.readinessScore)}/100${opusHint}`);
+                    collector.pushOk('readiness', `Readiness score: ${String(pipelineResult.readinessScore)}/100`);
                     advisorySignals.push(makeAdvisorySignal({
                         key: 'readiness-score',
                         kind: 'readiness',
@@ -1481,24 +1401,7 @@ export async function handleCreateSpec(inputParams, server) {
                         value: pipelineResult.readinessScore,
                     }));
                 }
-                else if (spec.difficulty >= 3) {
-                    // SPEC-629: always surface the Opus hint for high-difficulty specs
-                    collector.pushOk('recommend_model', `Difficulty ${String(spec.difficulty)} spec — use Opus to add exact file paths, function names and anticipated test breaks.`);
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'model-recommendation',
-                        kind: 'model',
-                        message: 'High-difficulty spec may benefit from a stronger model for review.',
-                        source: 'heuristic',
-                        evidence: [`difficulty:${String(spec.difficulty)}`],
-                        confidence: 0.4,
-                        surface: 'structuredContent',
-                        value: { recommendedTier: 'max' },
-                    }));
-                }
-                if (calibrationEnrichment.calibrationNote) {
-                    collector.pushOk('calibration', `📐 ${calibrationEnrichment.calibrationNote}`);
-                }
-                const humanSummary = buildCreateSpecSummary(spec.title, estimation.devHours);
+                const humanSummary = `Plan created for "${spec.title}". Review the grounded criteria before approval.`;
                 result.advisorySignals = advisorySignals;
                 result.compat = buildAdvisoryCompat();
                 const compactResult = compactObj(result);

package/dist/tools/elicit-requirements-handler.js

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto';
 import { generateSpecQuestions, formatQuestionsAsPrompt, parseAnswers, } from '../engine/elicitation/index.js';
-import { buildDefaultAnswers } from '../engine/elicitation/non-interactive-defaults.js';
 /** Build a clarification summary from parsed answers */
 function buildSummary(session, parsedAnswers) {
     const lines = [`## Clarification Summary for "${session.title}"`, ''];
@@ -34,10 +33,8 @@ export function handleElicitRequirements(input) {
     const { title, description, answers, mode } = input;
     // intakeRef is silently acknowledged — used by downstream agents to chain context
     const context = {
-        hasDatabase: description.toLowerCase().includes('data') ||
-            description.toLowerCase().includes('store') ||
-            description.toLowerCase().includes('database'),
-        isApi: description.toLowerCase().includes('api') || description.toLowerCase().includes('endpoint'),
+        hasDatabase: hasAffirmedTerm(description, /\b(?:data|store|database)\b/i),
+        isApi: hasAffirmedTerm(description, /\b(?:api|endpoint)\b/i),
     };
     const questions = generateSpecQuestions(title, description, context);
     const sessionId = input.sessionId ?? randomUUID();
@@ -47,17 +44,21 @@ export function handleElicitRequirements(input) {
         questions,
         answers: {},
     };
-    // SPEC-724: Non-interactive mode — synthesise defaults without AskUserQuestion round-trip
+    // Non-interactive mode cannot complete unanswered decisions on the user's behalf.
     if (mode === 'non-interactive' && (answers === undefined || answers.trim().length === 0)) {
-        const defaultAnswers = buildDefaultAnswers(input);
-        session.answers = defaultAnswers;
-        session.completedAt = new Date().toISOString();
-        const summary = buildSummary(session, defaultAnswers);
+        const missingDecision = 'Needs decision: provide explicit answers before requirements can be treated as confirmed.';
         return Promise.resolve({
-            content: [{ type: 'text', text: summary }],
+            content: [{ type: 'text', text: missingDecision }],
             structuredContent: {
-                summary,
                 mode: 'non-interactive',
+                complete: false,
+                missingDecision,
+                pendingQuestions: questions.map((question) => ({
+                    id: question.id,
+                    question: question.question,
+                    required: question.required,
+                    ...(question.choices ? { candidates: question.choices } : {}),
+                })),
             },
         });
     }
@@ -81,4 +82,11 @@ export function handleElicitRequirements(input) {
     const summary = buildSummary(session, parsedAnswers);
     return Promise.resolve({ content: [{ type: 'text', text: summary }] });
 }
+const NEGATION_RE = /\b(?:no|not|never|without|exclude|excluding|forbid|forbidden|avoid|must not|should not|do not|does not|don't|doesn't|out[- ]of[- ]scope)\b/i;
+function hasAffirmedTerm(description, pattern) {
+    return description.split(/(?:\r?\n|[.;!?]+)/).some((segment) => {
+        const match = new RegExp(pattern.source, pattern.flags.replace('g', '')).exec(segment);
+        return match !== null && !NEGATION_RE.test(segment.slice(0, match.index));
+    });
+}
 //# sourceMappingURL=elicit-requirements-handler.js.map

package/dist/tools/register-spec-tools/core-spec-tools.js

@@ -167,8 +167,17 @@ export function registerCoreSpecTools(server) {
                 .number()
                 .optional()
                 .describe('Maximum number of questions to generate (default: 5)'),
+            sessionId: z
+                .string()
+                .max(500)
+                .optional()
+                .describe('Existing clarification session to resume with user-confirmed answers.'),
+            answers: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Explicit user-confirmed answers keyed by clarification question ID.'),
         },
-    }, safeTracked('clarify_requirements', async (args) => handleClarifyRequirements(args)));
+    }, safeTracked('clarify_requirements', async (args) => handleClarifyRequirements(args, server)));
     // 5. create_spec
     server.registerTool('create_spec', {
         description: t('tools.create_spec.description'),
@@ -210,7 +219,7 @@ export function registerCoreSpecTools(server) {
             outOfScope: z
                 .array(z.string())
                 .optional()
-                .describe('SPEC-612: Explicit out-of-scope items for this spec. If omitted, Planu auto-suggests based on the description.'),
+                .describe('Explicit user-confirmed out-of-scope items for this spec.'),
             specId: z
                 .string()
                 .optional()