@planu/cli 5.7.5 → 5.7.6

package/dist/engine/session/session-tracker.js

@@ -1,15 +1,12 @@
-// engine/session/session-tracker.ts — In-memory call counter and file modification tracker
-// for auto session checkpointing (SPEC-563).
 const DEFAULT_THRESHOLD = 10;
 const MAX_LAST_CALLS = 10;
 const MAX_ERRORS = 20;
-class SessionTracker {
+let sharedPolicy = { threshold: DEFAULT_THRESHOLD, enabled: true };
+export class SessionTracker {
     callCount = 0;
     lastCalls = [];
     modifiedFiles = new Set();
     errors = [];
-    policy = { threshold: DEFAULT_THRESHOLD, enabled: true };
-    /** Record a tool call. Appends to lastCalls (capped at MAX_LAST_CALLS). */
     recordCall(tool, success) {
         this.callCount++;
         this.lastCalls.push({ tool, success, timestamp: new Date().toISOString() });
@@ -17,25 +14,18 @@ class SessionTracker {
             this.lastCalls.shift();
         }
     }
-    /** Record a file path as modified during this session. */
     recordFile(path) {
         this.modifiedFiles.add(path);
     }
-    /** Record an error message (capped at MAX_ERRORS). */
     recordError(msg) {
         if (this.errors.length >= MAX_ERRORS) {
             this.errors.shift();
         }
         this.errors.push(msg);
     }
-    /**
-     * Returns true when a checkpoint should be written:
-     * policy is enabled, callCount > 0, and callCount is a multiple of threshold.
-     */
     shouldCheckpoint() {
-        return (this.policy.enabled && this.callCount > 0 && this.callCount % this.policy.threshold === 0);
+        return (sharedPolicy.enabled && this.callCount > 0 && this.callCount % sharedPolicy.threshold === 0);
     }
-    /** Return a compact snapshot of the current session state. */
     getSnapshot() {
         return {
             callCount: this.callCount,
@@ -44,28 +34,41 @@ class SessionTracker {
             errors: [...this.errors],
         };
     }
-    /** Update the checkpoint policy (partial update — unspecified fields keep current values). */
     setPolicy(p) {
-        if (p.threshold !== undefined) {
-            this.policy = { ...this.policy, threshold: Math.max(1, Math.round(p.threshold)) };
-        }
-        if (p.enabled !== undefined) {
-            this.policy = { ...this.policy, enabled: p.enabled };
-        }
+        setCheckpointPolicy(p);
     }
-    /** Return the current checkpoint policy. */
     getPolicy() {
-        return { ...this.policy };
+        return getCheckpointPolicy();
     }
-    /** Reset the tracker state (useful for testing). */
     reset() {
         this.callCount = 0;
         this.lastCalls.splice(0);
         this.modifiedFiles.clear();
         this.errors.splice(0);
-        this.policy = { threshold: DEFAULT_THRESHOLD, enabled: true };
     }
 }
-/** Singleton session tracker — one per process. */
-export const sessionTracker = new SessionTracker();
+const trackers = new Map();
+export function getSessionTracker(projectPath) {
+    let tracker = trackers.get(projectPath);
+    if (!tracker) {
+        tracker = new SessionTracker();
+        trackers.set(projectPath, tracker);
+    }
+    return tracker;
+}
+export function setCheckpointPolicy(p) {
+    if (p.threshold !== undefined) {
+        sharedPolicy = { ...sharedPolicy, threshold: Math.max(1, Math.round(p.threshold)) };
+    }
+    if (p.enabled !== undefined) {
+        sharedPolicy = { ...sharedPolicy, enabled: p.enabled };
+    }
+}
+export function getCheckpointPolicy() {
+    return { ...sharedPolicy };
+}
+export function resetSessionTrackers() {
+    trackers.clear();
+    sharedPolicy = { threshold: DEFAULT_THRESHOLD, enabled: true };
+}
 //# sourceMappingURL=session-tracker.js.map

package/dist/engine/session-state/writer.js

@@ -2,8 +2,8 @@
 // engine/session-state/writer.ts — SPEC-633: Write session.json universal state file
 import { readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { execSync } from 'node:child_process';
 import { stableJsonStringify, stableWriteGeneratedFile, stripRootUpdatedAt, } from '../generated-artifact-writer.js';
+import { execGitCapture } from '../git/exec-git.js';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1699
 import { projectRuntimeDir } from '../../storage/storage-layout.js';
 const ROOT_SESSION = 'session.json';
@@ -18,11 +18,7 @@ export function rootFile(projectPath) {
 }
 function getModifiedFiles(projectPath) {
     try {
-        const out = execSync('git diff --name-only HEAD 2>/dev/null', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const out = execGitCapture('git diff --name-only HEAD 2>/dev/null', projectPath);
         return out.trim().split('\n').filter(Boolean).slice(0, 10);
     }
     catch {
@@ -31,11 +27,7 @@ function getModifiedFiles(projectPath) {
 }
 function getBranch(projectPath) {
     try {
-        const out = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const out = execGitCapture('git rev-parse --abbrev-ref HEAD 2>/dev/null', projectPath);
         return out.trim() || null;
     }
     catch {

package/dist/engine/skill-generator/workflow-skill-generator.d.ts

@@ -3,8 +3,10 @@ import type { WorkflowSkillGenerationOptions, WorkflowSkillGenerationResult } fr
 export type { WorkflowSkillGenerationOptions, WorkflowSkillGenerationResult, } from '../../types/skill-registry.js';
 /**
  * Generate all 22 workflow skill files for the given project.
- * Respects idempotency: only rewrites if conventions changed.
- * Writes registry entries via writeSkillRegistryEntry (SPEC-680).
+ * Refreshes a pristine copy when Planu's shipped body changes; never touches
+ * a user-authored or user-edited file (SPEC-1457).
+ * Writes registry entries via writeSkillRegistryEntry (SPEC-680) only when a
+ * file is actually rewritten.
  */
 export declare function generateWorkflowSkills(projectPath: string, knowledge: ProjectKnowledge, options?: WorkflowSkillGenerationOptions): Promise<WorkflowSkillGenerationResult>;
 //# sourceMappingURL=workflow-skill-generator.d.ts.map

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

@@ -1,28 +1,35 @@
 import { technologyValue } from '../technology-registry.js';
-// src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685
+// src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685, refreshed by SPEC-1457
 // Generates all 22 workflow skill files for a project.
 // Delegates placeholder substitution to adaptSkillContent (SPEC-682 — DRY).
 // Registers each skill via writeSkillRegistryEntry (SPEC-680).
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { adaptSkillContent } from '../skill-adapter/index.js';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { writeSkillRegistryEntry } from '../../storage/skill-registry-storage.js';
 import { WORKFLOW_SKILL_DEFINITIONS } from './skill-definitions.js';
-import { hashConventions } from './conventions-hasher.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 const CLAUDE_SKILLS_REL = '.claude/skills';
-const HASH_MARKER_PREFIX = '<!-- planu-conventions-hash: ';
+const HASH_MARKER_PREFIX = '<!-- planu-skill-hash: ';
 const HASH_MARKER_SUFFIX = ' -->';
+const LEGACY_HASH_MARKER_PREFIX = '<!-- planu-conventions-hash: ';
+const MARKER_SCAN_WINDOW = 5;
+const HEX_HASH_PATTERN = /^[0-9a-f]{64}$/;
+const LEGACY_HEX_HASH_PATTERN = /^[0-9a-f]{16}$/;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-/** Build the full skill markdown with hash marker on line 2. */
+/** SHA-256 hex digest of the exact bytes of the rendered skill content. */
+function digestContent(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+/** Build the full skill markdown with the content-bound hash marker on line 2. */
 function buildSkillContent(adaptedBody, hash) {
     const marker = `${HASH_MARKER_PREFIX}${hash}${HASH_MARKER_SUFFIX}`;
-    // Insert hash marker as second line (after the first line of the body)
     const lines = adaptedBody.split('\n');
     if (lines.length < 2) {
         return adaptedBody + '\n' + marker + '\n';
@@ -30,16 +37,58 @@ function buildSkillContent(adaptedBody, hash) {
     lines.splice(1, 0, marker);
     return lines.join('\n');
 }
-/** Extract the hash from line 2 of an existing skill file. Returns null if absent or malformed. */
-function extractExistingHash(content) {
+/** Rendered content with the marker line at `lineIndex` removed, for the pristine digest check. */
+function contentWithoutMarkerLine(content, lineIndex) {
+    const lines = content.split('\n');
+    lines.splice(lineIndex, 1);
+    return lines.join('\n');
+}
+function extractMarkerValue(line, prefix) {
+    if (!line.startsWith(prefix) || !line.endsWith(HASH_MARKER_SUFFIX)) {
+        return null;
+    }
+    return line.slice(prefix.length, -HASH_MARKER_SUFFIX.length);
+}
+/**
+ * Fail-closed marker reader: any duplicate marker, mixed marker formats, or a
+ * malformed hash value is reported as 'invalid' so the caller treats the file
+ * as user-modified rather than risk overwriting an edit.
+ */
+function readMarker(content) {
     const lines = content.split('\n');
-    for (let i = 0; i < Math.min(lines.length, 5); i++) {
-        const line = lines[i] ?? '';
-        if (line.startsWith(HASH_MARKER_PREFIX) && line.endsWith(HASH_MARKER_SUFFIX)) {
-            return line.slice(HASH_MARKER_PREFIX.length, -HASH_MARKER_SUFFIX.length);
+    const window = lines.slice(0, MARKER_SCAN_WINDOW);
+    let currentHash = '';
+    let currentLineIndex = -1;
+    let currentCount = 0;
+    let legacyHash = '';
+    let legacyCount = 0;
+    for (let lineIndex = 0; lineIndex < window.length; lineIndex++) {
+        const line = window[lineIndex] ?? '';
+        const currentValue = extractMarkerValue(line, HASH_MARKER_PREFIX);
+        if (currentValue !== null) {
+            currentCount += 1;
+            currentHash = currentValue;
+            currentLineIndex = lineIndex;
+            continue;
+        }
+        const legacyValue = extractMarkerValue(line, LEGACY_HASH_MARKER_PREFIX);
+        if (legacyValue !== null) {
+            legacyCount += 1;
+            legacyHash = legacyValue;
         }
     }
-    return null;
+    if (currentCount > 1 || legacyCount > 1 || (currentCount === 1 && legacyCount === 1)) {
+        return { kind: 'invalid' };
+    }
+    if (currentCount === 1) {
+        return HEX_HASH_PATTERN.test(currentHash)
+            ? { kind: 'current', hash: currentHash, lineIndex: currentLineIndex }
+            : { kind: 'invalid' };
+    }
+    if (legacyCount === 1) {
+        return LEGACY_HEX_HASH_PATTERN.test(legacyHash) ? { kind: 'legacy' } : { kind: 'invalid' };
+    }
+    return { kind: 'absent' };
 }
 /** Apply fallback values when knowledge fields are null. */
 function applyFallbacks(knowledge) {
@@ -53,55 +102,81 @@ function applyFallbacks(knowledge) {
         language: knowledge.language || technologyValue('technology-typescript-969545'),
     };
 }
+async function decideForFile(destPath, newDigest, force) {
+    let existingContent;
+    try {
+        existingContent = await readFile(destPath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            return { action: 'write' };
+        }
+        return { action: 'skip-error', message: err instanceof Error ? err.message : String(err) };
+    }
+    const marker = readMarker(existingContent);
+    switch (marker.kind) {
+        case 'invalid':
+        case 'absent':
+            return { action: 'skip-user-modified' };
+        case 'legacy':
+            return { action: 'write' };
+        case 'current': {
+            const onDiskDigest = digestContent(contentWithoutMarkerLine(existingContent, marker.lineIndex));
+            if (onDiskDigest !== marker.hash) {
+                return { action: 'skip-user-modified' };
+            }
+            if (force || marker.hash !== newDigest) {
+                return { action: 'write' };
+            }
+            return { action: 'skip-unchanged' };
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // Main export
 // ---------------------------------------------------------------------------
 /**
  * Generate all 22 workflow skill files for the given project.
- * Respects idempotency: only rewrites if conventions changed.
- * Writes registry entries via writeSkillRegistryEntry (SPEC-680).
+ * Refreshes a pristine copy when Planu's shipped body changes; never touches
+ * a user-authored or user-edited file (SPEC-1457).
+ * Writes registry entries via writeSkillRegistryEntry (SPEC-680) only when a
+ * file is actually rewritten.
  */
 export async function generateWorkflowSkills(projectPath, knowledge, options = {}) {
     const targets = options.targets ?? ['claude'];
     const force = options.force ?? false;
     // Apply fallbacks so placeholders always resolve
     const resolvedKnowledge = applyFallbacks(knowledge);
-    // Compute current conventions hash (same for all skills in this run)
-    const currentHash = hashConventions(resolvedKnowledge);
     // Ensure output directories exist
     const claudeSkillsDir = join(projectPath, CLAUDE_SKILLS_REL);
     await mkdir(claudeSkillsDir, { recursive: true });
     const written = [];
     const skipped = [];
+    const userModified = [];
     const errors = {};
     for (const def of WORKFLOW_SKILL_DEFINITIONS) {
         try {
             const skillFileName = `${def.name}.md`;
             const destPath = join(claudeSkillsDir, skillFileName);
-            // --- Idempotency check ---
-            if (!force) {
-                let existingContent = null;
-                try {
-                    existingContent = await readFile(destPath, 'utf-8');
-                }
-                catch {
-                    // File does not exist — will write
-                }
-                if (existingContent !== null) {
-                    const existingHash = extractExistingHash(existingContent);
-                    // Scenario 9: missing hash marker → treat as foreign, overwrite
-                    // Scenario 3: same hash → skip
-                    if (existingHash !== null && existingHash === currentHash) {
-                        skipped.push(def.name);
-                        continue;
-                    }
-                    // existingHash === null (missing marker) → fall through and overwrite
-                }
-            }
             // --- Adapt content via SPEC-682 (DRY — no duplicated placeholder logic) ---
             const { adapted } = adaptSkillContent(def.templateBody, resolvedKnowledge);
+            const newDigest = digestContent(adapted);
+            const decision = await decideForFile(destPath, newDigest, force);
+            if (decision.action === 'skip-unchanged') {
+                skipped.push(def.name);
+                continue;
+            }
+            if (decision.action === 'skip-user-modified') {
+                userModified.push(def.name);
+                continue;
+            }
+            if (decision.action === 'skip-error') {
+                errors[def.name] = decision.message;
+                continue;
+            }
             // --- Build final content with hash marker ---
-            const finalContent = buildSkillContent(adapted, currentHash);
+            const finalContent = buildSkillContent(adapted, newDigest);
             // --- Write .claude/skills/{name}.md ---
             if (targets.includes('claude')) {
                 await writeFile(destPath, finalContent, 'utf-8');
@@ -121,6 +196,6 @@ export async function generateWorkflowSkills(projectPath, knowledge, options = {
             errors[def.name] = err instanceof Error ? err.message : String(err);
         }
     }
-    return { written, skipped, errors };
+    return { written, skipped, userModified, errors };
 }
 //# sourceMappingURL=workflow-skill-generator.js.map

package/dist/engine/spec-format/bdd-parser.d.ts

@@ -1,16 +1,6 @@
 import type { BddScenario, BddStep, LeanCriterion } from '../../types/index.js';
 export type { BddScenario, BddStep };
-/**
- * Parses Gherkin-style blocks from a markdown string.
- *
- * Recognises:
- *   Scenario: <title>
- *     Given ...
- *     When ...
- *     Then ...
- *     And ...
- *     But ...
- */
+export declare function extractInlineTestPaths(text: string): string[];
 export declare function parseBddScenarios(markdown: string): BddScenario[];
 /**
  * Converts an array of BddScenario objects into YAML lines for the frontmatter.

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.
@@ -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() ?? '';
@@ -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