@planu/cli 4.11.2 → 4.11.3

package/dist/engine/web-fetcher/stack-advisor.js

@@ -96,20 +96,24 @@ function getBaseRecommendations() {
         },
     };
 }
-function applyRequirementOverrides(rec, reqStr, constStr) {
+function applyRequirementOverrides(rec, requirements, constraints) {
     let result = rec;
-    if (reqStr.includes('python') || reqStr.includes('ml') || reqStr.includes('ai')) {
+    if (hasAffirmedTerm(requirements, /\bpython\b/i) ||
+        hasAffirmedTerm(requirements, /\bml\b/i) ||
+        hasAffirmedTerm(requirements, /\bai\b/i)) {
+        const requestsApi = hasAffirmedTerm(requirements, /\bapi\b/i);
         result = {
             ...result,
             language: 'python',
-            framework: reqStr.includes('api') ? 'fastapi' : 'django',
-            version: reqStr.includes('api') ? '0.100+' : '5+',
-            ecosystem: reqStr.includes('api')
+            framework: requestsApi ? 'fastapi' : 'django',
+            version: requestsApi ? '0.100+' : '5+',
+            ecosystem: requestsApi
                 ? ['fastapi', 'pydantic', 'sqlalchemy', 'alembic']
                 : ['django', 'django-rest-framework', 'celery', 'pytest'],
         };
     }
-    if (reqStr.includes('go') || reqStr.includes('golang') || reqStr.includes('performance')) {
+    if (hasAffirmedTerm(requirements, /\bgo(?:lang)?\b/i) ||
+        hasAffirmedTerm(requirements, /\bperformance\b/i)) {
         result = {
             ...result,
             language: 'go',
@@ -118,7 +122,7 @@ function applyRequirementOverrides(rec, reqStr, constStr) {
             ecosystem: ['gin', 'gorm', 'wire', 'testify'],
         };
     }
-    if (reqStr.includes('supabase')) {
+    if (hasAffirmedTerm(requirements, /\bsupabase\b/i)) {
         result = {
             ...result,
             database: 'supabase',
@@ -126,22 +130,21 @@ function applyRequirementOverrides(rec, reqStr, constStr) {
             auth: 'supabase-auth',
         };
     }
-    if (reqStr.includes('firebase')) {
+    if (hasAffirmedTerm(requirements, /\bfirebase\b/i)) {
         result = { ...result, database: 'firebase', auth: 'firebase-auth' };
     }
-    if (constStr.includes('no-vendor-lock') || constStr.includes('self-host')) {
+    if (constraints.some((constraint) => constraint.toLowerCase().includes('no-vendor-lock')) ||
+        hasAffirmedTerm(constraints, /\bself[- ]host(?:ed|ing)?\b/i)) {
         result = { ...result, deployment: 'docker + railway', database: 'postgresql' };
     }
     return result;
 }
 export function recommendStack(projectType, requirements, constraints) {
-    const reqStr = requirements.join(' ').toLowerCase();
-    const constStr = constraints.join(' ').toLowerCase();
     const recommendations = getBaseRecommendations();
     const base = 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- 'web' key always exists in getBaseRecommendations()
     recommendations[projectType] ?? recommendations.web;
-    return applyRequirementOverrides(base, reqStr, constStr);
+    return applyRequirementOverrides(base, requirements, constraints);
 }
 export function recommendAlternativeStack(projectType, _requirements) {
     const alternatives = {
@@ -208,23 +211,23 @@ export function buildWhyNotOthers(_projectType, chosenFramework) {
     const allAlternatives = [
         {
             name: 'Ruby on Rails',
-            reason: 'Great for prototyping but TypeScript ecosystem is larger and has better type safety.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'PHP/Laravel',
-            reason: 'Solid framework but less modern tooling and TypeScript interop.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'Java/Spring',
-            reason: 'Enterprise-grade but heavier setup and verbose for smaller projects.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'C#/.NET',
-            reason: 'Excellent for enterprise but tighter coupling to Microsoft ecosystem.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'Elixir/Phoenix',
-            reason: 'Great for real-time but smaller ecosystem and talent pool.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
     ];
     return allAlternatives
@@ -307,6 +310,8 @@ export async function buildSuggestStackResult(projectType, requirements, constra
         // Offline: keep static versions, mark confidence as low
         confidence = 'low';
     }
+    const detectedEvidence = collectDetectedEvidence(requirements, constraints);
+    const confirmedChoices = collectConfirmedChoices(requirements);
     return {
         primary,
         alternative,
@@ -314,6 +319,62 @@ export async function buildSuggestStackResult(projectType, requirements, constra
         mcpCompatibility: buildMcpCompatibility(primary),
         lastChecked: new Date().toISOString(),
         confidence,
+        selectionStatus: confirmedChoices.length > 0 ? 'partially-confirmed' : 'unconfirmed',
+        detectedEvidence,
+        confirmedChoices,
+        candidateNotice: 'Recommendations are optional candidates. No candidate is selected or persisted without user confirmation.',
     };
 }
+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;
+const NEGATIVE_SUFFIX_RE = /\b(?:forbidden|excluded|not allowed|out[- ]of[- ]scope)\b/i;
+function hasAffirmedTerm(values, pattern) {
+    return values.some((value) => {
+        const withoutQuotedText = value
+            .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);
+            const suffix = segment.slice(match.index + match[0].length);
+            return !NEGATION_RE.test(prefix) && !NEGATIVE_SUFFIX_RE.test(suffix);
+        });
+    });
+}
+function collectDetectedEvidence(requirements, constraints) {
+    const definitions = [
+        ['language:python', /\bpython\b/i],
+        ['language:go', /\bgo(?:lang)?\b/i],
+        ['database:supabase', /\bsupabase\b/i],
+        ['database:firebase', /\bfirebase\b/i],
+        ['capability:api', /\bapi\b/i],
+        ['capability:ml', /\b(?:ml|ai)\b/i],
+    ];
+    const evidence = definitions
+        .filter(([, pattern]) => hasAffirmedTerm(requirements, pattern))
+        .map(([name]) => `requirement:${name}`);
+    if (constraints.some((constraint) => constraint.toLowerCase().includes('no-vendor-lock'))) {
+        evidence.push('constraint:no-vendor-lock');
+    }
+    if (hasAffirmedTerm(constraints, /\bself[- ]host(?:ed|ing)?\b/i)) {
+        evidence.push('constraint:self-host');
+    }
+    return evidence;
+}
+function collectConfirmedChoices(requirements) {
+    const confirmationText = requirements.join(' ');
+    const choices = [
+        ['language', 'python', /\b(?:must use|use|selected|confirmed|requires?)\s+python\b/i],
+        ['language', 'go', /\b(?:must use|use|selected|confirmed|requires?)\s+go(?:lang)?\b/i],
+        ['database', 'supabase', /\b(?:must use|use|selected|confirmed|requires?)\s+supabase\b/i],
+        ['database', 'firebase', /\b(?:must use|use|selected|confirmed|requires?)\s+firebase\b/i],
+    ];
+    return choices
+        .filter(([, , pattern]) => pattern.test(confirmationText))
+        .filter(([, value]) => hasAffirmedTerm(requirements, new RegExp(`\\b${value}\\b`, 'i')))
+        .map(([field, value]) => ({ field, value, source: 'user_confirmation' }));
+}
 //# sourceMappingURL=stack-advisor.js.map

package/dist/tools/challenge-spec/challenge-report.d.ts

@@ -0,0 +1,13 @@
+import type { ChallengeReport, ChallengeResolutionEvidence, FailureScenario } from '../../types/index.js';
+export declare const MINIMUM_RESOLVED_CHALLENGES = 3;
+/** Count only evidence tied to findings persisted by the same challenge report. */
+export declare function getResolvedChallengeEvidence(report: ChallengeReport | undefined): ChallengeResolutionEvidence[];
+/** Build a report whose resolution state is derived exclusively from explicit evidence. */
+export declare function buildChallengeReport(input: {
+    scenarios: FailureScenario[];
+    focusAreas: string[];
+    overallRisk: ChallengeReport['overallRisk'];
+    previousReport?: ChallengeReport;
+    runAt?: string;
+}): ChallengeReport;
+//# sourceMappingURL=challenge-report.d.ts.map

package/dist/tools/challenge-spec/challenge-report.js

@@ -0,0 +1,55 @@
+export const MINIMUM_RESOLVED_CHALLENGES = 3;
+function isExplicitResolutionEvidence(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.scenario === 'string' &&
+        candidate.scenario.trim().length > 0 &&
+        (candidate.resolution === 'mitigated' || candidate.resolution === 'accepted') &&
+        typeof candidate.evidence === 'string' &&
+        candidate.evidence.trim().length > 0 &&
+        typeof candidate.resolvedAt === 'string' &&
+        candidate.resolvedAt.trim().length > 0);
+}
+function uniqueMatchingEvidence(report, scenarioNames) {
+    const evidence = Array.isArray(report?.resolutionEvidence) ? report.resolutionEvidence : [];
+    const matched = new Map();
+    for (const item of evidence) {
+        if (isExplicitResolutionEvidence(item) && scenarioNames.has(item.scenario)) {
+            matched.set(item.scenario, item);
+        }
+    }
+    return [...matched.values()];
+}
+/** Count only evidence tied to findings persisted by the same challenge report. */
+export function getResolvedChallengeEvidence(report) {
+    if (!Array.isArray(report?.findings)) {
+        return [];
+    }
+    const scenarioNames = new Set(report.findings
+        .map((finding) => finding.scenario)
+        .filter((scenario) => typeof scenario === 'string' && scenario.trim().length > 0));
+    return uniqueMatchingEvidence(report, scenarioNames);
+}
+/** Build a report whose resolution state is derived exclusively from explicit evidence. */
+export function buildChallengeReport(input) {
+    const scenarioNames = new Set(input.scenarios.map((scenario) => scenario.scenario));
+    const resolutionEvidence = uniqueMatchingEvidence(input.previousReport, scenarioNames);
+    const resolvedScenarios = new Set(resolutionEvidence.map((item) => item.scenario));
+    const addressedCount = resolvedScenarios.size;
+    return {
+        runAt: input.runAt ?? new Date().toISOString(),
+        totalScenarios: input.scenarios.length,
+        addressedCount,
+        focusAreas: input.focusAreas,
+        overallRisk: input.overallRisk,
+        passed: addressedCount >= MINIMUM_RESOLVED_CHALLENGES,
+        findings: input.scenarios.map((scenario) => ({
+            scenario: scenario.scenario,
+            resolved: resolvedScenarios.has(scenario.scenario),
+        })),
+        resolutionEvidence,
+    };
+}
+//# sourceMappingURL=challenge-report.js.map

package/dist/tools/challenge-spec.js

@@ -18,6 +18,7 @@ import { calculateTokenBudget, injectBudgetIntoPrompt } from '../engine/token-bu
 import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 import { detectChallengeCapabilities, } from './challenge-spec/scenarios-utils.js';
 import { collectCapabilityScenarios } from './challenge-spec/scenario-collector.js';
+import { buildChallengeReport } from './challenge-spec/challenge-report.js';
 const ALL_FOCUS_AREAS = [
     'failures',
     'concurrency',
@@ -193,6 +194,12 @@ export async function handleChallengeSpec(args, server) {
         scalabilityAssessment,
         overallRisk,
     };
+    const challengeReport = buildChallengeReport({
+        scenarios: failureScenariosScored,
+        focusAreas,
+        overallRisk,
+        previousReport: spec.challengeReport,
+    });
     const rawHumanSummary = buildChallengeSpecSummary(prioritized, overallRisk);
     // SPEC-620: Inject token budget tag into the LLM-facing summary prompt
     const specDevHours = spec.estimation.devHours;
@@ -232,18 +239,12 @@ export async function handleChallengeSpec(args, server) {
                 checkedAt: new Date().toISOString(),
             }
             : null,
+        challengeReport,
     };
     // SPEC-964: Persist challenge report so update_status can gate on it
     try {
         await updateSpec(projectId, specId, {
-            challengeReport: {
-                runAt: new Date().toISOString(),
-                totalScenarios: actionableFailureScenarios.length,
-                addressedCount: actionableFailureScenarios.length,
-                focusAreas: focusAreas,
-                overallRisk: overallRisk,
-                passed: true,
-            },
+            challengeReport,
         });
     }
     catch {

package/dist/tools/clarify-requirements/multiple-choice.js

@@ -277,7 +277,7 @@ export function attachOptions(question) {
  * The returned string is suitable for passing directly to create_spec.
  */
 export function buildSuggestedDescription(topic, answers, questions) {
-    const parts = [`Feature: ${topic}.`];
+    const parts = [`Topic: ${topic}.`];
     for (const q of questions) {
         const answer = answers[q.id];
         if (answer === undefined || answer.trim() === '') {

package/dist/tools/clarify-requirements/questions-context.js

@@ -6,13 +6,12 @@ import { buildSuggestedAnswers } from './questions.js';
  */
 export function generateQuestions(topic, _context, knowledge, maxQuestions) {
     const questions = [];
-    const lower = topic.toLowerCase();
     let idx = 0;
     const nextId = () => `q-${++idx}`;
     // === Core question: What do you want? (always relevant) ===
     questions.push({
         id: nextId(),
-        question: `What is the main goal of "${topic}"? What should the user be able to do?`,
+        question: `What observable behavior or result should "${topic}" produce?`,
         category: 'scope',
         importance: 'critical',
     });
@@ -26,16 +25,13 @@ export function generateQuestions(topic, _context, knowledge, maxQuestions) {
     // === Acceptance: What does done look like? ===
     questions.push({
         id: nextId(),
-        question: `What does "done" look like? Describe the ideal user flow.`,
+        question: `Which explicit observations or checks will prove that "${topic}" is done?`,
         category: 'acceptance',
         importance: 'critical',
     });
     // === Context-specific (only if topic mentions specific domains) ===
     // Auth related — only ask which method, nothing else
-    if (lower.includes('auth') ||
-        lower.includes('login') ||
-        lower.includes('register') ||
-        lower.includes('password')) {
+    if (hasAffirmedTerm(topic, /\b(?:auth|authentication|login|register|password)\b/i)) {
         questions.push({
             id: nextId(),
             question: `What login methods? (email/password, Google, Apple, magic link, etc.)`,
@@ -44,10 +40,7 @@ export function generateQuestions(topic, _context, knowledge, maxQuestions) {
         });
     }
     // UI related — only ask if there are mockups
-    if (lower.includes('ui') ||
-        lower.includes('page') ||
-        lower.includes('screen') ||
-        lower.includes('dashboard')) {
+    if (hasAffirmedTerm(topic, /\b(?:ui|page|screen|dashboard)\b/i)) {
         questions.push({
             id: nextId(),
             question: `Are there mockups or a reference design to follow?`,
@@ -71,4 +64,11 @@ export function generateQuestions(topic, _context, knowledge, maxQuestions) {
         suggestedAnswers: buildSuggestedAnswers(q, knowledge),
     }));
 }
+const NEGATION_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)\b/i;
+function hasAffirmedTerm(text, pattern) {
+    return text.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=questions-context.js.map

package/dist/tools/clarify-requirements/questions.js

@@ -7,28 +7,22 @@ export function generateMetaQuestions() {
     return [
         {
             id: 'meta-1',
-            question: 'Is this a brand new feature or an improvement to something that already exists?',
+            question: 'Which change type best describes the request?',
             category: 'scope',
             importance: 'critical',
             suggestedAnswers: ['New feature', 'Improvement to existing feature', 'Bug fix', 'Refactor'],
         },
         {
             id: 'meta-2',
-            question: 'Who is the primary user that benefits from this? (e.g., end user, admin, developer)',
+            question: 'What observable outcome must this work produce?',
             category: 'scope',
             importance: 'critical',
-            suggestedAnswers: ['End user', 'Admin', 'Developer/internal', 'All users'],
         },
         {
             id: 'meta-3',
-            question: 'What is the minimum viable scope — what would make this "done" at a basic level?',
+            question: 'Which boundaries are explicitly in scope and out of scope?',
             category: 'scope',
             importance: 'critical',
-            suggestedAnswers: [
-                'Just the core happy path',
-                'Happy path + error handling',
-                'Full feature with edge cases',
-            ],
         },
     ];
 }
@@ -97,20 +91,6 @@ export function buildSuggestedAnswers(question, knowledge) {
             ];
         }
     }
-    // Performance questions
-    if (lower.includes('performance') ||
-        lower.includes('response time') ||
-        lower.includes('throughput')) {
-        return ['< 200ms response', '< 1s response', 'No strict requirement', 'Depends on load'];
-    }
-    // Auth questions
-    if (lower.includes('authentication') || lower.includes('auth')) {
-        return ['JWT tokens', 'Session-based', 'OAuth 2.0', 'No authentication needed', 'API key'];
-    }
-    // Timeline questions
-    if (lower.includes('deadline') || lower.includes('timeline')) {
-        return ['No strict deadline', 'Within 1 week', 'Within 1 sprint (2 weeks)', 'Specific date'];
-    }
     return [];
 }
 //# sourceMappingURL=questions.js.map

package/dist/tools/clarify-requirements.js

@@ -6,6 +6,12 @@ import { isShortTopic, generateMetaQuestions, detectContradictions, buildSuggest
 import { generateQuestions } from './clarify-requirements/questions-context.js';
 import { detectStack, shouldSkipQuestion, attachOptions, buildSuggestedDescription, } from './clarify-requirements/multiple-choice.js';
 import { compactJson, compactResult, compactError } from './output-formatter.js';
+function buildConfirmedChoices(questions, answers) {
+    return questions.flatMap((question) => {
+        const value = answers[question.id]?.trim();
+        return value ? [{ questionId: question.id, value, source: 'user_confirmation' }] : [];
+    });
+}
 /** Resume an existing clarification session with new answers. */
 async function handleResumeSession(projectId, sessionId, newAnswers, knowledge) {
     const existing = await knowledgeStore.getClarification(projectId, sessionId).catch(() => null);
@@ -50,11 +56,14 @@ async function handleResumeSession(projectId, sessionId, newAnswers, knowledge)
             category: q.category,
             importance: q.importance,
             suggestedAnswers: q.suggestedAnswers,
+            ...(q.suggestedAnswers.length > 0 ? { suggestedAnswersClassification: 'candidate' } : {}),
             options: q.options,
+            ...(q.options ? { optionsClassification: 'candidate' } : {}),
             skipped: q.skipped,
             answered: mergedAnswers[q.id] !== undefined,
         })),
         specReady,
+        confirmedChoices: buildConfirmedChoices(enriched, mergedAnswers),
         ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
         answeredCount: Object.keys(mergedAnswers).length,
         ...(contradictions.length > 0
@@ -126,6 +135,29 @@ export async function handleClarifyRequirements(params, server) {
             const skipped = shouldSkipQuestion(q, stack);
             return skipped ? { ...withOptions, skipped: true } : withOptions;
         });
+        const detectedEvidence = [
+            ...(stack.language
+                ? [{ field: 'language', value: stack.language, source: 'project_manifest' }]
+                : knowledge?.language && knowledge.language !== 'unknown'
+                    ? [{ field: 'language', value: knowledge.language, source: 'project_knowledge' }]
+                    : []),
+            ...(stack.framework
+                ? [{ field: 'framework', value: stack.framework, source: 'project_manifest' }]
+                : knowledge?.framework
+                    ? [
+                        {
+                            field: 'framework',
+                            value: knowledge.framework,
+                            source: 'project_knowledge',
+                        },
+                    ]
+                    : []),
+            ...(stack.database
+                ? [{ field: 'database', value: stack.database, source: 'project_manifest' }]
+                : knowledge?.database && knowledge.database !== 'unknown'
+                    ? [{ field: 'database', value: knowledge.database, source: 'project_knowledge' }]
+                    : []),
+        ];
         // Determine if spec is ready (all non-skipped critical questions have non-empty answers)
         const criticalIds = questions
             .filter((q) => q.importance === 'critical' && q.skipped !== true)
@@ -170,9 +202,15 @@ export async function handleClarifyRequirements(params, server) {
                 suggestedAnswer: q.suggestedAnswer,
                 /* v8 ignore next 1 */
                 suggestedAnswers: q.suggestedAnswers ?? [],
+                ...(q.suggestedAnswers && q.suggestedAnswers.length > 0
+                    ? { suggestedAnswersClassification: 'candidate' }
+                    : {}),
                 options: q.options,
+                ...(q.options ? { optionsClassification: 'candidate' } : {}),
                 skipped: q.skipped,
             })),
+            detectedEvidence,
+            confirmedChoices: buildConfirmedChoices(questions, currentAnswers),
             specReady,
             ...(suggestedDescription !== undefined ? { suggestedDescription } : {}),
             instructions: specReady

package/dist/tools/create-spec/autopilot-analyzer.d.ts

@@ -20,7 +20,7 @@ export declare function getEmptyAutopilotResult(): AutopilotAnalysis;
  * Analyze the project to enrich a spec with real file paths and patterns.
  * Runs automatically during create_spec — no user interaction needed.
  */
-export declare function analyzeProjectForSpec(projectPath: string, description: string, title: string, knowledge: ProjectKnowledge | null): Promise<AutopilotAnalysis>;
+export declare function analyzeProjectForSpec(projectPath: string, description: string, title: string, _knowledge: ProjectKnowledge | null): Promise<AutopilotAnalysis>;
 /**
  * SPEC-619 AC1: Detect broad-scope descriptions that mention 2+ major subsystems.
  * When true, create_spec should ask clarifying questions before proceeding.

package/dist/tools/create-spec/autopilot-analyzer.js

@@ -19,7 +19,7 @@ export function getEmptyAutopilotResult() {
  * Analyze the project to enrich a spec with real file paths and patterns.
  * Runs automatically during create_spec — no user interaction needed.
  */
-export async function analyzeProjectForSpec(projectPath, description, title, knowledge) {
+export async function analyzeProjectForSpec(projectPath, description, title, _knowledge) {
     const result = {
         suggestedFiles: { create: [], modify: [], test: [] },
         detectedPatterns: [],
@@ -68,10 +68,8 @@ export async function analyzeProjectForSpec(projectPath, description, title, kno
     catch {
         // Best-effort — file scanning failure doesn't block spec creation
     }
-    // Detect stack patterns and suggest relevant criteria
-    if (knowledge) {
-        result.detectedPatterns = detectPatterns(knowledge, description);
-    }
+    // Detect patterns only from affirmed request wording.
+    result.detectedPatterns = detectPatterns(description);
     return result;
 }
 /** Check if description contains technical terms (stack, framework, or code references). */
@@ -89,7 +87,23 @@ function hasTechnicalTerms(description) {
         /\.\w{2,4}\b/, // file extensions like .ts, .py
         /src\/|tests\/|lib\/|app\//, // file paths
     ];
-    return techTerms.some((re) => re.test(description));
+    return techTerms.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|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);
+    });
 }
 /**
  * SPEC-619 AC1: Detect broad-scope descriptions that mention 2+ major subsystems.
@@ -100,8 +114,7 @@ function hasTechnicalTerms(description) {
  * one feature, not two independent systems).
  */
 export function detectBroadScope(description) {
-    const lower = description.toLowerCase();
-    const wordCount = lower.trim().split(/\s+/).length;
+    const wordCount = description.trim().split(/\s+/).length;
     const subsystems = [
         /\b(auth|authentication|login|signup|sign.?up|register|oauth|sso)\b/,
         /\b(payment|billing|invoice|subscription|stripe|checkout|pricing)\b/,
@@ -114,7 +127,7 @@ export function detectBroadScope(description) {
         /\b(user.?management|profile|account|role|permission|rbac)\b/,
         /\b(chat|messaging|real.?time|websocket|feed|timeline)\b/,
     ];
-    const matched = subsystems.filter((re) => re.test(lower));
+    const matched = subsystems.filter((pattern) => hasAffirmedPattern(description, pattern));
     // Longer descriptions are specific enough to reference adjacent domain terms
     // without being genuinely broad (e.g. "Stripe billing + webhook handler" = one feature).
     const threshold = wordCount >= 20 ? 3 : 2;
@@ -135,62 +148,24 @@ function inferTestPath(srcPath) {
     return `tests/${withoutExt}.test${ext}`;
 }
 /** Detect relevant patterns from project knowledge. */
-function detectPatterns(knowledge, description) {
+function detectPatterns(description) {
     const patterns = [];
-    const desc = description.toLowerCase();
-    const hasDatabaseIntent = desc.includes('data') ||
-        desc.includes('database') ||
-        desc.includes('tabla') ||
-        desc.includes('schema') ||
-        desc.includes('rls') ||
-        desc.includes('rpc') ||
-        desc.includes('migration') ||
-        desc.includes('persistence') ||
-        desc.includes('data access');
-    const hasUiIntent = desc.includes('component') ||
-        desc.includes('ui') ||
-        desc.includes('page') ||
-        desc.includes('screen') ||
-        desc.includes('form') ||
-        desc.includes('layout') ||
-        desc.includes('style') ||
-        desc.includes('button') ||
-        desc.includes('modal') ||
-        desc.includes('dialog');
+    const hasDatabaseIntent = hasAffirmedPattern(description, /\b(?:data|database|tabla|schema|rls|rpc|migration|persistence|data access)\b/i);
     if (hasDatabaseIntent) {
         patterns.push('database');
     }
-    if (knowledge.framework?.toLowerCase().includes('next') && desc.includes('page')) {
-        patterns.push('nextjs-pages');
-    }
-    if (knowledge.framework?.toLowerCase().includes('react') && hasUiIntent) {
-        patterns.push('react-components');
-    }
-    if (desc.includes('api') || desc.includes('endpoint')) {
+    if (hasAffirmedPattern(description, /\b(?:api|endpoint)\b/i)) {
         patterns.push('api-endpoint');
     }
-    if (desc.includes('auth') || desc.includes('login')) {
+    if (hasAffirmedPattern(description, /\b(?:auth|authentication|login)\b/i)) {
         patterns.push('authentication');
     }
-    if (desc.includes('test') || desc.includes('coverage')) {
+    if (hasAffirmedPattern(description, /\b(?:test|testing|coverage)\b/i)) {
         patterns.push('testing');
     }
-    if (knowledge.stack.some((s) => s.toLowerCase().includes('supabase')) && hasDatabaseIntent) {
-        patterns.push('supabase');
-    }
     // SPEC-535: Detect LLM/foundation model features for EU AI Act Article 53-55 compliance
-    if (desc.includes('llm') ||
-        desc.includes('ai ') ||
-        desc.includes(' ai') ||
-        desc.includes('claude') ||
-        desc.includes('openai') ||
-        desc.includes('gpt') ||
-        desc.includes('gemini') ||
-        desc.includes('anthropic') ||
-        desc.includes('chatbot') ||
-        desc.includes('language model') ||
-        desc.includes('foundation model') ||
-        (desc.includes('chat') && desc.includes('model'))) {
+    if (hasAffirmedPattern(description, /\b(?:llm|ai|claude|openai|gpt|gemini|anthropic|chatbot|language model|foundation model)\b/i) ||
+        (hasAffirmedPattern(description, /\bchat\b/i) && hasAffirmedPattern(description, /\bmodel\b/i))) {
         patterns.push('llm-feature');
     }
     return patterns;