@planu/cli 4.3.24 → 4.4.0

package/dist/engine/spec-grounding/contract.js

@@ -0,0 +1,186 @@
+const GENERIC_CRITERION_PATTERNS = [
+    /\bimplementation complete\b/i,
+    /\bcomplete and tested\b/i,
+    /\bensure (adequate )?coverage\b/i,
+    /\ball edge cases\b/i,
+    /\bgeneric validation\b/i,
+    /\bautopilot could not infer testable behavior\b/i,
+    /\bdefine acceptance criteria\b/i,
+];
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
+export function normalizeCriterionText(text) {
+    return text
+        .replace(/^[-*]\s*\[[ xX]\]\s*/, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+export function isGenericCriterion(text) {
+    return GENERIC_CRITERION_PATTERNS.some((pattern) => pattern.test(text));
+}
+export function filterGroundedCriteria(criteria) {
+    return criteria.filter((criterion) => criterion.trim().length > 0 && !isGenericCriterion(criterion));
+}
+export function buildCriterionGroundingRecords(args) {
+    const userInput = normalizeCriterionText(args.userInput);
+    const projectEvidence = args.projectEvidence ?? [];
+    const generatedEvidence = args.generatedEvidence ?? [];
+    return args.criteria.map((criterion) => {
+        const normalized = normalizeCriterionText(criterion);
+        if (isGenericCriterion(criterion)) {
+            return {
+                text: criterion,
+                source: 'ungrounded_advisory',
+                evidence: [],
+                confidence: 'low',
+            };
+        }
+        if (normalized.length > 0 && userInput.includes(normalized)) {
+            return {
+                text: criterion,
+                source: 'user_input',
+                evidence: ['create_spec.description'],
+                confidence: 'high',
+            };
+        }
+        if (projectEvidence.length > 0) {
+            return {
+                text: criterion,
+                source: 'project_evidence',
+                evidence: projectEvidence.slice(0, 8),
+                confidence: 'medium',
+            };
+        }
+        return {
+            text: criterion,
+            source: 'documented_assumption',
+            evidence: generatedEvidence.length > 0 ? generatedEvidence.slice(0, 4) : ['generated-spec-body'],
+            confidence: 'medium',
+        };
+    });
+}
+export function getContractCriteria(records) {
+    return records.filter((record) => record.source === 'user_input' || record.source === 'project_evidence');
+}
+export function getAdvisoryCriteria(records) {
+    return records.filter((record) => record.source === 'documented_assumption' || record.source === 'ungrounded_advisory');
+}
+export function renderGroundingFrontmatter(records) {
+    if (records.length === 0) {
+        return ['grounding_required: true', 'grounding:', '  criteria: []'];
+    }
+    return [
+        'grounding_required: true',
+        'grounding:',
+        '  criteria:',
+        ...records.flatMap((record) => [
+            `    - text: "${escapeYaml(record.text)}"`,
+            `      source: ${record.source}`,
+            `      evidence: [${record.evidence.map((item) => `"${escapeYaml(item)}"`).join(', ')}]`,
+            `      confidence: ${record.confidence}`,
+        ]),
+    ];
+}
+export function renderTechnicalReferenceGroundingFrontmatter(records) {
+    if (records.length === 0) {
+        return ['  technicalReferences: []'];
+    }
+    return [
+        '  technicalReferences:',
+        ...records.flatMap((record) => [
+            `    - path: "${escapeYaml(record.path)}"`,
+            `      section: ${record.section}`,
+            `      source: ${record.source}`,
+            `      evidence: [${record.evidence.map((item) => `"${escapeYaml(item)}"`).join(', ')}]`,
+            `      confidence: ${record.confidence}`,
+        ]),
+    ];
+}
+export function checkGroundedSpecContract(spec, content) {
+    const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
+    const required = /^grounding_required:\s*true\s*$/m.test(frontmatter);
+    const records = parseCriterionGroundingRecords(frontmatter);
+    if (!required) {
+        return { passed: true, required: false, issues: [], records };
+    }
+    const issues = [];
+    if (records.length === 0 && spec.scope !== 'trivial') {
+        issues.push(`Spec ${spec.id} requires grounding metadata but has no grounded criteria records.`);
+    }
+    for (const record of records) {
+        if (record.source === 'ungrounded_advisory') {
+            issues.push(`Criterion is advisory-only and cannot be approved as contract: ${record.text}`);
+        }
+        if (record.evidence.length === 0 && record.source !== 'ungrounded_advisory') {
+            issues.push(`Criterion has no grounding evidence: ${record.text}`);
+        }
+    }
+    const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter);
+    for (const record of technicalRecords) {
+        if (record.source === 'ungrounded_advisory') {
+            issues.push(`Technical reference is advisory-only and cannot be contract: ${record.path}`);
+        }
+        if (record.evidence.length === 0 && record.source !== 'ungrounded_advisory') {
+            issues.push(`Technical reference has no grounding evidence: ${record.path}`);
+        }
+    }
+    return {
+        passed: issues.length === 0,
+        required: true,
+        issues,
+        records,
+    };
+}
+export function parseCriterionGroundingRecords(frontmatter) {
+    const records = [];
+    const chunks = frontmatter.split(/\n\s{4}- text:\s*/).slice(1);
+    for (const chunk of chunks) {
+        const text = /^"((?:\\"|[^"])*)"/.exec(chunk)?.[1]?.replace(/\\"/g, '"') ?? '';
+        const source = /^\s{6}source:\s*(\S+)/m.exec(chunk)?.[1];
+        const confidence = /^\s{6}confidence:\s*(\S+)/m.exec(chunk)?.[1];
+        const evidenceRaw = /^\s{6}evidence:\s*\[(.*)\]/m.exec(chunk)?.[1] ?? '';
+        if (!text || !source || !confidence) {
+            continue;
+        }
+        records.push({
+            text,
+            source,
+            evidence: parseYamlInlineStringArray(evidenceRaw),
+            confidence,
+        });
+    }
+    return records;
+}
+export function parseTechnicalReferenceGroundingRecords(frontmatter) {
+    const records = [];
+    const chunks = frontmatter.split(/\n\s{4}- path:\s*/).slice(1);
+    for (const chunk of chunks) {
+        const path = /^"((?:\\"|[^"])*)"/.exec(chunk)?.[1]?.replace(/\\"/g, '"') ?? '';
+        const section = /^\s{6}section:\s*(\S+)/m.exec(chunk)?.[1];
+        const source = /^\s{6}source:\s*(\S+)/m.exec(chunk)?.[1];
+        const confidence = /^\s{6}confidence:\s*(\S+)/m.exec(chunk)?.[1];
+        const evidenceRaw = /^\s{6}evidence:\s*\[(.*)\]/m.exec(chunk)?.[1] ?? '';
+        if (!path || !section || !source || !confidence) {
+            continue;
+        }
+        records.push({
+            path,
+            section,
+            source,
+            evidence: parseYamlInlineStringArray(evidenceRaw),
+            confidence,
+        });
+    }
+    return records;
+}
+function parseYamlInlineStringArray(raw) {
+    if (raw.trim().length === 0) {
+        return [];
+    }
+    const matches = raw.matchAll(/"((?:\\"|[^"])*)"/g);
+    return [...matches].map((match) => match[1]?.replace(/\\"/g, '"') ?? '').filter(Boolean);
+}
+function escapeYaml(value) {
+    return value.replace(/"/g, '\\"');
+}
+//# sourceMappingURL=contract.js.map

package/dist/engine/spec-metrics/actionable-metrics.d.ts

@@ -0,0 +1,10 @@
+import type { ActionableSpecMetric, CriterionGroundingRecord, EvidenceGateIssue, SpecEvidenceIndex } from '../../types/index.js';
+export declare function calculateActionableSpecMetrics(args: {
+    criteria: readonly string[];
+    groundingRecords?: readonly CriterionGroundingRecord[];
+    evidenceIndex?: SpecEvidenceIndex;
+    ambiguityFindings?: readonly string[];
+    driftIssues?: readonly EvidenceGateIssue[];
+}): ActionableSpecMetric[];
+export declare function shouldExposeMetric(metric: ActionableSpecMetric): boolean;
+//# sourceMappingURL=actionable-metrics.d.ts.map

package/dist/engine/spec-metrics/actionable-metrics.js

@@ -0,0 +1,69 @@
+export function calculateActionableSpecMetrics(args) {
+    return [
+        groundingCoverage(args.criteria, args.groundingRecords ?? []),
+        verificationCoverage(args.evidenceIndex),
+        ambiguityCount(args.ambiguityFindings ?? []),
+        driftRisk(args.driftIssues ?? []),
+    ].filter((metric) => metric !== null);
+}
+export function shouldExposeMetric(metric) {
+    return metric.inputs.length > 0 && metric.nextAction.trim().length > 0;
+}
+function groundingCoverage(criteria, records) {
+    const missing = criteria.filter((criterion) => !records.some((record) => normalize(record.text) === normalize(criterion) &&
+        record.source !== 'ungrounded_advisory' &&
+        record.evidence.length > 0));
+    if (criteria.length === 0 || missing.length === 0) {
+        return null;
+    }
+    return {
+        name: 'groundingCoverage',
+        value: Math.round(((criteria.length - missing.length) / criteria.length) * 100),
+        inputs: missing,
+        nextAction: 'Add grounding evidence or move ungrounded criteria to discovery/advisory output.',
+    };
+}
+function verificationCoverage(index) {
+    if (!index) {
+        return null;
+    }
+    const missing = index.criteria.filter((entry) => !entry.evidence.some((record) => record.kind === 'validation' && record.status === 'valid'));
+    if (index.criteria.length === 0 || missing.length === 0) {
+        return null;
+    }
+    return {
+        name: 'verificationCoverage',
+        value: Math.round(((index.criteria.length - missing.length) / index.criteria.length) * 100),
+        inputs: missing.map((entry) => entry.criterion),
+        nextAction: 'Attach validation evidence mapped to each uncovered criterion.',
+    };
+}
+function ambiguityCount(findings) {
+    if (findings.length === 0) {
+        return null;
+    }
+    return {
+        name: 'ambiguityCount',
+        value: findings.length,
+        inputs: [...findings],
+        nextAction: 'Resolve each ambiguity or mark it explicitly out of scope before implementation.',
+    };
+}
+function driftRisk(issues) {
+    const driftIssues = issues.filter((issue) => issue.code.startsWith('done_drift_'));
+    if (driftIssues.length === 0) {
+        return null;
+    }
+    return {
+        name: 'driftRisk',
+        value: driftIssues.some((issue) => issue.code === 'done_drift_unapproved_scope')
+            ? 'high'
+            : 'medium',
+        inputs: driftIssues.map((issue) => issue.message),
+        nextAction: 'Reconcile scope, replace stale evidence, or map validation to the affected criteria.',
+    };
+}
+function normalize(value) {
+    return value.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+//# sourceMappingURL=actionable-metrics.js.map

package/dist/engine/spec-quality/generic-output-gate.d.ts

@@ -0,0 +1,3 @@
+import type { GenericSpecOutputGateResult } from '../../types/index.js';
+export declare function checkGenericSpecOutput(content: string): GenericSpecOutputGateResult;
+//# sourceMappingURL=generic-output-gate.d.ts.map

package/dist/engine/spec-quality/generic-output-gate.js

@@ -0,0 +1,105 @@
+const CRITERIA_SECTION_RE = /^criteria:\n([\s\S]*?)(?=^[a-zA-Z_][\w-]*:|\n---|\s*$)/m;
+const CRITERION_TEXT_RE = /^\s+- text:\s*"?(.+?)"?\s*$/gm;
+const FILE_LINE_RE = /^-\s+(.+?)\s+\((pending|done)\)\s*$/gm;
+const GENERIC_CRITERION_RULES = [
+    {
+        pattern: /\bimplementation (is )?complete\b/i,
+        reason: 'self-certifying completion is not a testable behavior',
+    },
+    {
+        pattern: /\bcomplete and tested\b/i,
+        reason: 'completion and testing must be proven by evidence, not criteria text',
+    },
+    {
+        pattern: /\ball edge cases\b/i,
+        reason: 'edge cases must be named explicitly',
+    },
+    {
+        pattern: /\bgeneric validation\b/i,
+        reason: 'validation must identify the behavior and expected result',
+    },
+    {
+        pattern: /\bensure (adequate )?coverage\b/i,
+        reason: 'coverage claims must map to concrete validation evidence',
+    },
+    {
+        pattern: /\bautopilot could not infer testable behavior\b/i,
+        reason: 'fallback uncertainty cannot become an acceptance criterion',
+    },
+    {
+        pattern: /\bdefine acceptance criteria\b/i,
+        reason: 'a request to define criteria is not itself a criterion',
+    },
+    {
+        pattern: /\b(example only|for example|sample)\b/i,
+        reason: 'example-only references cannot become contract criteria',
+    },
+    {
+        pattern: /\b(add|create|implement)\s+(api\s+)?(endpoint|route|migration)s?\b/i,
+        reason: 'broad implementation references must name grounded behavior and evidence',
+    },
+];
+const PLACEHOLDER_REFERENCE_RULES = [
+    {
+        pattern: /\b(to be determined|tbd|placeholder|not specified)\b/i,
+        reason: 'placeholder references are not grounded implementation ownership',
+    },
+    {
+        pattern: /(^|\/)(example|sample|mock|dummy)[\w.-]*\.[a-z]+$/i,
+        reason: 'example file names must not be persisted as technical ownership',
+    },
+];
+export function checkGenericSpecOutput(content) {
+    const issues = [
+        ...checkCriteria(frontmatterCriteria(content)),
+        ...checkTechnicalReferences(content),
+    ];
+    return { passed: issues.length === 0, issues };
+}
+function frontmatterCriteria(content) {
+    const criteriaSection = CRITERIA_SECTION_RE.exec(content)?.[1] ?? '';
+    const criteria = [];
+    let match = CRITERION_TEXT_RE.exec(criteriaSection);
+    while (match) {
+        const phrase = match[1]?.replace(/\\"/g, '"').trim() ?? '';
+        if (phrase.length > 0) {
+            criteria.push(phrase);
+        }
+        match = CRITERION_TEXT_RE.exec(criteriaSection);
+    }
+    return criteria;
+}
+function checkCriteria(criteria) {
+    const issues = [];
+    for (const criterion of criteria) {
+        for (const rule of GENERIC_CRITERION_RULES) {
+            if (rule.pattern.test(criterion)) {
+                issues.push({
+                    kind: rule.reason.includes('coverage') ? 'unsupported-verification' : 'generic-criterion',
+                    phrase: criterion,
+                    reason: rule.reason,
+                });
+            }
+        }
+    }
+    return issues;
+}
+function checkTechnicalReferences(content) {
+    const issues = [];
+    let match = FILE_LINE_RE.exec(content);
+    while (match) {
+        const phrase = match[1]?.replace(/`/g, '').trim() ?? '';
+        for (const rule of PLACEHOLDER_REFERENCE_RULES) {
+            if (rule.pattern.test(phrase)) {
+                issues.push({
+                    kind: 'placeholder-reference',
+                    phrase,
+                    reason: rule.reason,
+                });
+            }
+        }
+        match = FILE_LINE_RE.exec(content);
+    }
+    return issues;
+}
+//# sourceMappingURL=generic-output-gate.js.map

package/dist/engine/test-contract-generator.js

@@ -25,12 +25,12 @@ function buildContractContent(title, endpoints, format) {
         return buildOpenApiContent(title, endpoints);
     }
     if (format === 'graphql-schema') {
-        return buildGraphqlContent(title);
+        return buildGraphqlContent(title, endpoints);
     }
     if (format === 'pact') {
         return buildPactContent(title, endpoints);
     }
-    return buildTrpcContent(title);
+    return buildTrpcContent(title, endpoints);
 }
 function buildOpenApiContent(title, endpoints) {
     const paths = endpoints
@@ -45,34 +45,45 @@ function buildOpenApiContent(title, endpoints) {
     const openapiVersion = getStandardVersion('openapi') || '3.0.3';
     return `openapi: '${openapiVersion}'\ninfo:\n  title: "${title} API Contract"\n  version: '1.0.0'\npaths:\n${paths}\n`;
 }
-function buildGraphqlContent(title) {
+function toGraphqlFieldName(ep) {
+    const pathName = ep.path
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => segment.replace(/[{}:]/g, ''))
+        .join(' ');
+    const base = toSnake(pathName || 'root')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+    if (ep.method === 'GET') {
+        return base || 'root';
+    }
+    return `${ep.method.toLowerCase()}_${base || 'root'}`;
+}
+function buildGraphqlContent(title, endpoints) {
     const typeName = toPascal(title);
+    const queryFields = endpoints
+        .filter((ep) => ep.method === 'GET')
+        .map((ep) => `  ${toGraphqlFieldName(ep)}: ${typeName}`)
+        .join('\n');
+    const mutationFields = endpoints
+        .filter((ep) => ep.method !== 'GET')
+        .map((ep) => `  ${toGraphqlFieldName(ep)}: ${typeName}`)
+        .join('\n');
     return [
         `# GraphQL schema for: ${title}`,
         '# Generated by Planu SDD MCP Server',
+        '# Only endpoint-derived fields are emitted; add domain fields from an explicit schema.',
         '',
         `type ${typeName} {`,
         '  id: ID!',
-        '  # TODO: add fields',
         '}',
         '',
         'type Query {',
-        `  get${typeName}(id: ID!): ${typeName}`,
-        `  list${typeName}s: [${typeName}!]!`,
+        queryFields || '  _empty: Boolean',
         '}',
         '',
         'type Mutation {',
-        `  create${typeName}(input: Create${typeName}Input!): ${typeName}!`,
-        `  update${typeName}(id: ID!, input: Update${typeName}Input!): ${typeName}!`,
-        `  delete${typeName}(id: ID!): Boolean!`,
-        '}',
-        '',
-        `input Create${typeName}Input {`,
-        '  # TODO: add fields',
-        '}',
-        '',
-        `input Update${typeName}Input {`,
-        '  # TODO: add fields',
+        mutationFields || '  _empty: Boolean',
         '}',
         '',
     ].join('\n');
@@ -90,29 +101,25 @@ function buildPactContent(title, endpoints) {
         metadata: { pactSpecification: { version: '2.0.0' } },
     }, null, 2);
 }
-function buildTrpcContent(title) {
+function buildTrpcProcedure(ep) {
+    const procedureName = toGraphqlFieldName(ep);
+    const procedureKind = ep.method === 'GET' ? 'query' : 'mutation';
+    return [
+        `  ${procedureName}: publicProcedure.${procedureKind}(async () => {`,
+        `    throw new Error('Bind ${ep.method} ${ep.path} to its implementation before running this router.');`,
+        '  }),',
+    ].join('\n');
+}
+function buildTrpcContent(title, endpoints) {
     const routerName = toSnake(title);
+    const procedures = endpoints.map((ep) => buildTrpcProcedure(ep)).join('\n');
     return [
         `// tRPC router contract for: ${title}`,
         '// Generated by Planu SDD MCP Server',
         "import { router, publicProcedure } from '../trpc';",
-        "import { z } from 'zod';",
         '',
         `export const ${routerName}Router = router({`,
-        '  getAll: publicProcedure.query(async () => {',
-        '    // TODO: implement',
-        '    return [];',
-        '  }),',
-        '  getById: publicProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {',
-        '    // TODO: implement',
-        '    return { id: input.id };',
-        '  }),',
-        '  create: publicProcedure',
-        '    .input(z.object({ /* TODO: add fields */ }))',
-        '    .mutation(async () => {',
-        '      // TODO: implement',
-        "      return { id: 'new-id' };",
-        '    }),',
+        procedures,
         '});',
         '',
     ].join('\n');
@@ -142,12 +149,7 @@ function buildSampleData(ep) {
     if (ep.responseSchema && Object.keys(ep.responseSchema).length > 0) {
         return ep.responseSchema;
     }
-    return {
-        id: 'sample-id-001',
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        data: {},
-    };
+    return {};
 }
 /**
  * Generate an MSW (Mock Service Worker) handler file from mock definitions.

package/dist/engine/test-scaffold-generator/unit-scaffold.js

@@ -37,26 +37,26 @@ function buildBaseUnitContent(title, criteria, framework) {
 }
 function buildJsUnit(title, criteria, framework) {
     const importLine = framework === 'vitest'
-        ? "import { describe, it, expect } from 'vitest';"
-        : "import { describe, it, expect } from '@jest/globals';";
+        ? "import { describe, it } from 'vitest';"
+        : "import { describe, it } from '@jest/globals';";
     const tests = criteria
-        .map((c) => `  it('${c}', () => {\n    // TODO: implement\n    expect(true).toBe(true);\n  });`)
+        .map((c) => `  it.skip('${c}', () => {\n    throw new Error('Bind this criterion to implementation evidence before enabling.');\n  });`)
         .join('\n\n');
     return `${importLine}\n\ndescribe('${title}', () => {\n${tests}\n});\n`;
 }
 function buildPytestUnit(title, criteria) {
     const cls = toPascal(title);
     const methods = criteria
-        .map((c) => `    def test_${toSnake(c)}(self):\n        """${c}"""\n        # TODO: implement\n        assert True`)
+        .map((c) => `    @pytest.mark.skip(reason="Bind this criterion to implementation evidence before enabling.")\n    def test_${toSnake(c)}(self):\n        """${c}"""\n        raise AssertionError("Bind this criterion to implementation evidence before enabling.")`)
         .join('\n\n');
     return `import pytest\n\n\nclass Test${cls}:\n    """Unit tests for ${title}."""\n\n${methods}\n`;
 }
 function buildJunitUnit(title, criteria) {
     const cls = toPascal(title);
     const methods = criteria
-        .map((c) => `    @Test\n    void ${toSnake(c).replace(/_([a-z])/g, (_, l) => l.toUpperCase())}() {\n        // TODO: implement — ${c}\n        assertTrue(true);\n    }`)
+        .map((c) => `    @Test\n    @Disabled("Bind this criterion to implementation evidence before enabling.")\n    void ${toSnake(c).replace(/_([a-z])/g, (_, l) => l.toUpperCase())}() {\n        fail("Bind this criterion to implementation evidence before enabling: ${c}");\n    }`)
         .join('\n\n');
-    return `import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass ${cls}Test {\n\n${methods}\n}\n`;
+    return `import org.junit.jupiter.api.Disabled;\nimport org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass ${cls}Test {\n\n${methods}\n}\n`;
 }
 // === Integration test scaffold ===
 /**
@@ -77,11 +77,11 @@ export function generateIntegrationTestScaffold(specTitle, framework) {
 function buildIntegrationContent(title, framework) {
     if (framework === 'pytest') {
         const cls = toPascal(title);
-        return `import pytest\n\n\nclass Test${cls}Integration:\n    """Integration tests for ${title}."""\n\n    def test_api_endpoint(self):\n        """Test API endpoint integration."""\n        # TODO: implement\n        assert True\n\n    def test_database_round_trip(self):\n        """Test database persistence."""\n        # TODO: implement\n        assert True\n`;
+        return `import pytest\n\n\nclass Test${cls}Integration:\n    """Integration tests for ${title}."""\n\n    @pytest.mark.skip(reason="Bind integration boundaries before enabling.")\n    def test_declared_integration_boundary(self):\n        raise AssertionError("Bind integration boundaries before enabling.")\n`;
     }
     const importLine = framework === 'vitest'
-        ? "import { describe, it, expect } from 'vitest';"
-        : "import { describe, it, expect } from '@jest/globals';";
-    return `${importLine}\n\ndescribe('${title} — Integration', () => {\n  it('should handle API endpoint correctly', async () => {\n    // TODO: implement\n    expect(true).toBe(true);\n  });\n\n  it('should persist data to storage', async () => {\n    // TODO: implement\n    expect(true).toBe(true);\n  });\n});\n`;
+        ? "import { describe, it } from 'vitest';"
+        : "import { describe, it } from '@jest/globals';";
+    return `${importLine}\n\ndescribe('${title} — Integration', () => {\n  it.skip('declared integration boundary is verified', async () => {\n    throw new Error('Bind integration boundaries before enabling.');\n  });\n});\n`;
 }
 //# sourceMappingURL=unit-scaffold.js.map

package/dist/engine/test-spec-generator/criterion-parser.js

@@ -1,29 +1,10 @@
 // engine/test-spec-generator/criterion-parser.ts — Extract Given/When/Then from criteria text
 export function suggestTestData(criterion) {
-    const lower = criterion.toLowerCase();
-    if (lower.includes('api') || lower.includes('endpoint') || lower.includes('url')) {
-        return 'endpoint: "https://api.example.com/v1/resource", method: "POST"';
-    }
-    if (lower.includes('user') || lower.includes('usuario') || lower.includes('usuário')) {
-        return 'user: { id: "usr-123", email: "test@example.com", role: "admin" }';
-    }
-    if (lower.includes('email')) {
-        return 'email: "user@example.com", subject: "Test subject", body: "Test body"';
-    }
-    if (lower.includes('file') || lower.includes('arquivo') || lower.includes('fichero')) {
-        return 'file: { path: "/tmp/test.json", size: 1024, mimeType: "application/json" }';
-    }
-    if (lower.includes('database') || lower.includes('db') || lower.includes('banco')) {
-        return 'db: { host: "localhost", port: 5432, name: "test_db" }';
-    }
-    if (lower.includes('token') || lower.includes('auth') || lower.includes('jwt')) {
-        return 'token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test.signature"';
-    }
-    if (lower.includes('config')) {
-        return 'config: { enabled: true, timeout: 5000, retries: 3 }';
-    }
-    if (lower.includes('spec') || lower.includes('criteria')) {
-        return 'specId: "SPEC-001", title: "Test feature", criteria: ["criterion 1", "criterion 2"]';
+    const quotedValues = Array.from(criterion.matchAll(/["'`]([^"'`]+)["'`]/g))
+        .map((match) => match[1]?.trim())
+        .filter((value) => Boolean(value));
+    if (quotedValues.length > 0) {
+        return `explicitValues: ${JSON.stringify(quotedValues)}`;
     }
     return undefined;
 }

package/dist/storage/base-store.d.ts

@@ -50,5 +50,4 @@ export declare function projectDataDir(projectId: string): string;
  * and CI environments where HOME is not writable).
  */
 export declare function globalDataDir(): string;
-export { createCrudStore } from './crud-store-factory.js';
 //# sourceMappingURL=base-store.d.ts.map

package/dist/storage/base-store.js

@@ -116,8 +116,4 @@ export function globalDataDir() {
 function isNodeError(err) {
     return err instanceof Error && 'code' in err;
 }
-// ---------------------------------------------------------------------------
-// Generic CRUD store factory (re-exported from crud-store-factory.ts)
-// ---------------------------------------------------------------------------
-export { createCrudStore } from './crud-store-factory.js';
 //# sourceMappingURL=base-store.js.map