@planu/cli 5.7.5 → 5.7.7

package/dist/engine/spec-format/bdd-parser.js

@@ -1,4 +1,20 @@
 // engine/spec-format/bdd-parser.ts — BDD/Gherkin parser and emitter (SPEC-481)
+import { consumePathRunPreservingCase } from './technical-md-populator.js';
+const TEST_MARKER_RE = /\bTESTS?\s*:/gi;
+export function extractInlineTestPaths(text) {
+    const paths = [];
+    const seen = new Set();
+    for (const marker of text.matchAll(TEST_MARKER_RE)) {
+        const start = marker.index + marker[0].length;
+        for (const path of consumePathRunPreservingCase(text.slice(start))) {
+            if (!seen.has(path)) {
+                seen.add(path);
+                paths.push(path);
+            }
+        }
+    }
+    return paths;
+}
 const KEYWORD_MAP = {
     given: 'given',
     when: 'when',
@@ -17,22 +33,37 @@ const KEYWORD_MAP = {
  *     And ...
  *     But ...
  */
+const THEN_WORD_RE = /\bTHEN\b/i;
+const WHEN_WORD_RE = /\bWHEN\b/i;
+function hasThenSignal(scenario) {
+    return scenario.steps.some((step) => step.keyword === 'then' || THEN_WORD_RE.test(step.text));
+}
+function isSingleLineGivenWhenThenText(text) {
+    return WHEN_WORD_RE.test(text) && THEN_WORD_RE.test(text);
+}
+function opensHeaderlessScenario(rawKeyword, text) {
+    return rawKeyword === 'given' || isSingleLineGivenWhenThenText(text);
+}
 export function parseBddScenarios(markdown) {
     const scenarios = [];
     const lines = markdown.split('\n');
     let current = null;
     // Tracks whether the current scenario was auto-created (no Scenario: header)
     let currentIsHeaderless = false;
+    const closeCurrent = () => {
+        if (current && hasThenSignal(current)) {
+            scenarios.push(current);
+        }
+        current = null;
+        currentIsHeaderless = false;
+    };
     for (const raw of lines) {
         const line = raw.trim();
         // Detect scenario header
         const scenarioMatch = /^scenario:\s*(.+)$/i.exec(line);
         if (scenarioMatch) {
-            if (current) {
-                scenarios.push(current);
-            }
+            closeCurrent();
             current = { title: (scenarioMatch[1] ?? '').trim(), steps: [], done: false };
-            currentIsHeaderless = false;
             continue;
         }
         // Detect step keywords
@@ -47,12 +78,12 @@ export function parseBddScenarios(markdown) {
         // steps. This handles both multiple headerless blocks and headerless blocks following
         // an explicit Scenario: header block.
         if (rawKeyword === 'given' && current !== null && current.steps.length > 0) {
-            scenarios.push(current);
-            current = null;
-            currentIsHeaderless = false;
+            closeCurrent();
         }
-        // Auto-create a scenario when a step is found without a preceding Scenario header
         if (!current) {
+            if (!opensHeaderlessScenario(rawKeyword, text)) {
+                continue;
+            }
             current = { title: text, steps: [], done: false };
             currentIsHeaderless = true;
         }
@@ -62,9 +93,7 @@ export function parseBddScenarios(markdown) {
             current.title = text;
         }
     }
-    if (current) {
-        scenarios.push(current);
-    }
+    closeCurrent();
     return scenarios;
 }
 /**

package/dist/engine/spec-format/lean-spec-generator.js

@@ -1,6 +1,6 @@
 // engine/spec-format/lean-spec-generator.ts — Generates lean spec.md with YAML frontmatter (SPEC-461)
 // Output: ~30-50 lines. No generic sections, no OWASP, no STRIDE, no resilience criteria.
-import { parseBddScenarios, renderBddScenariosYaml, convertCheckboxToBdd } from './bdd-parser.js';
+import { parseBddScenarios, renderBddScenariosYaml, convertCheckboxToBdd, extractInlineTestPaths, } from './bdd-parser.js';
 import { decideMetadataSerialization, } from './metadata-value-policy.js';
 import { renderGroundingFrontmatter, renderTechnicalReferenceGroundingFrontmatter, } from '../spec-grounding/contract.js';
 /** Strip a redundant spec-ID prefix from spec titles.
@@ -117,15 +117,21 @@ function buildBddLines(description, extraCriteria, criteriaOverride, scenarioTes
                 done: false,
             });
         }
+        appendUncoveredCheckboxCriteria(scenarios, description);
     }
-    if (scenarioTestPaths.length > 0) {
-        scenarios = scenarios.map((scenario) => ({
-            ...scenario,
-            tests: scenario.tests && scenario.tests.length > 0
-                ? scenario.tests
-                : scenarioTestPaths.map((path) => ({ path })),
-        }));
-    }
+    scenarios = scenarios.map((scenario) => {
+        const inlinePaths = extractInlineTestPaths([scenario.title, ...scenario.steps.map((step) => step.text)].join('\n'));
+        if (inlinePaths.length > 0) {
+            return { ...scenario, tests: inlinePaths.map((path) => ({ path })) };
+        }
+        if (scenario.tests && scenario.tests.length > 0) {
+            return scenario;
+        }
+        if (scenarioTestPaths.length > 0) {
+            return { ...scenario, tests: scenarioTestPaths.map((path) => ({ path })) };
+        }
+        return scenario;
+    });
     return renderBddScenariosYaml(scenarios);
 }
 /** Extract acceptance criteria explicitly present in the description.
@@ -148,7 +154,7 @@ export function extractCriteria(description) {
 /** Extract checkbox-style criteria: `- [ ] text` or `- [x] text`. */
 function extractCheckboxCriteria(description) {
     const criteria = [];
-    const checkboxRegex = /^[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+    const checkboxRegex = /^[-*+]\s*\[([ xX])\]\s*(.+)$/gm;
     let match = checkboxRegex.exec(description);
     while (match) {
         criteria.push({
@@ -166,7 +172,7 @@ function extractCheckboxCriteria(description) {
 function extractGivenWhenThenCriteria(description) {
     const criteria = [];
     // Single-line: GIVEN ... WHEN ... THEN ...
-    const singleLineRegex = /^[ \t]*(?:[-*>]\s*|\d+[.)]\s*)?GIVEN\s+.+\s+WHEN\s+.+\s+THEN\s+(.+)$/gim;
+    const singleLineRegex = /^[ \t]*(?:[-*+>]\s*|\d+[.)]\s*)?GIVEN\s+.+\s+WHEN\s+.+\s+THEN\s+(.+)$/gim;
     let match = singleLineRegex.exec(description);
     while (match) {
         const thenText = match[1]?.trim() ?? '';
@@ -199,7 +205,7 @@ function extractPlainListCriteria(description) {
     }
     const criteria = [];
     // Plain list: `- text` or `* text`, not followed by `[`
-    const plainListRegex = /^[-*]\s+(?!\[)(.+)$/gm;
+    const plainListRegex = /^[-*+]\s+(?!\[)(.+)$/gm;
     let match = plainListRegex.exec(acceptanceSection);
     while (match) {
         const text = match[1]?.trim() ?? '';
@@ -214,4 +220,18 @@ function extractPlainListCriteria(description) {
 function escapeYaml(value) {
     return value.replace(/"/g, '\\"');
 }
+function normalizeForDedupe(value) {
+    return value.trim().toLowerCase();
+}
+function appendUncoveredCheckboxCriteria(scenarios, description) {
+    const existingTexts = new Set(scenarios.flatMap((scenario) => [
+        normalizeForDedupe(scenario.title),
+        ...scenario.steps.map((step) => normalizeForDedupe(step.text)),
+    ]));
+    for (const criterion of extractCheckboxCriteria(description)) {
+        if (!existingTexts.has(normalizeForDedupe(criterion.text))) {
+            scenarios.push(...convertCheckboxToBdd([criterion]));
+        }
+    }
+}
 //# sourceMappingURL=lean-spec-generator.js.map

package/dist/engine/spec-format/retired-scaffold.d.ts

@@ -0,0 +1,3 @@
+export declare const RETIRED_SCAFFOLD_PREFIX = "GIVEN the requested change is implemented WHEN the behavior is exercised";
+export declare function isRetiredScaffoldText(text: string): boolean;
+//# sourceMappingURL=retired-scaffold.d.ts.map

package/dist/engine/spec-format/retired-scaffold.js

@@ -0,0 +1,5 @@
+export const RETIRED_SCAFFOLD_PREFIX = 'GIVEN the requested change is implemented WHEN the behavior is exercised';
+export function isRetiredScaffoldText(text) {
+    return text.toLowerCase().includes(RETIRED_SCAFFOLD_PREFIX.toLowerCase());
+}
+//# sourceMappingURL=retired-scaffold.js.map

package/dist/engine/spec-format/technical-md-populator.d.ts

@@ -1,4 +1,5 @@
 import type { LeanFileEntry } from '../../types/index.js';
+export declare function consumePathRunPreservingCase(remainder: string): string[];
 /**
  * Extract the path list declared immediately after each FILES:/FILE:/TEST:/TESTS: marker.
  * Returns null when no such marker is present (caller falls back to whole-text grounding).

package/dist/engine/spec-format/technical-md-populator.js

@@ -137,6 +137,33 @@ function consumePathRun(remainder) {
     }
     return paths;
 }
+export function consumePathRunPreservingCase(remainder) {
+    const paths = [];
+    const seen = new Set();
+    let cursor = remainder;
+    for (;;) {
+        cursor = cursor.replace(PATH_SEPARATOR_RE, '');
+        const tokenMatch = PATH_TOKEN_RE.exec(cursor);
+        if (tokenMatch?.[1] === undefined) {
+            break;
+        }
+        const raw = tokenMatch[1];
+        const endsWithTerminator = /[.;:]+$/.test(raw);
+        const trimmed = raw.replace(TRAILING_PUNCTUATION_RE, '');
+        if (!isPathShaped(trimmed)) {
+            break;
+        }
+        if (!seen.has(trimmed)) {
+            seen.add(trimmed);
+            paths.push(trimmed);
+        }
+        if (endsWithTerminator) {
+            break;
+        }
+        cursor = cursor.slice(tokenMatch[0].length);
+    }
+    return paths;
+}
 /**
  * Extract the path list declared immediately after each FILES:/FILE:/TEST:/TESTS: marker.
  * Returns null when no such marker is present (caller falls back to whole-text grounding).

package/dist/engine/spec-format/unified-spec-builder.d.ts

@@ -21,4 +21,5 @@ export declare function containsUnresolvedContractPlaceholder(rawText: string, o
 export declare function validateUnifiedSpecCandidate(candidate: string, options?: {
     groundedFilePaths?: Iterable<string>;
 }): UnifiedSpecCandidateValidation;
+export declare function maskFencedAndQuotedText(body: string): string;
 //# sourceMappingURL=unified-spec-builder.d.ts.map

package/dist/engine/spec-format/unified-spec-builder.js

@@ -3,6 +3,7 @@
 // two-file spec.md + technical.md pair only to be merged on the next list_specs run.
 import { stripFrontmatter } from '../frontmatter-parser.js';
 import { extractAcceptanceCriteriaTexts } from './acceptance-criteria.js';
+import { isRetiredScaffoldText } from './retired-scaffold.js';
 import { escapeRegex } from '../../core/shared/strings.js';
 const REQUIRED_SECTIONS = [
     'Problem',
@@ -24,7 +25,7 @@ export function buildCanonicalUnifiedSpecContent(input) {
     const goal = firstNonEmpty(explicitGoal, input.criteria[0]?.text, 'Needs decision: define the goal this spec must achieve.');
     const explicitTechnical = extractTopLevelSectionBody(source, 'Technical');
     const generatedNotes = extractTopLevelSectionBody(input.technicalBody, 'Implementation Notes');
-    const technical = firstNonEmpty(explicitTechnical, generatedNotes, 'Implement only the grounded ownership and observable behavior declared by this contract.');
+    const technical = firstNonEmpty(explicitTechnical, generatedNotes, groundedTechnicalFallback(input.files, input.criteria));
     const acceptance = extractExecutableCriteria(source, input.criteria);
     const explicitOutOfScope = extractTopLevelSectionBody(source, 'Out of scope');
     const outOfScope = input.outOfScope.length > 0
@@ -224,8 +225,12 @@ export function validateUnifiedSpecCandidate(candidate, options = {}) {
         });
     }
     const acceptanceSection = extractTopLevelSectionBody(scannable, 'Acceptance Criteria');
-    if (acceptanceSection === null ||
-        !/\bGIVEN\b[\s\S]*\bWHEN\b[\s\S]*\bTHEN\b/i.test(acceptanceSection)) {
+    const acceptanceSectionForBddCheck = acceptanceSection
+        ?.split('\n')
+        .filter((line) => !isRetiredScaffoldText(line))
+        .join('\n');
+    if (!acceptanceSectionForBddCheck ||
+        !/\bGIVEN\b[\s\S]*\bWHEN\b[\s\S]*\bTHEN\b/i.test(acceptanceSectionForBddCheck)) {
         issues.push({
             code: 'MISSING_EXECUTABLE_CRITERIA',
             section: 'Acceptance Criteria',
@@ -248,7 +253,7 @@ export function validateUnifiedSpecCandidate(candidate, options = {}) {
     }
     return { valid: issues.length === 0, issues };
 }
-function maskFencedAndQuotedText(body) {
+export function maskFencedAndQuotedText(body) {
     const lines = body.split('\n');
     let fence = null;
     return lines
@@ -305,27 +310,18 @@ function firstNonEmpty(...values) {
     return (values.find((value) => value !== undefined && value !== null && value.length > 0) ?? '');
 }
 function fallbackCriteriaBullets(criteria) {
-    return criteria
-        .map((criterion) => `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${criterion.text}`)
-        .join('\n');
+    return criteria.map((criterion) => `- ${criterion.text}`).join('\n');
 }
-// Same BDD step vocabulary `acceptance-criteria.ts` recognizes (English + Spanish).
-// A criterion already starting with one of these is a genuine BDD fragment
-// (a full GIVEN/WHEN/THEN block, or an AND continuation of one) — leave it as-is.
-const BDD_STEP_START = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
 /**
- * Render one real criterion as an executable bullet. Criteria already
- * written in BDD form pass through untouched; plain-text criteria (e.g.
- * checkbox items) are wrapped in the same GIVEN/WHEN/THEN scaffold
- * `fallbackCriteriaBullets` uses, so every bullet stays BDD-executable
- * without ever discarding a real criterion.
+ * Render one real criterion as a bullet. Criteria already written in BDD form
+ * pass through untouched; plain-text criteria (e.g. checkbox items) render as
+ * plain bullets — SPEC-1435 retires the constant GIVEN/WHEN/THEN scaffold that
+ * used to wrap them, since it satisfied `MISSING_EXECUTABLE_CRITERIA` without
+ * adding any spec-specific content.
  */
 function toExecutableBullet(text) {
     const cleaned = text.trim().replace(/[.\s]+$/, '.');
-    if (BDD_STEP_START.test(cleaned)) {
-        return `- ${cleaned}`;
-    }
-    return `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${cleaned}`;
+    return `- ${cleaned}`;
 }
 /**
  * Criteria resolve through the canonical parser in `acceptance-criteria.ts`
@@ -339,6 +335,20 @@ function extractExecutableCriteria(source, criteria) {
     }
     return parsed.map(toExecutableBullet).join('\n');
 }
+/**
+ * SPEC-1435: replaces the constant Technical fallback sentence. When neither an
+ * author-written `## Technical` body nor generated implementation notes exist, compose
+ * the section from the spec's own grounded material instead of a fixed sentence that
+ * never varies with the spec: the grounded file records when present, otherwise the
+ * criteria texts.
+ */
+function groundedTechnicalFallback(files, criteria) {
+    const groundedFiles = [...files.create, ...files.modify, ...files.test];
+    if (groundedFiles.length > 0) {
+        return groundedFiles.map((entry) => `- \`${entry.path}\``).join('\n');
+    }
+    return criteria.map((criterion) => `- ${criterion.text}`).join('\n');
+}
 function renderOwnedFiles(files) {
     const sections = [];
     for (const [title, entries] of [

package/dist/engine/spec-grounding/contract.d.ts

@@ -1,5 +1,5 @@
 import type { Spec } from '../../types/index.js';
-import type { CriterionGroundingRecord, GroundingGateResult, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
+import type { CriterionGroundingRecord, GroundingGateResult, GroundingParseResult, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
 export { normalizeCriterionText } from '../criterion-identity.js';
 export declare function isGenericCriterion(text: string): boolean;
 export declare function filterGroundedCriteria(criteria: string[]): string[];
@@ -19,8 +19,8 @@ export declare function getAdvisoryCriteria(records: CriterionGroundingRecord[])
 export declare function renderGroundingFrontmatter(records: CriterionGroundingRecord[]): string[];
 export declare function renderTechnicalReferenceGroundingFrontmatter(records: TechnicalReferenceGroundingRecord[]): string[];
 export declare function checkGroundedSpecContract(spec: Spec, content: string): GroundingGateResult;
-export declare function parseCriterionGroundingRecords(frontmatter: string): CriterionGroundingRecord[];
-export declare function parseTechnicalReferenceGroundingRecords(frontmatter: string): TechnicalReferenceGroundingRecord[];
+export declare function parseCriterionGroundingRecords(frontmatter: string): GroundingParseResult<CriterionGroundingRecord>;
+export declare function parseTechnicalReferenceGroundingRecords(frontmatter: string): GroundingParseResult<TechnicalReferenceGroundingRecord>;
 export declare function parseApprovedFileLevelWorkPlanPaths(content: string): string[];
 export declare function parseGroundedTechnicalPaths(content: string): string[];
 //# sourceMappingURL=contract.d.ts.map

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

@@ -1,4 +1,6 @@
+import YAML from 'yaml';
 import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
+import { isRecord, toCriterionGroundingRecord, toTechnicalReferenceGroundingRecord, } from './grounding-entry-parser.js';
 export { normalizeCriterionText } from '../criterion-identity.js';
 const GENERIC_CRITERION_PATTERNS = [
     /\bimplementation complete\b/i,
@@ -102,7 +104,7 @@ export function renderTechnicalReferenceGroundingFrontmatter(records) {
 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);
+    const records = parseCriterionGroundingRecords(frontmatter).records;
     if (!required) {
         return { passed: true, required: false, issues: [], records };
     }
@@ -118,7 +120,7 @@ export function checkGroundedSpecContract(spec, content) {
             issues.push(`Criterion has no grounding evidence: ${record.text}`);
         }
     }
-    const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter);
+    const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter).records;
     for (const record of technicalRecords) {
         if (record.source === 'ungrounded_advisory' || record.source === 'documented_assumption') {
             issues.push(`Technical reference is advisory-only and cannot be contract: ${record.path}`);
@@ -135,6 +137,65 @@ export function checkGroundedSpecContract(spec, content) {
     };
 }
 export function parseCriterionGroundingRecords(frontmatter) {
+    const outcome = parseFrontmatterYaml(frontmatter);
+    if (!outcome.parsed) {
+        return { records: parseCriterionGroundingRecordsLegacy(frontmatter), diagnostics: [] };
+    }
+    const grounding = readGroundingSection(outcome.document);
+    const entries = Array.isArray(grounding?.criteria) ? grounding.criteria : [];
+    const records = [];
+    const diagnostics = [];
+    for (const [index, entry] of entries.entries()) {
+        const entryOutcome = toCriterionGroundingRecord(entry, index);
+        if (entryOutcome.record) {
+            records.push(entryOutcome.record);
+        }
+        diagnostics.push(...entryOutcome.diagnostics);
+    }
+    return { records, diagnostics };
+}
+export function parseTechnicalReferenceGroundingRecords(frontmatter) {
+    const outcome = parseFrontmatterYaml(frontmatter);
+    if (!outcome.parsed) {
+        return {
+            records: parseTechnicalReferenceGroundingRecordsLegacy(frontmatter),
+            diagnostics: [],
+        };
+    }
+    const grounding = readGroundingSection(outcome.document);
+    const entries = grounding
+        ? Array.isArray(grounding.technicalReferences)
+            ? grounding.technicalReferences
+            : []
+        : Array.isArray(outcome.document?.technicalReferences)
+            ? outcome.document.technicalReferences
+            : [];
+    const records = [];
+    const diagnostics = [];
+    for (const [index, entry] of entries.entries()) {
+        const entryOutcome = toTechnicalReferenceGroundingRecord(entry, index);
+        if (entryOutcome.record) {
+            records.push(entryOutcome.record);
+        }
+        diagnostics.push(...entryOutcome.diagnostics);
+    }
+    return { records, diagnostics };
+}
+function parseFrontmatterYaml(frontmatter) {
+    let value;
+    try {
+        value = YAML.parse(frontmatter);
+    }
+    catch {
+        return { parsed: false };
+    }
+    return { parsed: true, document: isRecord(value) ? value : undefined };
+}
+function readGroundingSection(document) {
+    const grounding = document?.grounding;
+    return isRecord(grounding) ? grounding : undefined;
+}
+function parseCriterionGroundingRecordsLegacy(frontmatter) {
     const records = [];
     const chunks = frontmatter.split(/\n\s{4}- text:\s*/).slice(1);
     for (const chunk of chunks) {
@@ -154,7 +215,7 @@ export function parseCriterionGroundingRecords(frontmatter) {
     }
     return records;
 }
-export function parseTechnicalReferenceGroundingRecords(frontmatter) {
+function parseTechnicalReferenceGroundingRecordsLegacy(frontmatter) {
     const records = [];
     const chunks = frontmatter.split(/\n\s{4}- path:\s*/).slice(1);
     for (const chunk of chunks) {
@@ -197,7 +258,7 @@ export function parseGroundedTechnicalPaths(content) {
     const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
     return [
         ...new Set([
-            ...parseTechnicalReferenceGroundingRecords(frontmatter).map((record) => record.path),
+            ...parseTechnicalReferenceGroundingRecords(frontmatter).records.map((record) => record.path),
             ...parseApprovedFileLevelWorkPlanPaths(content),
         ]),
     ];

package/dist/engine/spec-grounding/grounding-entry-parser.d.ts

@@ -0,0 +1,5 @@
+import type { CriterionGroundingRecord, GroundingEntryOutcome, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function toCriterionGroundingRecord(entry: unknown, index: number): GroundingEntryOutcome<CriterionGroundingRecord>;
+export declare function toTechnicalReferenceGroundingRecord(entry: unknown, index: number): GroundingEntryOutcome<TechnicalReferenceGroundingRecord>;
+//# sourceMappingURL=grounding-entry-parser.d.ts.map

package/dist/engine/spec-grounding/grounding-entry-parser.js

@@ -0,0 +1,185 @@
+const GROUNDING_SOURCES = [
+    'user_input',
+    'project_evidence',
+    'documented_assumption',
+    'ungrounded_advisory',
+];
+const GROUNDING_CONFIDENCES = ['low', 'medium', 'high'];
+const TECHNICAL_REFERENCE_SECTIONS = [
+    'create',
+    'modify',
+    'test',
+];
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringifyDiagnosticValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return value.toString();
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'unstringifiable value';
+    }
+}
+function nonObjectEntryDiagnostic(entry, index) {
+    return {
+        identifier: `entry[${String(index)}]`,
+        field: 'entry',
+        value: stringifyDiagnosticValue(entry),
+        allowed: [],
+    };
+}
+function toGroundingSource(value) {
+    return typeof value === 'string' && GROUNDING_SOURCES.includes(value)
+        ? value
+        : null;
+}
+function toGroundingConfidence(value) {
+    return typeof value === 'string' && GROUNDING_CONFIDENCES.includes(value)
+        ? value
+        : null;
+}
+function toTechnicalReferenceSection(value) {
+    return typeof value === 'string' &&
+        TECHNICAL_REFERENCE_SECTIONS.includes(value)
+        ? value
+        : null;
+}
+function toStringArrayWithDiagnostics(value, identifier) {
+    if (!Array.isArray(value)) {
+        return { evidence: [], diagnostics: [] };
+    }
+    const evidence = [];
+    const diagnostics = [];
+    for (const item of value) {
+        if (typeof item === 'string') {
+            evidence.push(item);
+        }
+        else {
+            diagnostics.push({
+                identifier,
+                field: 'evidence',
+                value: stringifyDiagnosticValue(item),
+                allowed: ['string'],
+            });
+        }
+    }
+    return { evidence, diagnostics };
+}
+export function toCriterionGroundingRecord(entry, index) {
+    if (!isRecord(entry)) {
+        return { record: null, diagnostics: [nonObjectEntryDiagnostic(entry, index)] };
+    }
+    const text = typeof entry.text === 'string' && entry.text.length > 0 ? entry.text : null;
+    const identifier = text ?? `entry[${String(index)}]`;
+    const source = toGroundingSource(entry.source);
+    if (!source) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'source',
+                    value: stringifyDiagnosticValue(entry.source),
+                    allowed: GROUNDING_SOURCES,
+                },
+            ],
+        };
+    }
+    const confidence = toGroundingConfidence(entry.confidence);
+    if (!confidence) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'confidence',
+                    value: stringifyDiagnosticValue(entry.confidence),
+                    allowed: GROUNDING_CONFIDENCES,
+                },
+            ],
+        };
+    }
+    if (!text) {
+        return {
+            record: null,
+            diagnostics: [
+                { identifier, field: 'text', value: stringifyDiagnosticValue(entry.text), allowed: [] },
+            ],
+        };
+    }
+    const { evidence, diagnostics } = toStringArrayWithDiagnostics(entry.evidence, identifier);
+    return { record: { text, source, evidence, confidence }, diagnostics };
+}
+export function toTechnicalReferenceGroundingRecord(entry, index) {
+    if (!isRecord(entry)) {
+        return { record: null, diagnostics: [nonObjectEntryDiagnostic(entry, index)] };
+    }
+    const path = typeof entry.path === 'string' && entry.path.length > 0 ? entry.path : null;
+    const identifier = path ?? `entry[${String(index)}]`;
+    const section = toTechnicalReferenceSection(entry.section);
+    if (!section) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'section',
+                    value: stringifyDiagnosticValue(entry.section),
+                    allowed: TECHNICAL_REFERENCE_SECTIONS,
+                },
+            ],
+        };
+    }
+    const source = toGroundingSource(entry.source);
+    if (!source) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'source',
+                    value: stringifyDiagnosticValue(entry.source),
+                    allowed: GROUNDING_SOURCES,
+                },
+            ],
+        };
+    }
+    const confidence = toGroundingConfidence(entry.confidence);
+    if (!confidence) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'confidence',
+                    value: stringifyDiagnosticValue(entry.confidence),
+                    allowed: GROUNDING_CONFIDENCES,
+                },
+            ],
+        };
+    }
+    if (!path) {
+        return {
+            record: null,
+            diagnostics: [
+                { identifier, field: 'path', value: stringifyDiagnosticValue(entry.path), allowed: [] },
+            ],
+        };
+    }
+    const { evidence, diagnostics } = toStringArrayWithDiagnostics(entry.evidence, identifier);
+    return { record: { path, section, source, evidence, confidence }, diagnostics };
+}
+//# sourceMappingURL=grounding-entry-parser.js.map