@planu/cli 4.14.1 → 5.1.1

package/dist/engine/cost-guardrails.js

@@ -38,7 +38,7 @@ export function formatBudgetMessage(status) {
     return msg;
 }
 /**
- * Enforces budget limits before executing a licensed tool.
+ * Enforces engineering budget limits before executing a governed tool.
  * - If no budget is configured for the spec → no-op (pass through).
  * - If budget is exhausted → throws an Error to block tool execution.
  * - If warning threshold is reached → logs a warning but allows execution.

package/dist/engine/criterion-identity.d.ts

@@ -1,5 +1,6 @@
 import type { CriterionIdentity, CriterionIdentityOptions } from '../types/criterion-identity.js';
 export type { CriterionIdentity, CriterionIdentityOptions } from '../types/criterion-identity.js';
+export declare function hasExplicitCriterionId(value: string): boolean;
 export declare function normalizeCriterionText(value: string): string;
 export declare function createCriterionIdentity(value: string, options?: CriterionIdentityOptions): CriterionIdentity;
 export declare function criterionIdentitiesMatch(left: CriterionIdentity, right: CriterionIdentity): boolean;

package/dist/engine/criterion-identity.js

@@ -1,5 +1,12 @@
 import { createHash } from 'node:crypto';
 const CRITERION_ID_PREFIX = /^(AC|AB)\s*-?\s*(\d+)\b\s*[:.)-]?\s*/i;
