@planu/cli 4.13.0 → 5.0.0

package/dist/engine/skill-adapter/index.js

@@ -5,6 +5,8 @@ import { join } from 'node:path';
 import { readSkillRegistry, writeSkillRegistryEntry, } from '../../storage/skill-registry-storage.js';
 import { PLACEHOLDER_MAP } from './placeholder-map.js';
 import { rewritePackageManagerCommands, rewriteTestRunnerCommands } from './command-rewriter.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
 export { PLACEHOLDER_MAP } from './placeholder-map.js';
 export { rewritePackageManagerCommands, rewriteTestRunnerCommands } from './command-rewriter.js';
 // ---------------------------------------------------------------------------
@@ -84,8 +86,6 @@ export function adaptSkillContent(rawContent, knowledge) {
 // ---------------------------------------------------------------------------
 // File I/O orchestration
 // ---------------------------------------------------------------------------
-/** Cache directory path relative to projectPath */
-const CACHE_REL = '.planu/skill-cache';
 /** Installation directory relative to projectPath */
 const INSTALL_REL = '.claude/skills';
 /**
@@ -101,7 +101,7 @@ export async function adaptAndInstallSkill(projectPath, skillName, knowledge) {
     const entry = registry.installed[skillName];
     const source = entry?.source ?? 'anthropic'; // default to 'anthropic' if not yet registered
     // Resolve raw cache path
-    const cachePath = join(projectPath, CACHE_REL, source, `${skillName}.md`);
+    const cachePath = join(resolveStorageLayout().cache, 'skills', hashProjectPath(projectPath), source, `${skillName}.md`);
     // Read raw content — throw if missing (caller should re-fetch via SPEC-681)
     let rawContent;
     try {

package/dist/engine/skill-adapter/placeholder-map.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 /**
  * Ordered list of placeholder definitions used during skill adaptation.
  * Each entry maps a template placeholder to a ProjectKnowledge field or a derive function.
@@ -26,7 +27,7 @@ export const PLACEHOLDER_MAP = [
     {
         placeholder: '{language}',
         knowledgePath: 'language',
-        fallback: 'typescript',
+        fallback: technologyValue('technology-typescript-969545'),
     },
     {
         placeholder: '{framework}',
@@ -36,7 +37,7 @@ export const PLACEHOLDER_MAP = [
     {
         placeholder: '{test_runner}',
         knowledgePath: null,
-        fallback: 'vitest',
+        fallback: technologyValue('technology-vitest-a9127f'),
         derive: (k) => {
             if (!k.testCommand) {
                 return null;

package/dist/engine/skill-bootstrap/stack-matcher.js

@@ -1,25 +1,24 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/skill-bootstrap/stack-matcher.ts — SPEC-439: Detect project stack and match to skills
-// SPEC-597-EXEMPT: npm-package→canonical-name mapping. Lookup table consumed
-// at runtime; JSON externalization adds I/O without payoff.
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 const DEP_TO_TECH = {
     // Frontend frameworks
-    next: 'nextjs',
-    react: 'react',
+    next: technologyValue('technology-nextjs-c93379'),
+    react: technologyValue('technology-react-275976'),
     vue: 'vuejs',
-    '@angular/core': 'angular',
-    svelte: 'svelte',
-    '@sveltejs/kit': 'sveltekit',
+    '@angular/core': technologyValue('technology-angular-a39f89'),
+    svelte: technologyValue('technology-svelte-c190ac'),
+    '@sveltejs/kit': technologyValue('technology-sveltekit-eefb03'),
     'solid-js': 'solidjs',
     '@solidjs/start': 'solidstart',
-    nuxt: 'nuxt',
-    astro: 'astro',
-    remix: 'remix',
+    nuxt: technologyValue('technology-nuxt-22c407'),
+    astro: technologyValue('technology-astro-23661e'),
+    remix: technologyValue('technology-remix-0c5d96'),
     gatsby: 'gatsby',
     qwik: 'qwik',
     // Styling
-    tailwindcss: 'tailwind',
+    tailwindcss: technologyValue('technology-tailwind-44c8cf'),
     'styled-components': 'styled-components',
     '@emotion/react': 'emotion',
     sass: 'sass',
@@ -38,25 +37,25 @@ const DEP_TO_TECH = {
     mobx: 'mobx',
     nanostores: 'nanostores',
     // Backend / Node
-    express: 'express',
-    fastify: 'fastify',
+    express: technologyValue('technology-express-008231'),
+    fastify: technologyValue('technology-fastify-cbe57e'),
     hono: 'hono',
     koa: 'koa',
-    nestjs: 'nestjs',
-    '@nestjs/core': 'nestjs',
+    nestjs: technologyValue('technology-nestjs-2d0087'),
+    '@nestjs/core': technologyValue('technology-nestjs-2d0087'),
     elysia: 'elysia',
     // ORMs / DB
-    prisma: 'prisma',
-    '@prisma/client': 'prisma',
-    'drizzle-orm': 'drizzle',
-    typeorm: 'typeorm',
-    sequelize: 'sequelize',
-    mongoose: 'mongoose',
+    prisma: technologyValue('technology-prisma-99497c'),
+    '@prisma/client': technologyValue('technology-prisma-99497c'),
+    'drizzle-orm': technologyValue('technology-drizzle-424f22'),
+    typeorm: technologyValue('technology-typeorm-527d4d'),
+    sequelize: technologyValue('technology-sequelize-d18291'),
+    mongoose: technologyValue('technology-mongoose-4e1812'),
     '@planetscale/database': 'planetscale',
     '@vercel/postgres': 'vercel-postgres',
     'better-sqlite3': 'sqlite',
     // BaaS / Cloud
-    '@supabase/supabase-js': 'supabase',
+    '@supabase/supabase-js': technologyValue('technology-supabase-4d7594'),
     firebase: 'firebase',
     'firebase-admin': 'firebase',
     '@aws-sdk/client-s3': 'aws',
@@ -73,15 +72,15 @@ const DEP_TO_TECH = {
     '@clerk/remix': 'clerk',
     'better-auth': 'better-auth',
     // Testing
-    vitest: 'vitest',
-    jest: 'jest',
-    playwright: 'playwright',
+    vitest: technologyValue('technology-vitest-a9127f'),
+    jest: technologyValue('technology-jest-35e99f'),
+    playwright: technologyValue('technology-playwright-7827e8'),
     cypress: 'cypress',
     '@testing-library/react': 'testing-library',
     storybook: 'storybook',
     '@storybook/react': 'storybook',
     // Build / Meta
-    typescript: 'typescript',
+    typescript: technologyValue('technology-typescript-969545'),
     vite: 'vite',
     turbo: 'turborepo',
     nx: 'nx',
@@ -97,23 +96,23 @@ const DEP_TO_TECH = {
     '@langchain/core': 'langchain',
     ollama: 'ollama',
     // Payments
-    stripe: 'stripe',
-    '@stripe/stripe-js': 'stripe',
+    stripe: technologyValue('technology-stripe-2bed20'),
+    '@stripe/stripe-js': technologyValue('technology-stripe-2bed20'),
     // APIs / GraphQL
-    graphql: 'graphql',
+    graphql: technologyValue('technology-graphql-aed31c'),
     'apollo-server': 'apollo',
     '@apollo/client': 'apollo',
-    trpc: 'trpc',
-    '@trpc/server': 'trpc',
+    trpc: technologyValue('technology-trpc-7a75ed'),
+    '@trpc/server': technologyValue('technology-trpc-7a75ed'),
     // Mobile
     'react-native': 'react-native',
     expo: 'expo',
     // Python (detectados en requirements.txt)
-    fastapi: 'fastapi',
-    django: 'django',
-    flask: 'flask',
-    sqlalchemy: 'sqlalchemy',
-    pydantic: 'pydantic',
+    fastapi: technologyValue('technology-fastapi-6aee0e'),
+    django: technologyValue('technology-django-7d8a08'),
+    flask: technologyValue('technology-flask-b87aa5'),
+    sqlalchemy: technologyValue('technology-sqlalchemy-37f268'),
+    pydantic: technologyValue('technology-pydantic-636623'),
 };
 async function readFileSafe(filePath) {
     try {
@@ -150,16 +149,16 @@ async function detectFromPackageJson(projectPath) {
     return techs;
 }
 const PYTHON_DEP_TO_TECH = {
-    fastapi: 'fastapi',
-    django: 'django',
-    flask: 'flask',
-    sqlalchemy: 'sqlalchemy',
-    pydantic: 'pydantic',
-    celery: 'celery',
-    pytest: 'pytest',
-    uvicorn: 'fastapi',
-    starlette: 'fastapi',
-    alembic: 'sqlalchemy',
+    fastapi: technologyValue('technology-fastapi-6aee0e'),
+    django: technologyValue('technology-django-7d8a08'),
+    flask: technologyValue('technology-flask-b87aa5'),
+    sqlalchemy: technologyValue('technology-sqlalchemy-37f268'),
+    pydantic: technologyValue('technology-pydantic-636623'),
+    celery: technologyValue('technology-celery-ddc517'),
+    pytest: technologyValue('technology-pytest-2b0121'),
+    uvicorn: technologyValue('technology-fastapi-6aee0e'),
+    starlette: technologyValue('technology-fastapi-6aee0e'),
+    alembic: technologyValue('technology-sqlalchemy-37f268'),
     torch: 'pytorch',
     tensorflow: 'tensorflow',
     pandas: 'pandas',
@@ -190,8 +189,8 @@ async function detectFromGemfile(projectPath) {
         return [];
     }
     const techs = [];
-    if (content.includes('rails')) {
-        techs.push('rails');
+    if (content.includes(technologyValue('technology-rails-2e1d59'))) {
+        techs.push(technologyValue('technology-rails-2e1d59'));
     }
     return techs;
 }

package/dist/engine/skill-generation/stack-content-generator.js

@@ -1,6 +1,4 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // engine/skill-generation/stack-content-generator.ts — SPEC-607
 // Generates rich, stack-aware skill content from JSON templates and detected project stack.
 import { readFile } from 'node:fs/promises';

package/dist/engine/skill-generator/workflow-skill-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685
 // Generates all 22 workflow skill files for a project.
 // Delegates placeholder substitution to adaptSkillContent (SPEC-682 — DRY).
@@ -48,7 +49,7 @@ function applyFallbacks(knowledge) {
         buildCommand: knowledge.buildCommand ?? 'npm run build',
         lintCommand: knowledge.lintCommand ?? 'npm run lint',
         // language is typed as string (non-null) — no fallback needed
-        language: knowledge.language || 'typescript',
+        language: knowledge.language || technologyValue('technology-typescript-969545'),
     };
 }
 // ---------------------------------------------------------------------------

package/dist/engine/skill-registry/ttl-refresh.js

@@ -3,6 +3,8 @@
 import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fetchAnthropicSkillContent } from './anthropic-adapter.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
 const TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const SKILLS_DIR = '.claude/skills';
 const MANIFEST_FILE = 'manifest.json';
@@ -37,7 +39,7 @@ function isStale(entry) {
 // Backup
 // ---------------------------------------------------------------------------
 async function backupSkill(projectPath, skillName, content) {
-    const cacheDir = join(projectPath, '.planu', 'skill-cache');
+    const cacheDir = join(resolveStorageLayout().cache, 'skills', hashProjectPath(projectPath));
     await mkdir(cacheDir, { recursive: true });
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     const fileName = `${skillName}-${ts}.md`;

package/dist/engine/skills/skills-fetcher.js

@@ -1,7 +1,4 @@
-// engine/skills/skills-fetcher.ts — SPEC-022: skills.sh catalog fetcher
-// Business logic for fetching and recommending AI agent skills.
-// Lives in engine/ so engine/ modules can import it without violating architecture.
-// SPEC-198: design/marketing skill detection added.
+import { technologyValue } from '../technology-registry.js';
 import { fetchUrl } from '../web-fetcher/http-client.js';
 const MARKETING_DIR_KEYWORDS = ['landing', 'marketing', 'brand', 'assets/brand', 'brand-assets'];
 const MARKETING_STACK_KEYWORDS = ['landing', 'saas', 'startup', 'website', 'brand', 'marketing'];
@@ -93,7 +90,7 @@ function buildFallbackSkills(knowledge) {
     const skills = [];
     const stackLower = knowledge.stack.map((s) => s.toLowerCase());
     const lang = knowledge.language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         skills.push({
             name: 'typescript-patterns',
             description: 'TypeScript best practices, strict mode patterns, and type safety conventions',
@@ -101,7 +98,7 @@ function buildFallbackSkills(knowledge) {
             justification: `Project uses ${knowledge.language}`,
         });
     }
-    if (stackLower.some((s) => s.includes('react'))) {
+    if (stackLower.some((s) => s.includes(technologyValue('technology-react-275976')))) {
         skills.push({
             name: 'react-patterns',
             description: 'React component patterns, hooks best practices, and performance optimization',

package/dist/engine/skills-reconciler.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/skills-reconciler.ts — SPEC-189: Detect stack changes and reconcile skills
 // SPEC-395: autoFixSkills — install missing, remove stale, repair corrupt paths.
 // SPEC-607: Detect old-format skills and new agents, trigger regeneration.
@@ -113,11 +114,9 @@ async function detectOldFormatSkills(projectPath) {
     }
     return oldFormat;
 }
-/** Agent presence signals (directory or file that indicates an agent is used). */
+/** Supported host presence signals handled by the canonical host asset writer. */
 const AGENT_PRESENCE_SIGNALS = {
-    cursor: '.cursor',
-    copilot: '.github',
-    gemini: 'GEMINI.md',
+    gemini: '.gemini',
 };
 /**
  * Detect AI agents that are present in the project but don't yet have skills
@@ -130,7 +129,7 @@ async function detectNewAgentTargets(projectPath) {
         try {
             await fs.access(signalPath);
             // Agent is present — check if it has any Planu skills
-            const hasSkills = await agentHasPlanuSkills(projectPath, agentName);
+            const hasSkills = await agentHasPlanuSkills(projectPath);
             if (!hasSkills) {
                 newTargets.push(agentName);
             }
@@ -141,40 +140,20 @@ async function detectNewAgentTargets(projectPath) {
     }));
     return newTargets;
 }
-/** Check if a specific agent already has Planu-generated skills. */
-async function agentHasPlanuSkills(projectPath, agentName) {
-    const checkPaths = [];
-    if (agentName === 'cursor') {
-        checkPaths.push(path.join(projectPath, '.cursor', 'rules'));
-    }
-    else if (agentName === 'copilot') {
-        checkPaths.push(path.join(projectPath, '.github', 'copilot-instructions.md'));
-    }
-    else if (agentName === 'gemini') {
-        checkPaths.push(path.join(projectPath, 'GEMINI.md'));
-    }
-    for (const p of checkPaths) {
-        try {
-            const stat = await fs.stat(p);
-            if (stat.isDirectory()) {
-                const entries = await fs.readdir(p);
-                if (entries.some((e) => e.endsWith('.mdc') || e.endsWith('.md'))) {
-                    return true;
-                }
-            }
-            else if (stat.isFile()) {
-                const content = await fs.readFile(p, 'utf-8');
-                // Check if Planu has appended content
-                if (content.includes('project-testing') || content.includes('project-deployment')) {
-                    return true;
-                }
-            }
-        }
-        catch {
-            /* not found */
+/** Check the canonical Gemini skills directory for Planu-generated skills. */
+async function agentHasPlanuSkills(projectPath) {
+    try {
+        const skillsPath = path.join(projectPath, '.gemini', 'skills');
+        const stat = await fs.stat(skillsPath);
+        if (!stat.isDirectory()) {
+            return false;
         }
+        const entries = await fs.readdir(skillsPath);
+        return entries.some((entry) => entry.startsWith('planu-') && entry.endsWith('.md'));
+    }
+    catch {
+        return false;
     }
-    return false;
 }
 /**
  * Compute a 0–100 health score.
@@ -194,9 +173,10 @@ function isProtectedBuiltInSkill(name, knowledge) {
     }
     const language = knowledge.language.toLowerCase();
     const stack = knowledge.stack.map((item) => item.toLowerCase());
-    return (language === 'typescript' ||
+    return (language === technologyValue('technology-typescript-969545') ||
         language === 'javascript' ||
-        stack.some((item) => item.includes('typescript') || item.includes('javascript')));
+        stack.some((item) => item.includes(technologyValue('technology-typescript-969545')) ||
+            item.includes('javascript')));
 }
 /** Return a neutral reconciliation when prerequisites are missing. */
 function buildEmptyReconciliation(_reason) {

package/dist/engine/spec-coverage/test-finder.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/spec-coverage/test-finder.ts — Finds test files in a project using
 // multi-ecosystem naming conventions. Pure I/O, no analysis logic.
 import { readFile } from 'node:fs/promises';
@@ -8,7 +9,7 @@ import { glob } from 'glob';
 // ---------------------------------------------------------------------------
 const ECOSYSTEM_PATTERNS = [
     {
-        ecosystem: 'typescript',
+        ecosystem: technologyValue('technology-typescript-969545'),
         patterns: ['**/*.test.ts', '**/*.spec.ts', '**/*.test.js', '**/*.spec.js'],
     },
     { ecosystem: 'python', patterns: ['**/*_test.py', '**/test_*.py'] },
@@ -61,17 +62,17 @@ const SUPERFICIAL_PATTERNS = [
 // ---------------------------------------------------------------------------
 const RUNNER_DETECTORS = [
     {
-        name: 'vitest',
-        ecosystem: 'typescript',
+        name: technologyValue('technology-vitest-a9127f'),
+        ecosystem: technologyValue('technology-typescript-969545'),
         configFiles: ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mts'],
     },
     {
-        name: 'jest',
-        ecosystem: 'typescript',
+        name: technologyValue('technology-jest-35e99f'),
+        ecosystem: technologyValue('technology-typescript-969545'),
         configFiles: ['jest.config.ts', 'jest.config.js', 'jest.config.cjs'],
     },
     {
-        name: 'pytest',
+        name: technologyValue('technology-pytest-2b0121'),
         ecosystem: 'python',
         configFiles: ['pytest.ini', 'pyproject.toml', 'setup.cfg'],
     },

package/dist/engine/spec-diff-engine.js

@@ -90,12 +90,12 @@ function computeLineDiffIterative(linesA, linesB) {
     while (ia < linesA.length || ib < linesB.length) {
         const lineA = linesA[ia];
         const lineB = linesB[ib];
-        if (ia >= linesA.length || lineB === undefined) {
+        if (ia >= linesA.length || lineA === undefined) {
             result.push({ type: 'added', content: lineB ?? '', lineNumberB: ib + 1 });
             ib++;
         }
-        else if (ib >= linesB.length || lineA === undefined) {
-            result.push({ type: 'removed', content: lineA ?? '', lineNumberA: ia + 1 });
+        else if (ib >= linesB.length || lineB === undefined) {
+            result.push({ type: 'removed', content: lineA, lineNumberA: ia + 1 });
             ia++;
         }
         else if (lineA === lineB) {

package/dist/engine/spec-format/acceptance-criteria.d.ts

@@ -1,5 +1,9 @@
 import type { NormalizedAcceptanceCriterion } from '../../types/spec-format.js';
-export declare function extractNormalizedAcceptanceCriteria(raw: string): NormalizedAcceptanceCriterion[];
-export declare function extractAcceptanceCriteriaTexts(raw: string): string[];
+export declare function extractNormalizedAcceptanceCriteria(raw: string, options?: {
+    allowLegacyBodyFallback?: boolean;
+}): NormalizedAcceptanceCriterion[];
+export declare function extractAcceptanceCriteriaTexts(raw: string, options?: {
+    allowLegacyBodyFallback?: boolean;
+}): string[];
 export declare function normalizeAcceptanceCriterionToken(value: string): string;
 //# sourceMappingURL=acceptance-criteria.d.ts.map

package/dist/engine/spec-format/acceptance-criteria.js

@@ -1,12 +1,12 @@
 import { parseFrontmatterScenarios } from '../validator/spec-compliance-runner.js';
 import { stripFrontmatter } from '../frontmatter-parser.js';
-import { extractListItems, extractSection } from '../validator/extractors.js';
+import { extractListItems, extractSection } from './markdown-sections.js';
 import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
-function extractSectionCriteria(section) {
-    const listItems = extractListItems(section);
-    if (listItems.length > 0) {
-        return listItems;
-    }
+const BDD_STEP = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
+const BDD_START = /^(GIVEN|DADO)\b/i;
+const TECHNICAL_MARKER = /^(FILES|FUNCTIONS|TEST|OWNER):/i;
+const EXPLICIT_CRITERION_HEADING = /^#{3,6}\s+((?:AC|AB)\s*-?\s*\d+)\b/i;
+function extractBddBlocks(section) {
     const lines = section.split('\n').map((line) => line.trim());
     if (lines.length === 0) {
         return [];
@@ -21,16 +21,21 @@ function extractSectionCriteria(section) {
             }
             continue;
         }
-        if (/^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i.test(line)) {
-            if (/^(GIVEN|DADO)\b/i.test(line) && current.length > 0) {
+        const withoutListMarker = line.replace(/^(?:[-*+]\s+(?:\[[ xX]\]\s*)?|\d+[.)]\s+)/, '');
+        if (TECHNICAL_MARKER.test(withoutListMarker) || /^#{1,6}\s+/.test(withoutListMarker)) {
+            if (current.length > 0) {
                 bddBlocks.push(current.join(' '));
                 current = [];
             }
-            current.push(line.replace(/^[-*+]\s*/, ''));
             continue;
         }
-        if (current.length > 0) {
-            current.push(line);
+        if (BDD_STEP.test(withoutListMarker)) {
+            if (BDD_START.test(withoutListMarker) && current.length > 0) {
+                bddBlocks.push(current.join(' '));
+                current = [];
+            }
+            current.push(withoutListMarker);
+            continue;
         }
     }
     if (current.length > 0) {
@@ -38,7 +43,54 @@ function extractSectionCriteria(section) {
     }
     return bddBlocks;
 }
-function extractBodyCriteria(raw) {
+function extractExplicitCriterionBodies(section) {
+    const lines = section.split('\n');
+    const bodies = [];
+    let current = null;
+    for (const line of lines) {
+        const heading = EXPLICIT_CRITERION_HEADING.exec(line.trim());
+        if (heading?.[1]) {
+            if (current !== null) {
+                bodies.push(current);
+            }
+            current = { id: heading[1].replace(/[\s-]/g, ''), body: '' };
+            continue;
+        }
+        if (current !== null) {
+            current.body += `${current.body.length > 0 ? '\n' : ''}${line}`;
+        }
+    }
+    if (current !== null) {
+        bodies.push(current);
+    }
+    return bodies;
+}
+function extractOneCriterion(body) {
+    const bddBlocks = extractBddBlocks(body);
+    if (bddBlocks.length > 0) {
+        return bddBlocks.reduce((selected, candidate) => candidate.length > selected.length ? candidate : selected);
+    }
+    const listItem = extractListItems(body).find((item) => !TECHNICAL_MARKER.test(item));
+    return listItem ?? null;
+}
+function extractSectionCriteria(section) {
+    const explicitBodies = extractExplicitCriterionBodies(section);
+    if (explicitBodies.length > 0) {
+        return explicitBodies
+            .map(({ id, body }) => {
+            const criterion = extractOneCriterion(body);
+            return criterion === null ? null : `${id}: ${criterion}`;
+        })
+            .filter((criterion) => criterion !== null);
+    }
+    const listItems = extractListItems(section).filter((item) => !TECHNICAL_MARKER.test(item));
+    if (listItems.length > 0) {
+        const nonStepItems = listItems.filter((item) => !BDD_STEP.test(item));
+        return nonStepItems.length > 0 ? nonStepItems : extractBddBlocks(section);
+    }
+    return extractBddBlocks(section);
+}
+function extractBodyCriteria(raw, options) {
     const body = stripFrontmatter(raw);
     const acceptanceCriteria = extractSection(body, 'acceptance criteria', 'criterios de aceptaci');
     if (acceptanceCriteria) {
@@ -47,11 +99,18 @@ function extractBodyCriteria(raw) {
             return sectionCriteria;
         }
     }
-    return body
+    if (options.allowLegacyBodyFallback === false) {
+        return [];
+    }
+    const checkboxCriteria = body
         .split('\n')
         .map((line) => line.trim())
-        .filter((line) => /^-\s*\[[ x]\]/i.test(line) || /^- .*\bgiven\b.*\bwhen\b.*\bthen\b/i.test(line))
+        .filter((line) => /^-\s*\[[ x]\]/i.test(line))
         .map((line) => line.replace(/^-\s*\[[ x]\]\s*/i, '').trim());
+    if (checkboxCriteria.length > 0) {
+        return checkboxCriteria;
+    }
+    return extractBddBlocks(body);
 }
 function buildCriterion(text, source, index) {
     const trimmed = text.trim();
@@ -68,8 +127,8 @@ function buildCriterion(text, source, index) {
         aliases: identity.aliases,
     };
 }
-export function extractNormalizedAcceptanceCriteria(raw) {
-    const bodyCriteria = extractBodyCriteria(raw)
+export function extractNormalizedAcceptanceCriteria(raw, options = {}) {
+    const bodyCriteria = extractBodyCriteria(raw, options)
         .map((criterion, index) => buildCriterion(criterion, 'body', index))
         .filter((criterion) => criterion !== null);
     if (bodyCriteria.length > 0) {
@@ -79,8 +138,8 @@ export function extractNormalizedAcceptanceCriteria(raw) {
         .map((scenario, index) => buildCriterion(scenario.title, 'frontmatter', index))
         .filter((criterion) => criterion !== null);
 }
-export function extractAcceptanceCriteriaTexts(raw) {
-    return extractNormalizedAcceptanceCriteria(raw).map((criterion) => criterion.text);
+export function extractAcceptanceCriteriaTexts(raw, options = {}) {
+    return extractNormalizedAcceptanceCriteria(raw, options).map((criterion) => criterion.text);
 }
 export function normalizeAcceptanceCriterionToken(value) {
     return normalizeCriterionText(value);

package/dist/engine/spec-format/markdown-sections.d.ts

@@ -0,0 +1,14 @@
+/** Locate one exact markdown section without normalizing or copying source bytes. */
+export declare function findMarkdownSectionRange(content: string, headingName: string): {
+    headingStart: number;
+    contentStart: number;
+    end: number;
+    level: number;
+} | null;
+/**
+ * Extract the text content under a markdown heading that matches any keyword.
+ */
+export declare function extractSection(content: string, ...headingKeywords: string[]): string | null;
+/** Extract bullet and numbered-list item text from a markdown block. */
+export declare function extractListItems(content: string): string[];
+//# sourceMappingURL=markdown-sections.d.ts.map