@planu/cli 4.11.9 → 4.12.2

package/dist/engine/safety/lock-scavenger.d.ts

@@ -0,0 +1,9 @@
+import type { CrossProcessLockMetadata, LockScavengeMetrics } from '../../types/spec-lock-v2.js';
+export declare function getLockScavengeMetrics(): Readonly<LockScavengeMetrics>;
+export declare function resetLockScavengeMetricsForTests(): void;
+export declare function readValidatedLockFile(path: string): Promise<{
+    raw: string;
+    metadata: CrossProcessLockMetadata;
+} | null>;
+export declare function scavengeStaleLockArtifacts(projectPath: string, onlySpecId?: string): Promise<LockScavengeMetrics>;
+//# sourceMappingURL=lock-scavenger.d.ts.map

package/dist/engine/safety/lock-scavenger.js

@@ -0,0 +1,114 @@
+import { readFile, readdir, unlink } from 'node:fs/promises';
+import { hostname as osHostname } from 'node:os';
+import { join } from 'node:path';
+import { enrichWithStaleness } from './lock-staleness.js';
+const MIN_TTL_MS = 60_000;
+const MAX_TTL_MS = 86_400_000;
+const metrics = {
+    scavengedLocks: 0,
+    scavengedBackups: 0,
+    preservedLive: 0,
+    preservedCorrupt: 0,
+};
+export function getLockScavengeMetrics() {
+    return { ...metrics };
+}
+export function resetLockScavengeMetricsForTests() {
+    metrics.scavengedLocks = 0;
+    metrics.scavengedBackups = 0;
+    metrics.preservedLive = 0;
+    metrics.preservedCorrupt = 0;
+}
+function locksDir(projectPath) {
+    return join(projectPath, 'data', '.locks', 'planu');
+}
+function isValidLockMetadata(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const lock = value;
+    return (typeof lock.specId === 'string' &&
+        lock.specId.trim().length > 0 &&
+        typeof lock.sessionId === 'string' &&
+        lock.sessionId.trim().length > 0 &&
+        typeof lock.hostname === 'string' &&
+        lock.hostname.trim().length > 0 &&
+        typeof lock.pid === 'number' &&
+        Number.isSafeInteger(lock.pid) &&
+        lock.pid > 0 &&
+        typeof lock.ttlMs === 'number' &&
+        Number.isSafeInteger(lock.ttlMs) &&
+        lock.ttlMs >= MIN_TTL_MS &&
+        lock.ttlMs <= MAX_TTL_MS &&
+        typeof lock.acquiredAt === 'string' &&
+        !Number.isNaN(Date.parse(lock.acquiredAt)) &&
+        typeof lock.lastHeartbeatAt === 'string' &&
+        !Number.isNaN(Date.parse(lock.lastHeartbeatAt)));
+}
+export async function readValidatedLockFile(path) {
+    try {
+        const raw = await readFile(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return isValidLockMetadata(parsed) ? { raw, metadata: parsed } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function scavengeStaleLockArtifacts(projectPath, onlySpecId) {
+    const dir = locksDir(projectPath);
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return { scavengedLocks: 0, scavengedBackups: 0, preservedLive: 0, preservedCorrupt: 0 };
+    }
+    const delta = {
+        scavengedLocks: 0,
+        scavengedBackups: 0,
+        preservedLive: 0,
+        preservedCorrupt: 0,
+    };
+    const candidates = entries.filter((entry) => {
+        const match = /^(.*\.lock)(?:\.bak\.\d+)?$/.exec(entry);
+        return match !== null && (!onlySpecId || match[1] === `${onlySpecId}.lock`);
+    });
+    for (const entry of candidates) {
+        const path = join(dir, entry);
+        const first = await readValidatedLockFile(path);
+        if (!first) {
+            delta.preservedCorrupt += 1;
+            continue;
+        }
+        const info = enrichWithStaleness(first.metadata, osHostname(), Date.now());
+        if (!info.stale) {
+            delta.preservedLive += 1;
+            continue;
+        }
+        const current = await readValidatedLockFile(path);
+        if (current?.raw !== first.raw) {
+            delta.preservedLive += 1;
+            continue;
+        }
+        try {
+            await unlink(path);
+            if (entry.includes('.lock.bak.')) {
+                delta.scavengedBackups += 1;
+            }
+            else {
+                delta.scavengedLocks += 1;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+                throw error;
+            }
+        }
+    }
+    for (const key of Object.keys(delta)) {
+        metrics[key] += delta[key];
+    }
+    return delta;
+}
+//# sourceMappingURL=lock-scavenger.js.map

package/dist/engine/session-context-generator.js

@@ -44,6 +44,13 @@ function getPendingApproved(specs) {
         .filter((s) => s.status === 'approved')
         .sort((a, b) => b.estimation.devHours - a.estimation.devHours);
 }
+/** Returns active in-progress specs ordered by most recently updated first. */
+function getActiveSpecs(specs) {
+    return specs
+        .filter((s) => s.status === 'implementing' || s.status === 'review')
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .slice(0, 5);
+}
 /** Fetches the last 3 lessons for the project via lessonsStore (best-effort). */
 async function fetchRecentLessons(projectPath) {
     try {
@@ -70,6 +77,13 @@ function buildApprovedRows(approved) {
         .map((s) => `| ${s.id} | ${s.title} | ${s.estimation.devHours.toFixed(1)}h |`)
         .join('\n');
 }
+/** Builds the markdown rows for the "Active Work" table. */
+function buildActiveRows(active) {
+    if (active.length === 0) {
+        return '| — | No active specs | — |';
+    }
+    return active.map((s) => `| ${s.id} | ${s.title} | ${s.status} |`).join('\n');
+}
 /** Renders the Key Lessons section. */
 function buildLessonsSection(lessons) {
     if (lessons.length === 0) {
@@ -79,7 +93,7 @@ function buildLessonsSection(lessons) {
 }
 /** Generates the full session-context.md content. */
 function buildMarkdown(params) {
-    const { version, doneCount, approvedCount, doneRows, approvedRows, lessonsContent, generatedAt } = params;
+    const { version, activeCount, doneCount, approvedCount, activeRows, doneRows, approvedRows, lessonsContent, generatedAt, } = params;
     return [
         '# Planu — Session Context',
         '',
@@ -88,7 +102,12 @@ function buildMarkdown(params) {
         '',
         '## Current State',
         `- **Version**: ${version}`,
-        `- **Status**: ${String(doneCount)} specs done / ${String(approvedCount)} approved pending`,
+        `- **Status**: ${String(activeCount)} active / ${String(doneCount)} done / ${String(approvedCount)} approved pending`,
+        '',
+        '## Active Work',
+        '| ID | Title | Status |',
+        '|----|-------|--------|',
+        activeRows,
         '',
         '## Recently Completed (last 5)',
         '| ID | Title | Completed |',
@@ -118,12 +137,15 @@ export async function generateSessionContext(projectPath, projectId) {
             specStore.listSpecs(projectId),
             fetchRecentLessons(projectPath),
         ]);
+        const active = getActiveSpecs(allSpecs);
         const done = getRecentlyDone(allSpecs);
         const approved = getPendingApproved(allSpecs);
         const content = buildMarkdown({
             version,
+            activeCount: active.length,
             doneCount: allSpecs.filter((s) => s.status === 'done').length,
             approvedCount: approved.length,
+            activeRows: buildActiveRows(active),
             doneRows: buildDoneRows(done),
             approvedRows: buildApprovedRows(approved),
             lessonsContent: buildLessonsSection(lessons),

package/dist/engine/session-safeguard/learnings-buffer.js

@@ -1,15 +1,19 @@
 // engine/session-safeguard/learnings-buffer.ts — SPEC-585: Append/flush learnings buffer
 import { open, readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 const BUFFER_VERSION = 1;
-const MEMORY_MD_PATH = '/Users/kevin/.claude/projects/-Users-kevin-Documents-desarrollo-sdd-mcp-server/memory/MEMORY.md';
 const MAX_RETRIES = 50;
 const JITTER_MS = 100;
 function bufferPath(projectPath) {
     const hash = hashProjectPath(projectPath);
     return join(projectDataDir(hash), 'learnings-buffer.json');
 }
+function claudeMemoryPath(projectPath) {
+    const projectKey = projectPath.replaceAll('\\', '-').replaceAll('/', '-');
+    return join(homedir(), '.claude', 'projects', projectKey, 'memory', 'MEMORY.md');
+}
 function emptyBuffer() {
     return { version: BUFFER_VERSION, entries: [] };
 }
@@ -92,7 +96,7 @@ export async function flushBuffer(projectPath) {
     if (buffer.entries.length === 0) {
         return 0;
     }
-    const memoryPath = MEMORY_MD_PATH;
+    const memoryPath = claudeMemoryPath(projectPath);
     let existing = '';
     try {
         existing = await readFile(memoryPath, 'utf-8');
@@ -102,6 +106,7 @@ export async function flushBuffer(projectPath) {
     }
     const bullets = buffer.entries.map(entryToMarkdown).join('\n');
     const section = `\n\n## Session Learnings (auto-flushed ${new Date().toISOString().slice(0, 10)})\n\n${bullets}\n`;
+    await mkdir(join(memoryPath, '..'), { recursive: true });
     await writeFile(memoryPath, existing + section, 'utf-8');
     await writeBuffer(projectPath, emptyBuffer());
     return buffer.entries.length;

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

@@ -123,6 +123,14 @@ export function computeEpicProgress(specs) {
     }
     return progress;
 }
+function reconcileActiveSpecIds(existing, specs) {
+    const activeFromSpecs = specs
+        .filter((spec) => spec.status === 'implementing' || spec.status === 'review')
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .map((spec) => spec.id);
+    const knownActive = new Set(activeFromSpecs);
+    return [...new Set(existing.filter((specId) => knownActive.has(specId)).concat(activeFromSpecs))];
+}
 /**
  * SPEC-656: Update epicProgress in root session.json after any status change.
  * Best-effort — never throws.
@@ -130,9 +138,6 @@ export function computeEpicProgress(specs) {
 export async function updateEpicProgressInSession(projectPath, specs) {
     try {
         const epicProgress = computeEpicProgress(specs);
-        if (Object.keys(epicProgress).length === 0) {
-            return;
-        }
         const filePath = rootFile(projectPath);
         let existingContent = null;
         let index = { activeSpecs: [], updatedAt: '' };
@@ -143,11 +148,13 @@ export async function updateEpicProgressInSession(projectPath, specs) {
         catch {
             /* start fresh */
         }
-        const terminalSpecIds = new Set(specs
-            .filter((spec) => spec.status === 'done' || spec.status === 'discarded')
-            .map((spec) => spec.id));
-        index.activeSpecs = index.activeSpecs.filter((specId) => !terminalSpecIds.has(specId));
-        index.epicProgress = epicProgress;
+        index.activeSpecs = reconcileActiveSpecIds(index.activeSpecs, specs);
+        if (Object.keys(epicProgress).length === 0) {
+            delete index.epicProgress;
+        }
+        else {
+            index.epicProgress = epicProgress;
+        }
         index.updatedAt = new Date().toISOString();
         await stableWriteGeneratedFile(filePath, stableJsonStringify(index), {
             equivalence: stripRootUpdatedAt,

package/dist/engine/skill-registry/installer.js

@@ -195,7 +195,7 @@ export async function installSkill(skillName, source, projectPath, options = {})
         source,
         version,
         installedAt: new Date().toISOString(),
-        path: installDir,
+        path: path.relative(projectPath, installDir).split(path.sep).join('/'),
         securityScan,
     };
     await writeSkillManifest(projectPath, upsertManifestEntry(manifest, entry));

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

@@ -1,21 +1,7 @@
 import { parseFrontmatterScenarios } from '../validator/spec-compliance-runner.js';
 import { stripFrontmatter } from '../frontmatter-parser.js';
 import { extractListItems, extractSection } from '../validator/extractors.js';
-function normalizeCriterionValue(value) {
-    return value
-        .replace(/^-\s*\[[ x]\]\s*/i, '')
-        .replace(/[`*_()[\]:]/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim()
-        .toLowerCase();
-}
-function stripCriterionIdPrefix(value) {
-    return value.replace(/^(AC\d+)\s*[:.)-]?\s*/i, '').trim();
-}
-function detectCriterionId(value, index) {
-    const explicit = /^(AC\d+)\b/i.exec(value)?.[1];
-    return (explicit ?? `AC${String(index + 1)}`).toUpperCase();
-}
+import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
 function extractSectionCriteria(section) {
     const listItems = extractListItems(section);
     if (listItems.length > 0) {
@@ -72,18 +58,14 @@ function buildCriterion(text, source, index) {
     if (trimmed.length === 0) {
         return null;
     }
-    const id = detectCriterionId(trimmed, index);
-    const withoutId = stripCriterionIdPrefix(trimmed);
-    const aliases = new Set([
-        normalizeCriterionValue(trimmed),
-        normalizeCriterionValue(withoutId),
-        normalizeCriterionValue(id),
-    ]);
+    const identity = createCriterionIdentity(trimmed, { index });
     return {
-        id,
-        text: withoutId,
+        id: identity.id,
+        text: identity.text,
+        normalizedText: identity.normalizedText,
+        stableKey: identity.stableKey,
         source,
-        aliases: [...aliases].filter((alias) => alias.length > 0),
+        aliases: identity.aliases,
     };
 }
 export function extractNormalizedAcceptanceCriteria(raw) {
@@ -101,6 +83,6 @@ export function extractAcceptanceCriteriaTexts(raw) {
     return extractNormalizedAcceptanceCriteria(raw).map((criterion) => criterion.text);
 }
 export function normalizeAcceptanceCriterionToken(value) {
-    return normalizeCriterionValue(stripCriterionIdPrefix(value));
+    return normalizeCriterionText(value);
 }
 //# sourceMappingURL=acceptance-criteria.js.map

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

@@ -1,6 +1,6 @@
 import type { Spec } from '../../types/index.js';
 import type { CriterionGroundingRecord, GroundingGateResult, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
-export declare function normalizeCriterionText(text: string): string;
+export { normalizeCriterionText } from '../criterion-identity.js';
 export declare function isGenericCriterion(text: string): boolean;
 export declare function filterGroundedCriteria(criteria: string[]): string[];
 export declare function buildCriterionGroundingRecords(args: {
@@ -21,4 +21,6 @@ export declare function renderTechnicalReferenceGroundingFrontmatter(records: Te
 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 parseApprovedFileLevelWorkPlanPaths(content: string): string[];
+export declare function parseGroundedTechnicalPaths(content: string): string[];
 //# sourceMappingURL=contract.d.ts.map

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

@@ -1,3 +1,5 @@
+import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
+export { normalizeCriterionText } from '../criterion-identity.js';
 const GENERIC_CRITERION_PATTERNS = [
     /\bimplementation complete\b/i,
     /\bcomplete and tested\b/i,
@@ -8,13 +10,6 @@ const GENERIC_CRITERION_PATTERNS = [
     /\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));
 }
@@ -24,12 +19,16 @@ export function filterGroundedCriteria(criteria) {
 export function buildCriterionGroundingRecords(args) {
     const userInput = normalizeCriterionText(args.userInput);
     const generatedEvidence = args.generatedEvidence ?? [];
-    const criterionEvidence = new Map((args.criterionEvidence ?? []).map((record) => [
-        normalizeCriterionText(record.criterion),
-        record.evidence.filter((item) => item.trim().length > 0),
-    ]));
-    return args.criteria.map((criterion) => {
-        const normalized = normalizeCriterionText(criterion);
+    const criterionEvidence = new Map();
+    for (const [index, record] of (args.criterionEvidence ?? []).entries()) {
+        const evidence = record.evidence.filter((item) => item.trim().length > 0);
+        for (const alias of createCriterionIdentity(record.criterion, { index }).aliases) {
+            criterionEvidence.set(alias, evidence);
+        }
+    }
+    return args.criteria.map((criterion, index) => {
+        const identity = createCriterionIdentity(criterion, { index });
+        const normalized = identity.normalizedText;
         if (isGenericCriterion(criterion)) {
             return {
                 text: criterion,
@@ -46,7 +45,7 @@ export function buildCriterionGroundingRecords(args) {
                 confidence: 'high',
             };
         }
-        const directProjectEvidence = criterionEvidence.get(normalized) ?? [];
+        const directProjectEvidence = identity.aliases.map((alias) => criterionEvidence.get(alias)).find(Boolean) ?? [];
         if (directProjectEvidence.length > 0) {
             return {
                 text: criterion,
@@ -177,6 +176,32 @@ export function parseTechnicalReferenceGroundingRecords(frontmatter) {
     }
     return records;
 }
+export function parseApprovedFileLevelWorkPlanPaths(content) {
+    const section = /(?:^|\n)### File-Level Work Plan\s*\n([\s\S]*?)(?=\n###\s|$)/i.exec(content)?.[1];
+    if (!section) {
+        return [];
+    }
+    const paths = new Set();
+    for (const match of section.matchAll(/^-\s*(?:Create|Modify|Test):\s*`([^`]+)`/gim)) {
+        const path = match[1]?.trim() ?? '';
+        if (path.length > 0 &&
+            !path.startsWith('/') &&
+            !path.split('/').includes('..') &&
+            !/[*?[\]{}]/.test(path)) {
+            paths.add(path.replace(/^\.\//, ''));
+        }
+    }
+    return [...paths];
+}
+export function parseGroundedTechnicalPaths(content) {
+    const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
+    return [
+        ...new Set([
+            ...parseTechnicalReferenceGroundingRecords(frontmatter).map((record) => record.path),
+            ...parseApprovedFileLevelWorkPlanPaths(content),
+        ]),
+    ];
+}
 function parseYamlInlineStringArray(raw) {
     if (raw.trim().length === 0) {
         return [];

package/dist/engine/universal-rules/installer.js

@@ -1,6 +1,6 @@
 // engine/universal-rules/installer.ts — SPEC-779
 // Install all applicable universal rules for a given host.
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
 import { UNIVERSAL_RULES } from './catalog.js';
 import { writeRuleForHost } from './host-writer.js';
@@ -38,7 +38,7 @@ export async function installUniversalRules(projectPath, host) {
             const hash = hashContent(content);
             const entry = {
                 id: rule.id,
-                path: writtenPath,
+                path: relative(projectPath, writtenPath).split('\\').join('/'),
                 hostId: host,
                 hashAtInstall: hash,
                 installedAt: new Date().toISOString(),

package/dist/engine/validation-evidence-digest.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationEvidenceKeyInput, ValidationToolchain } from '../types/validation-evidence.js';
+export declare function resolveValidationToolchain(input: ValidationEvidenceKeyInput): ValidationToolchain;
+export declare function digestValidationPaths(projectPath: string, selectedPaths: readonly string[]): string;
+//# sourceMappingURL=validation-evidence-digest.d.ts.map

package/dist/engine/validation-evidence-digest.js

@@ -0,0 +1,83 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+export function resolveValidationToolchain(input) {
+    const packageManager = readPackageManager(input.projectPath);
+    return {
+        node: input.toolchain?.node ?? process.version,
+        packageManager: input.toolchain?.packageManager ?? packageManager,
+        platform: input.platformDependent
+            ? (input.toolchain?.platform ?? process.platform)
+            : 'portable',
+        architecture: input.platformDependent
+            ? (input.toolchain?.architecture ?? process.arch)
+            : 'portable',
+    };
+}
+export function digestValidationPaths(projectPath, selectedPaths) {
+    const root = resolve(projectPath);
+    const files = new Set();
+    for (const selected of selectedPaths) {
+        collectFiles(root, selected, files);
+    }
+    const hash = createHash('sha256');
+    for (const relativePath of [...files].sort()) {
+        hash.update(relativePath);
+        hash.update('\0');
+        try {
+            hash.update(readFileSync(join(root, relativePath)));
+        }
+        catch {
+            hash.update('unreadable');
+        }
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function readPackageManager(projectPath) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf-8'));
+        return typeof manifest.packageManager === 'string' ? manifest.packageManager : '';
+    }
+    catch {
+        return '';
+    }
+}
+function collectFiles(root, selected, files) {
+    const normalized = normalizeRelativePath(selected);
+    if (!normalized || normalized.startsWith('../')) {
+        return;
+    }
+    const absolute = resolve(root, normalized);
+    if (absolute !== root && !absolute.startsWith(`${root}${sep}`)) {
+        return;
+    }
+    let stat;
+    try {
+        stat = lstatSync(absolute);
+    }
+    catch {
+        files.add(`${normalized}:missing`);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        return;
+    }
+    if (stat.isFile()) {
+        files.add(normalized);
+        return;
+    }
+    if (!stat.isDirectory()) {
+        return;
+    }
+    for (const entry of readdirSync(absolute)) {
+        if (entry === '.git' || entry === 'node_modules' || entry === 'dist') {
+            continue;
+        }
+        collectFiles(root, relative(root, join(absolute, entry)), files);
+    }
+}
+function normalizeRelativePath(path) {
+    return path.trim().replaceAll('\\', '/').replace(/^\.\//, '');
+}
+//# sourceMappingURL=validation-evidence-digest.js.map

package/dist/engine/validation-evidence-ledger.d.ts

@@ -0,0 +1,30 @@
+import { type ValidationEvidenceAudit, type ValidationEvidenceIdentity, type ValidationEvidenceKeyInput, type ValidationEvidenceReceipt } from '../types/validation-evidence.js';
+export declare function normalizeValidationCommand(command: string): string;
+export declare function computeValidationEvidenceIdentity(input: ValidationEvidenceKeyInput): ValidationEvidenceIdentity;
+export declare function computeValidationEvidenceKey(identity: ValidationEvidenceIdentity): string;
+export declare function validationReceiptPath(projectId: string, key: string): string;
+export declare function readMatchingValidationEvidence(projectId: string, input: ValidationEvidenceKeyInput): ValidationEvidenceReceipt | null;
+export declare function recordSuccessfulValidationEvidence(args: {
+    projectId: string;
+    input: ValidationEvidenceKeyInput;
+    expectedKey?: string;
+    producer: string;
+    durationMs: number;
+    output: string;
+    reason: string;
+    source?: string;
+}): ValidationEvidenceReceipt | null;
+export declare function auditValidationEvidence(receipt: ValidationEvidenceReceipt, action: ValidationEvidenceAudit['action']): ValidationEvidenceAudit;
+export declare function recordValidationEvidenceAudit(projectId: string, audit: ValidationEvidenceAudit): void;
+export declare function recordValidationOutcome(args: {
+    projectId: string;
+    input: ValidationEvidenceKeyInput;
+    action: ValidationEvidenceAudit['action'];
+    producer: string;
+    status: ValidationEvidenceReceipt['status'];
+    durationMs: number;
+    output: string;
+    reason: string;
+    source?: string;
+}): void;
+//# sourceMappingURL=validation-evidence-ledger.d.ts.map