+export function hasExplicitCriterionId(value) {
+    const stripped = value
+        .normalize('NFKC')
+        .replace(/^[-*+]\s*\[[ xX]\]\s*/, '')
+        .trim();
+    return CRITERION_ID_PREFIX.test(stripped);
+}
 export function normalizeCriterionText(value) {
     return value
         .normalize('NFKC')

package/dist/engine/dashboard/data-loader.js

@@ -324,18 +324,13 @@ export async function loadUsageStats() {
     const raw = await readJsonFile(usageFile);
     if (!raw) {
         return {
-            tier: 'unknown',
             callsToday: 0,
-            dailyLimit: null,
-            trialDaysLeft: null,
             isAvailable: false,
         };
     }
+    const today = new Date().toISOString().slice(0, 10);
     return {
-        tier: raw.tier ?? 'free',
-        callsToday: raw.callsToday ?? 0,
-        dailyLimit: raw.dailyLimit ?? null,
-        trialDaysLeft: raw.trialDaysLeft ?? null,
+        callsToday: (raw.events ?? []).filter((event) => event.timestamp?.startsWith(today)).length,
         isAvailable: true,
     };
 }

package/dist/engine/dashboard/templates-layout.js

@@ -194,9 +194,6 @@ function getPageStyles() {
   .usage-panel { background: var(--surface); border: 1px solid var(--border);
                  border-radius: var(--radius); padding: 1rem; margin-top: 1.5rem; }
   .usage-panel h3 { font-size: 0.9rem; font-weight: 600; margin-bottom: 0.75rem; color: var(--text-muted); }
-  .usage-tier { font-size: 1.1rem; font-weight: 700; color: var(--accent); }
-  .trial-warning { color: #f59e0b; font-size: 0.82rem; margin-top: 0.35rem; }
-  .trial-critical { color: #ef4444; font-weight: 600; }
   .status-indicator.updating { color: #f59e0b; }
   .shortcuts-overlay { display: none; position: fixed; inset: 0; background: rgba(0,0,0,0.7);
     z-index: 1000; align-items: center; justify-content: center; }

package/dist/engine/dashboard/templates-project.js

@@ -30,21 +30,9 @@ function renderUsagePanel(usage) {
       <div style="color:var(--text-muted);font-size:0.85rem">Sin datos de uso disponibles</div>
     </div>`;
     }
-    const tierLabel = usage.tier.charAt(0).toUpperCase() + usage.tier.slice(1);
-    const limitLabel = usage.dailyLimit !== null ? String(usage.dailyLimit) : '∞';
-    const callsLabel = `${usage.callsToday} / ${limitLabel}`;
-    let trialHtml = '';
-    if (usage.trialDaysLeft !== null) {
-        const isCritical = usage.trialDaysLeft <= 3;
-        trialHtml = `<div class="trial-warning ${isCritical ? 'trial-critical' : ''}">
-      Trial: ${usage.trialDaysLeft} día${usage.trialDaysLeft !== 1 ? 's' : ''} restante${usage.trialDaysLeft !== 1 ? 's' : ''}
-    </div>`;
-    }
     return `<div class="usage-panel">
     <h3>Uso</h3>
-    <div class="usage-tier">${escapeHtml(tierLabel)}</div>
-    <div style="font-size:0.82rem;color:var(--text-muted);margin-top:0.35rem">Llamadas hoy: ${escapeHtml(callsLabel)}</div>
-    ${trialHtml}
+    <div style="font-size:0.82rem;color:var(--text-muted);margin-top:0.35rem">Llamadas hoy: ${String(usage.callsToday)}</div>
   </div>`;
 }
 /** Render the health metrics panel */

package/dist/engine/docs-site-generator/data-collector.d.ts

@@ -1,5 +1,5 @@
 import type { DocSpecSummary, ToolEntry, ProjectMetrics } from '../../types/docs.js';
 export declare function collectSpecs(projectPath: string): Promise<DocSpecSummary[]>;
-export declare function collectTools(projectPath: string): ToolEntry[];
+export declare function collectTools(_projectPath: string): ToolEntry[];
 export declare function collectMetrics(projectPath: string): Promise<ProjectMetrics>;
 //# sourceMappingURL=data-collector.d.ts.map

package/dist/engine/docs-site-generator/data-collector.js

@@ -1,8 +1,8 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // SPEC-093: Data collector for docs site generator
-import { readFileSync } from 'node:fs';
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { readCanonicalToolNames } from '../../config/official-sdd-tools.js';
 import { parseFrontmatter } from '../frontmatter-parser.js';
 const SDD_PHASES = {
     Initialize: ['init_project', 'init_constitution', 'set_locale'],
@@ -225,33 +225,12 @@ export async function collectSpecs(projectPath) {
     });
     return results;
 }
-export function collectTools(projectPath) {
-    let plans;
-    try {
-        const plansPath = join(projectPath, 'src', 'config', 'license-plans.json');
-        plans = JSON.parse(readFileSync(plansPath, 'utf-8'));
-    }
-    catch {
-        return [];
-    }
-    const entries = [];
-    for (const tool of plans.freeTools ?? []) {
-        entries.push({
-            name: tool,
-            description: tool.replace(/_/g, ' '),
-            phase: findPhaseForTool(tool),
-            tier: 'free',
-        });
-    }
-    for (const tool of plans.proTools ?? []) {
-        entries.push({
-            name: tool,
-            description: tool.replace(/_/g, ' '),
-            phase: findPhaseForTool(tool),
-            tier: 'pro',
-        });
-    }
-    return entries;
+export function collectTools(_projectPath) {
+    return readCanonicalToolNames().map((tool) => ({
+        name: tool,
+        description: tool.replaceAll('_', ' '),
+        phase: findPhaseForTool(tool),
+    }));
 }
 async function countLinesInDir(dirPath) {
     let total = 0;

package/dist/engine/docs-site-generator/tools-renderer.js

@@ -11,18 +11,11 @@ function groupByPhase(tools) {
     }
     return groups;
 }
-function renderTierBadge(tier) {
-    const cls = tier === 'free' ? 'badge-free' : 'badge-pro';
-    const label = tier === 'free' ? 'Free' : 'Pro';
-    return `<span class="tier-badge ${cls}">${label}</span>`;
-}
 export function renderToolsCatalog(tools) {
-    const freeCount = tools.filter((t) => t.tier === 'free').length;
-    const proCount = tools.filter((t) => t.tier === 'pro').length;
     if (tools.length === 0) {
         return `<div class="tools-catalog">
   <div class="tools-summary">
-    <p>Total: 0 | Free: 0 | Pro: 0</p>
+    <p>Total: 0</p>
   </div>
   <p class="empty">No tools found.</p>
 </div>`;
@@ -34,7 +27,7 @@ export function renderToolsCatalog(tools) {
             .map((tool) => {
             const searchable = `${tool.name} ${tool.description}`.toLowerCase();
             return `    <div class="tool-card" data-searchable="${searchable}">
-      <h3>${tool.name} ${renderTierBadge(tool.tier)}</h3>
+      <h3>${tool.name}</h3>
       <p>${tool.description}</p>
     </div>`;
         })
@@ -47,7 +40,7 @@ ${cards}
         .join('\n');
     return `<div class="tools-catalog">
   <div class="tools-summary">
-    <p>Total: ${String(tools.length)} | Free: ${String(freeCount)} | Pro: ${String(proCount)}</p>
+    <p>Total: ${String(tools.length)}</p>
   </div>
 ${sections}
 </div>`;

package/dist/engine/evidence-gates/artifact-reader.d.ts

@@ -1,11 +1,22 @@
 import type { Spec } from '../../types/spec/core.js';
-import type { EvidenceArtifacts } from '../../types/evidence-gates.js';
+import type { EvidenceArtifacts, TraceabilityMatrixEvidence } from '../../types/evidence-gates.js';
 /** Digest of canonical artifact content; the provenance envelope is excluded. */
 export declare function evidenceArtifactDigest(artifact: unknown): string;
 export declare function evidenceArtifactCollectionDigest(artifacts: readonly {
     kind: string;
     provenance?: unknown;
 }[]): string;
+/** Verify legacy test-backed evidence without admitting prose-only traceability rows. */
+export declare function traceabilityRowHasCurrentTestEvidence(row: TraceabilityMatrixEvidence['rows'][number], args: {
+    projectPath: string;
+}): boolean;
+/** Verify strict command evidence against current repository inputs and the validation ledger. */
+export declare function traceabilityRowHasCurrentCommandEvidence(row: TraceabilityMatrixEvidence['rows'][number], args: {
+    projectId: string;
+    projectPath: string;
+}): boolean;
+/** SPEC-1356: exported so evidence-autofill (and other producers) target the same path convention. */
+export declare function handoffEvidencePath(projectId: string, specId: string, filename: string): string;
 export declare function readEvidenceArtifacts(args: {
     spec: Spec;
     projectId: string;

package/dist/engine/evidence-gates/artifact-reader.js

@@ -1,12 +1,30 @@
 import { technologyValue } from '../technology-registry.js';
 import { readFile } from 'node:fs/promises';
+import { lstatSync, realpathSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { join } from 'node:path';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { z } from 'zod';
 import { projectDataDir } from '../../storage/base-store.js';
+import { computeValidationEvidenceIdentity, computeValidationEvidenceKey, normalizeValidationCommand, readMatchingValidationEvidence, } from '../validation-evidence-ledger.js';
+import { VALIDATION_COMMANDS } from '../validation-impact-planner.js';
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const SPEC_ID = /^SPEC-[1-9]\d*$/u;
 const ISSUER_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const EVIDENCE_KEY = /^[a-f0-9]{64}$/u;
+const ValidationGateCapabilitySchema = z.enum([
+    'typecheck',
+    'lint',
+    'test-related',
+    'test-full',
+    'contract',
+    'coverage',
+    'migration',
+    'fault-injection',
+    'security',
+    'native',
+    'website',
+    'reproducibility',
+]);
 const ProvenanceSchema = z
     .object({
     receiptId: z.string().regex(DIGEST),
@@ -69,6 +87,16 @@ const TraceabilityMatrixSchema = z
         changedFiles: z.array(z.string().min(1)).max(200),
         validationEvidence: z.string().optional(),
         reviewerEvidence: z.string().optional(),
+        commandEvidence: z
+            .object({
+            capability: ValidationGateCapabilitySchema,
+            command: z.string().min(1),
+            scope: z.array(z.string().min(1)).min(1).max(200),
+            relevantPaths: z.array(z.string().min(1)).min(1).max(200).optional(),
+            evidenceKey: z.string().regex(EVIDENCE_KEY),
+        })
+            .strict()
+            .optional(),
     })
         .strict())
         .max(1000),
@@ -118,10 +146,95 @@ export function evidenceArtifactCollectionDigest(artifacts) {
         .map((artifact) => ({ kind: artifact.kind, digest: evidenceArtifactDigest(artifact) }))
         .sort((left, right) => left.kind.localeCompare(right.kind)));
 }
+function safeRepositoryPath(path) {
+    const normalized = path.trim().replaceAll('\\', '/').replace(/^\.\//u, '');
+    return (normalized.length > 0 &&
+        !normalized.startsWith('/') &&
+        !/^[A-Za-z]:/u.test(normalized) &&
+        normalized
+            .split('/')
+            .every((segment) => segment.length > 0 && segment !== '.' && segment !== '..'));
+}
+function repositoryEvidencePathsAreCurrent(row, projectPath, additionalPaths = []) {
+    let repositoryRoot;
+    try {
+        repositoryRoot = realpathSync(projectPath);
+    }
+    catch {
+        return false;
+    }
+    const paths = [
+        ...row.changedFiles,
+        ...(row.testEvidence ?? []),
+        ...(row.contractEvidence ?? []),
+        ...additionalPaths,
+    ];
+    return (paths.length > 0 &&
+        paths.every((path) => {
+            if (!safeRepositoryPath(path)) {
+                return false;
+            }
+            const candidate = resolve(repositoryRoot, path);
+            try {
+                if (lstatSync(candidate).isSymbolicLink()) {
+                    return false;
+                }
+                const realPath = realpathSync(candidate);
+                const relativePath = relative(repositoryRoot, realPath);
+                return (relativePath.length > 0 &&
+                    relativePath.split(/[\\/]/u)[0] !== '..' &&
+                    !isAbsolute(relativePath));
+            }
+            catch {
+                return false;
+            }
+        }));
+}
+function isExecutableTestPath(path) {
+    return /(?:^|\/)[^/]+\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(path.replaceAll('\\', '/'));
+}
+/** Verify legacy test-backed evidence without admitting prose-only traceability rows. */
+export function traceabilityRowHasCurrentTestEvidence(row, args) {
+    return (row.commandEvidence === undefined &&
+        row.changedFiles.length > 0 &&
+        (row.testEvidence?.length ?? 0) > 0 &&
+        row.testEvidence?.every(isExecutableTestPath) === true &&
+        Boolean(row.validationEvidence?.trim()) &&
+        Boolean(row.reviewerEvidence?.trim()) &&
+        repositoryEvidencePathsAreCurrent(row, args.projectPath));
+}
+/** Verify strict command evidence against current repository inputs and the validation ledger. */
+export function traceabilityRowHasCurrentCommandEvidence(row, args) {
+    const evidence = row.commandEvidence;
+    const expectedCommand = evidence
+        ? VALIDATION_COMMANDS[evidence.capability]
+        : undefined;
+    if (!evidence ||
+        !expectedCommand ||
+        normalizeValidationCommand(evidence.command) !== normalizeValidationCommand(expectedCommand)) {
+        return false;
+    }
+    const repositoryPaths = [...(evidence.relevantPaths ?? [])];
+    if (row.changedFiles.length === 0 ||
+        !repositoryEvidencePathsAreCurrent(row, args.projectPath, repositoryPaths) ||
+        evidence.scope.some((path) => !safeRepositoryPath(path))) {
+        return false;
+    }
+    const input = {
+        projectPath: args.projectPath,
+        capability: evidence.capability,
+        command: evidence.command,
+        scope: evidence.scope,
+        ...(evidence.relevantPaths === undefined ? {} : { relevantPaths: evidence.relevantPaths }),
+    };
+    const currentKey = computeValidationEvidenceKey(computeValidationEvidenceIdentity(input));
+    return (currentKey === evidence.evidenceKey &&
+        readMatchingValidationEvidence(args.projectId, input)?.status === 'passed');
+}
 const ARTIFACT_HINTS = {
     'Discovery evidence': 'Expected discovery.json with { version: 1, rules: string[], examples: [{ rule, example }], openQuestions: [{ question, status, resolution? }], outOfScope: string[], glossary: [{ term, meaning }] }.',
     'Task plan evidence': 'Expected task-plan.json with { version: 1, tasks: [{ id, title, acceptanceCriteria: string[], status: "pending"|"doing"|"done" }] }. Acceptance criteria may be full text or stable IDs such as AC1 when they map to the canonical criteria order.',
-    'Traceability matrix evidence': 'Expected traceability-matrix.json with { version: 1, rows: [{ acceptanceCriterion, scenario?, testEvidence?, contractEvidence?, manualEvidence?, changedFiles: string[], validationEvidence?, reviewerEvidence? }] }.',
+    'Traceability matrix evidence': 'Expected traceability-matrix.json with { version: 1, rows: [{ acceptanceCriterion, scenario?, testEvidence?, contractEvidence?, manualEvidence?, changedFiles: string[], validationEvidence?, reviewerEvidence?, commandEvidence?: { capability, command, scope, relevantPaths?, evidenceKey } }] }.',
     'contract-validation-api.json': 'Expected filename contract-validation-api.json with { version: 1, kind: "api", passed: boolean, reportPath?, summary? }.',
     'contract-validation-graphql.json': 'Expected filename contract-validation-graphql.json with { version: 1, kind: "graphql", passed: boolean, reportPath?, summary? }.',
     'contract-validation-event.json': 'Expected filename contract-validation-event.json with { version: 1, kind: "event", passed: boolean, reportPath?, summary? }.',
@@ -131,7 +244,58 @@ const ARTIFACT_HINTS = {
 function artifactHint(label) {
     return ARTIFACT_HINTS[label] ?? '';
 }
-function handoffEvidencePath(projectId, specId, filename) {
+/**
+ * SPEC-1356 / AC5: compact JSON literal per artifact kind, appended verbatim to
+ * schema-validation errors so a retrying caller sees the exact expected shape
+ * instead of re-deriving it from prose.
+ */
+const ARTIFACT_EXAMPLES = {
+    'Discovery evidence': JSON.stringify({
+        version: 1,
+        rules: ['Rule text'],
+        examples: [{ rule: 'Rule text', example: 'Example text' }],
+        openQuestions: [{ question: 'Open question?', status: 'open' }],
+        outOfScope: ['Not in scope item'],
+        glossary: [{ term: 'Term', meaning: 'Meaning' }],
+    }),
+    'Task plan evidence': JSON.stringify({
+        version: 1,
+        tasks: [{ id: 'T1', title: 'Task title', acceptanceCriteria: ['AC1'], status: 'pending' }],
+    }),
+    'Traceability matrix evidence': JSON.stringify({
+        version: 1,
+        rows: [
+            {
+                acceptanceCriterion: 'AC text',
+                testEvidence: ['tests/example.test.ts'],
+                changedFiles: ['src/example.ts'],
+                validationEvidence: 'validate passed with score 100',
+                reviewerEvidence: 'planu-implementation-reviewer approved',
+            },
+        ],
+    }),
+    // Contract kinds are derived from the artifact filenames so no
+    // configurable technology literal is hardcoded here (audit:hardcodes).
+    ...Object.fromEntries([
+        'contract-validation-api.json',
+        'contract-validation-graphql.json',
+        'contract-validation-event.json',
+        'contract-validation-ui.json',
+        'contract-validation-mcp.json',
+    ].map((label) => [
+        label,
+        JSON.stringify({
+            version: 1,
+            kind: label.slice('contract-validation-'.length, -'.json'.length),
+            passed: true,
+        }),
+    ])),
+};
+function artifactExample(label) {
+    return ARTIFACT_EXAMPLES[label] ?? '';
+}
+/** SPEC-1356: exported so evidence-autofill (and other producers) target the same path convention. */
+export function handoffEvidencePath(projectId, specId, filename) {
     return join(projectDataDir(projectId), 'handoffs', specId, filename);
 }
 async function readUnknown(paths) {
@@ -160,7 +324,13 @@ async function readOptional(args) {
         }
         const parsed = args.schema.safeParse(found.value);
         if (!parsed.success) {
-            args.invalidArtifacts.push(`${args.label} is invalid at ${found.path}: ${parsed.error.issues.map((issue) => issue.message).join('; ')} ${artifactHint(args.label)}`.trim());
+            // SPEC-1356 / AC5: surface every Zod issue (field path + message), not just the
+            // first one, so a single retry can fix every constraint violation at once.
+            const allIssues = parsed.error.issues
+                .map((issue) => `${issue.path.length > 0 ? issue.path.join('.') : '(root)'}: ${issue.message}`)
+                .join('; ');
+            const example = artifactExample(args.label);
+            args.invalidArtifacts.push(`${args.label} is invalid at ${found.path}: ${allIssues} ${artifactHint(args.label)}${example ? ` Expected shape example: ${example}` : ''}`.trim());
             return undefined;
         }
         return parsed.data;

package/dist/engine/evidence-gates/evidence-autofill.d.ts

@@ -0,0 +1,10 @@
+import type { AutofillTraceabilityMatrixArgs, AutofillTraceabilityMatrixResult } from '../../types/evidence-autofill.js';
+/**
+ * Generate `traceability-matrix.json` in the handoff evidence store when it does
+ * not already exist. Never overwrites an existing file — if one is present this
+ * is a no-op that reports `already-exists`. Tolerates every failure by returning
+ * a typed non-throwing result; callers must never let this crash a lifecycle
+ * transition.
+ */
+export declare function autofillTraceabilityMatrix(args: AutofillTraceabilityMatrixArgs): Promise<AutofillTraceabilityMatrixResult>;
+//# sourceMappingURL=evidence-autofill.d.ts.map

package/dist/engine/evidence-gates/evidence-autofill.js

@@ -0,0 +1,148 @@
+// engine/evidence-gates/evidence-autofill.ts — SPEC-1356: automated lifecycle evidence pipeline
+//
+// Generates traceability-matrix.json in the handoff evidence store when it is
+// missing, so a `done` transition never fails purely because nobody hand-wrote
+// the traceability artifact.
+//
+// ORDERING CAVEAT (documented per SPEC-1356 T-A3): writing traceability-matrix.json
+// *after* `validate` has already computed and bound durable validation receipts
+// would make those bindings stale relative to the newly-written evidence — the
+// receipt would be certifying a repository state that does not include this file.
+// This module does NOT attempt to re-run or re-bind validation. Instead, callers
+// (see `src/tools/update-status/index.ts`) MUST treat a write from this module as
+// "evidence created, not yet bound": when autofill actually writes the file, the
+// caller must block the `done` transition with a message telling the operator to
+// re-run `validate` once so the freshly-created evidence gets bound, then retry
+// `done`. This is the simpler, safe choice given SPEC-1356 could not fully verify
+// that skipping straight through to the done gates after autofill would keep
+// receipt bindings correct in every code path (reconciliation, forced bypass,
+// legacy harnesses, etc.).
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { extractAcceptanceCriteriaTexts } from '../spec-format/acceptance-criteria.js';
+import { parseFrontmatterScenarios } from '../validator/spec-compliance-runner.js';
+import { extractCanonicalFileOwnership } from '../handoff-packager.js';
+import { handoffEvidencePath } from './artifact-reader.js';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { ValidationReportV1Schema } from '../handoff-artifacts/schemas.js';
+import { projectDataDir } from '../../storage/base-store.js';
+import { readFile } from 'node:fs/promises';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+const execFileAsync = promisify(execFile);
+const defaultExec = async (command, args, options) => {
+    const { stdout } = await execFileAsync(command, args, { cwd: options.cwd, encoding: 'utf-8' });
+    return stdout;
+};
+/** Best-effort `git diff --name-only <mergeBase>...HEAD`; never throws. */
+async function computeChangedFilesFromGit(projectPath, exec, baseBranch) {
+    try {
+        const mergeBaseOut = await exec('git', ['merge-base', 'HEAD', baseBranch], {
+            cwd: projectPath,
+        });
+        const mergeBase = mergeBaseOut.trim();
+        if (!mergeBase) {
+            return [];
+        }
+        const diffOut = await exec('git', ['diff', '--name-only', `${mergeBase}...HEAD`], {
+            cwd: projectPath,
+        });
+        return diffOut
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch (error) {
+        /* reliability-optional: EVIDENCE_AUTOFILL_GIT_DIFF — falls back to ## Files ownership */
+        reportClassifiedDegradation('EVIDENCE_AUTOFILL_GIT_DIFF', error);
+        return [];
+    }
+}
+function filterExistingRepoFiles(projectPath, paths) {
+    return paths.filter((path) => {
+        if (isAbsolute(path)) {
+            return false;
+        }
+        try {
+            return existsSync(resolve(projectPath, path));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Best-effort read + sha256 summary of the persisted validation report, for prose evidence. */
+async function readValidationReportSummary(projectId, specId) {
+    const reportPath = join(projectDataDir(projectId), 'handoffs', specId, 'validation-report.json');
+    try {
+        const raw = await readFile(reportPath, 'utf-8');
+        const parsed = ValidationReportV1Schema.safeParse(JSON.parse(raw));
+        if (!parsed.success) {
+            return {};
+        }
+        const { score, reviewer } = parsed.data;
+        return {
+            validationEvidence: `Validated by handoffs/${specId}/validation-report.json (score=${score ?? 'n/a'}).`,
+            reviewerEvidence: `Reviewed by ${reviewer.agent} (${reviewer.kind}), verdict=${reviewer.verdict}.`,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Generate `traceability-matrix.json` in the handoff evidence store when it does
+ * not already exist. Never overwrites an existing file — if one is present this
+ * is a no-op that reports `already-exists`. Tolerates every failure by returning
+ * a typed non-throwing result; callers must never let this crash a lifecycle
+ * transition.
+ */
+export async function autofillTraceabilityMatrix(args) {
+    const targetPath = handoffEvidencePath(args.projectId, args.specId, 'traceability-matrix.json');
+    try {
+        if (existsSync(targetPath)) {
+            return { written: false, reason: 'already-exists' };
+        }
+        const criteria = extractAcceptanceCriteriaTexts(args.specBody);
+        if (criteria.length === 0) {
+            return { written: false, reason: 'no-criteria' };
+        }
+        const scenarios = parseFrontmatterScenarios(args.specBody);
+        const exec = args.exec ?? defaultExec;
+        const baseBranch = args.baseBranch ?? 'main';
+        const gitChangedFiles = args.projectPath
+            ? await computeChangedFilesFromGit(args.projectPath, exec, baseBranch)
+            : [];
+        const ownership = extractCanonicalFileOwnership(args.specBody);
+        const ownershipFiles = [...ownership.toCreate, ...ownership.toModify, ...ownership.toTest];
+        const rawChangedFiles = gitChangedFiles.length > 0 ? gitChangedFiles : ownershipFiles;
+        const changedFiles = args.projectPath
+            ? filterExistingRepoFiles(args.projectPath, rawChangedFiles)
+            : rawChangedFiles;
+        const { validationEvidence, reviewerEvidence } = await readValidationReportSummary(args.projectId, args.specId);
+        const rows = criteria.map((acceptanceCriterion, index) => {
+            const testPaths = scenarios[index]?.tests?.map((test) => test.path) ?? [];
+            return {
+                acceptanceCriterion,
+                ...(testPaths.length > 0 ? { testEvidence: testPaths } : {}),
+                changedFiles,
+                ...(validationEvidence ? { validationEvidence } : {}),
+                ...(reviewerEvidence ? { reviewerEvidence } : {}),
+            };
+        });
+        const payload = { version: 1, rows };
+        await atomicWriteFile(targetPath, JSON.stringify(payload, null, 2));
+        return { written: true, path: targetPath, rowCount: rows.length };
+    }
+    catch (error) {
+        /* reliability-optional: EVIDENCE_AUTOFILL_WRITE — caller proceeds without autofill */
+        reportClassifiedDegradation('EVIDENCE_AUTOFILL_WRITE', error);
+        return {
+            written: false,
+            reason: 'write-failed',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=evidence-autofill.js.map

package/dist/engine/evidence-gates/evidence-skeletons.d.ts

@@ -0,0 +1,19 @@
+import type { Spec } from '../../types/spec/core.js';
+import type { DiscoveryEvidence, TaskPlanEvidence } from '../../types/evidence-gates.js';
+/** Build a strict-schema discovery.json skeleton grounded in the spec's own grounding metadata. */
+export declare function generateDiscoverySkeleton(args: {
+    spec: Spec;
+    body: string | null;
+}): DiscoveryEvidence;
+/** Build a strict-schema task-plan.json skeleton with one pending task per canonical criterion. */
+export declare function generateTaskPlanSkeleton(args: {
+    criteria: string[];
+}): TaskPlanEvidence;
+/** Persist an auto-generated evidence skeleton to the external handoff store. */
+export declare function writeEvidenceSkeleton(args: {
+    projectId: string;
+    specId: string;
+    filename: string;
+    artifact: DiscoveryEvidence | TaskPlanEvidence;
+}): Promise<string>;
+//# sourceMappingURL=evidence-skeletons.d.ts.map