@planu/cli 5.0.0 → 5.1.1

package/dist/tools/update-status/index.js

@@ -15,8 +15,9 @@ import { checkApprovalGate } from '../../engine/approval-workflow.js';
 import * as approvalStore from '../../storage/approval-store.js';
 import { withApprovalSpecLock } from '../../storage/approval-operation-lock.js';
 import { isLocked, getLock } from '../../storage/spec-lock-store.js';
-import { checkDoneGates, checkComplianceGate, checkApprovedFormatGate, checkSpecReviewGate, writeSpecReviewArtifact, } from './dod-gates.js';
+import { checkDoneGates, checkComplianceGate, checkApprovedFormatGate, checkSpecReviewGate, writeSpecReviewArtifact, deriveDoneReviewDigest, } from './dod-gates.js';
 import { checkLifecycleEvidenceTransitionGate } from './evidence-gate.js';
+import { autofillTraceabilityMatrix } from '../../engine/evidence-gates/evidence-autofill.js';
 import { buildStatusResponse, buildDryRunResponse } from './response-builder.js';
 import { recordDoneMetrics, syncSpecFiles, tryReconcile, recordTerminalTransitionEvent, } from './file-sync.js';
 import { appendEntry, getLastHash } from '../../storage/audit-trail-store.js';
@@ -27,7 +28,8 @@ import { recordForceUsage } from '../../storage/force-analytics-store.js';
 import { maybeSafePushOnDone, queuePostCommitTasks, runCascadeForResponse, } from './side-effects.js';
 import { formatKeyValue } from '../output-formatter.js';
 import { checkCodeReality } from '../../engine/code-scanner/index.js';
-import { join, resolve } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
+import { readSpecContent } from '../../engine/spec-reader.js';
 import { trackCost } from '../../engine/cost-tracking/operation-tracker.js';
 import { resolveProjectIdOrAutoDetect } from '../resolve-project-id.js';
 import { withToolTimeout } from '../safe-handler.js';
@@ -40,6 +42,77 @@ import { assertExecutionCanCommit } from '../../engine/execution/context.js';
 import { shouldSkipGateForExplicitLegacyHarness } from './gate-harness.js';
 import { assertValidationFreshnessBarrier, closeValidationFreshnessLease, } from '../../engine/validation/validation-freshness.js';
 import { currentReconciliationInvocationContext, reconcileImplementingSpec, } from '../../engine/lifecycle-reconciliation.js';
+const IMPLEMENTATION_REVIEW_DIGEST = /^sha256:[a-f0-9]{64}$/u;
+function lifecycleAuthorityError(code, message, fixHint) {
+    return {
+        content: [{ type: 'text', text: `${code}: ${message}\nFix: ${fixHint}` }],
+        isError: true,
+        structuredContent: { error: code, code: 422, fixHint },
+    };
+}
+/** Select the lifecycle path before any transition, artifact, receipt, or log mutation. */
+export function classifyLifecycleAuthority(input, context, options = {}) {
+    const hasRequestId = input.reconciliationRequestId !== undefined;
+    const hasTransitionId = input.expectedImplementingTransitionId !== undefined;
+    const hasDigest = input.implementationReviewDigest !== undefined;
+    const hasAnyAuthority = hasRequestId || hasTransitionId || hasDigest;
+    if (input.status === 'done') {
+        if (hasRequestId || hasTransitionId) {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('RECONCILIATION_TARGET_INVALID', 'Reconciliation authority is valid only for the review target.', 'Remove reconciliationRequestId and expectedImplementingTransitionId from the done request.'),
+            };
+        }
+        // SPEC-1356: implementationReviewDigest is optional. When the caller omits it,
+        // the done gate (checkDoneGates via dod-gates.deriveDoneReviewDigest) derives
+        // it automatically from the persisted validation-report.json — the caller no
+        // longer has to compute the sha256 by hand. `options.requireDoneDigest` is
+        // retained only so legacy/explicit-authority callers can still demand it.
+        if (options.requireDoneDigest === true && !hasDigest) {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('DONE_REVIEW_DIGEST_REQUIRED', 'A done transition requires the implementation review digest.', 'Supply the sha256 digest of the exact persisted validation-report.json bytes.'),
+            };
+        }
+        if (hasDigest &&
+            (typeof input.implementationReviewDigest !== 'string' ||
+                !IMPLEMENTATION_REVIEW_DIGEST.test(input.implementationReviewDigest))) {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('DONE_REVIEW_DIGEST_INVALID', 'The implementation review digest must be sha256 followed by 64 lowercase hex characters.', 'Recompute the digest from the exact persisted validation-report.json bytes.'),
+            };
+        }
+        return { route: 'ordinary' };
+    }
+    if (input.status === 'review' && hasAnyAuthority) {
+        if (!hasRequestId || !hasTransitionId || !hasDigest) {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('RECONCILIATION_TUPLE_INCOMPLETE', 'Review reconciliation requires the complete authority tuple.', 'Supply reconciliationRequestId, expectedImplementingTransitionId, implementationReviewDigest, and a reason of at least 100 characters.'),
+            };
+        }
+        if (!input.reason || input.reason.trim().length < 100) {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('RECONCILIATION_REASON_INVALID', 'Review reconciliation requires a non-blank reason of at least 100 characters.', 'Explain the reviewed implementation drift and required follow-up in at least 100 characters.'),
+            };
+        }
+        if (context.surface !== 'local-mcp') {
+            return {
+                route: 'error',
+                result: lifecycleAuthorityError('RECONCILIATION_UNTRUSTED_SURFACE', 'Reconciliation is available only through trusted local MCP.', 'Retry the complete reconciliation request through the registered local MCP tool.'),
+            };
+        }
+        return { route: 'reconcile' };
+    }
+    if (hasAnyAuthority) {
+        return {
+            route: 'error',
+            result: lifecycleAuthorityError('RECONCILIATION_TARGET_INVALID', 'Lifecycle authority fields are invalid for this target.', 'Remove the authority fields or use implementationReviewDigest only with done.'),
+        };
+    }
+    return { route: 'ordinary' };
+}
 /**
  * SPEC-280: Silently traverse intermediate states so callers can jump forward
  * (e.g. draft → approved) without receiving an error.
@@ -52,6 +125,58 @@ function buildAutoAdvancePlan(currentStatus, targetStatus) {
         stepsExecuted,
     };
 }
+/**
+ * SPEC-1356 (T-A3): auto-generate traceability-matrix.json when it is missing,
+ * BEFORE the evidence gate reads it for a 'done' transition. Never overwrites an
+ * existing artifact. Tolerates every internal failure (falls through to the
+ * ordinary evidence gate, which will report the real missing-evidence error).
+ *
+ * When autofill actually writes a fresh file, the newly-created evidence has not
+ * been bound by validate's durable receipt yet, so this blocks once with a clear
+ * "re-run validate" message instead of letting a stale-relative-to-receipt
+ * traceability matrix slide through the done gates silently.
+ */
+async function runTraceabilityAutofillGate(args) {
+    try {
+        const specPath = isAbsolute(args.spec.specPath) || !args.projectPath
+            ? args.spec.specPath
+            : join(args.projectPath, args.spec.specPath);
+        const specBody = await readSpecContent(specPath);
+        if (specBody === null) {
+            return null;
+        }
+        const result = await autofillTraceabilityMatrix({
+            projectId: args.projectId,
+            specId: args.specId,
+            projectPath: args.projectPath,
+            specBody,
+        });
+        if (!result.written) {
+            return null;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `traceability-matrix.json was auto-generated at ${result.path} (${String(result.rowCount)} rows). ` +
+                        'Run validate to bind this evidence, then retry update_status(done).',
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'traceability_matrix_autofilled',
+                code: 422,
+                context: { specId: args.specId, path: result.path, rowCount: result.rowCount },
+                fixHint: 'Run validate so the new traceability-matrix.json is bound, then retry done.',
+            },
+        };
+    }
+    catch (error) {
+        // reliability-optional: EVIDENCE_AUTOFILL_GATE — falls through to the ordinary evidence gate
+        reportClassifiedDegradation('EVIDENCE_AUTOFILL_GATE', error);
+        return null;
+    }
+}
 /**
  * SPEC-301: Check if spec is locked by another agent.
  * Returns an error ToolResult if locked, or null to continue.
@@ -101,6 +226,27 @@ async function checkApprovalPolicyGate(projectId, specId, newStatus) {
     }
     return null;
 }
+/**
+ * SPEC-1356 (T-A2): a `done` transition no longer requires the caller to supply
+ * actuals. When the whole object is omitted, synthesize a minimal record instead
+ * of blocking the transition with `actuals_required`. Every caller-provided
+ * field — including a caller-provided partial object once the MCP input schema
+ * accepts one — is preserved verbatim; only genuinely unmeasured numeric fields
+ * default to 0, and `completedAt`/`notes` only default when absent.
+ */
+export function synthesizeActuals(actuals, transitionedAt) {
+    return {
+        devHours: actuals?.devHours ?? 0,
+        reviewHours: actuals?.reviewHours ?? 0,
+        tokensOpus: actuals?.tokensOpus ?? 0,
+        tokensSonnet: actuals?.tokensSonnet ?? 0,
+        apiCostUsd: actuals?.apiCostUsd ?? 0,
+        humanCostUsd: actuals?.humanCostUsd ?? 0,
+        totalCostUsd: actuals?.totalCostUsd ?? 0,
+        completedAt: actuals?.completedAt ?? transitionedAt,
+        notes: actuals?.notes ?? 'actuals unavailable — auto-filled by done gate',
+    };
+}
 /** Compute done metrics when transitioning to 'done' with actuals provided. */
 function computeDoneMetrics(newStatus, spec, actuals) {
     if (newStatus !== 'done' || actuals === undefined || spec === null) {
@@ -605,6 +751,13 @@ async function resolveOrchestrationPlan(newStatus, specScope, specId, projectPat
 export async function handleUpdateStatus(params, server) {
     return trackCost(params.projectPath?.trim() ?? '', 'update_status', async () => {
         const { specId, status: newStatus, actuals, reviewNotes } = params;
+        // SPEC-1356: implementationReviewDigest is derived automatically by the done
+        // gate when omitted (see dod-gates.deriveDoneReviewDigest), so it is never
+        // required here.
+        const authorityRoute = classifyLifecycleAuthority(params, currentReconciliationInvocationContext());
+        if (authorityRoute.route === 'error') {
+            return authorityRoute.result;
+        }
         // SPEC-509: auto-detect project from git root when projectPath/projectId are omitted
         const resolved = await resolveProjectIdOrAutoDetect({
             projectId: params.projectId,
@@ -619,9 +772,7 @@ export async function handleUpdateStatus(params, server) {
         const transitionProjectPath = (params.projectPath?.trim()
             ? effectiveProjectPath
             : (knowledge?.projectPath ?? effectiveProjectPath)) || undefined;
-        if (params.reconciliationRequestId ||
-            params.expectedImplementingTransitionId ||
-            params.implementationReviewDigest) {
+        if (authorityRoute.route === 'reconcile') {
             return reconcileImplementingSpec({
                 input: params,
                 projectId,
@@ -693,22 +844,9 @@ export async function handleUpdateStatus(params, server) {
                             return idempotentResult;
                         }
                     }
-                    if (newStatus === 'done' && actuals === undefined) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: 'actuals_required: provide measured values for done. Use zero only when a metric is explicitly unavailable; Planu does not estimate provider tokens or costs.',
-                                },
-                            ],
-                            isError: true,
-                            structuredContent: {
-                                error: 'actuals_required',
-                                code: 422,
-                                fixHint: 'Provide actuals with measured values or zero for unavailable metrics. Values are preserved without estimation.',
-                            },
-                        };
-                    }
+                    // SPEC-1356 (T-A2): actuals are no longer required to reach done. When
+                    // omitted, synthesizeActuals() below fills in a defaulted record instead
+                    // of blocking the transition — see synthesizeActuals doc comment.
                     // SPEC-280/SPEC-1122: plan every intermediate state in memory. No status is
                     // persisted until all gates for the complete path have passed.
                     const { plannedStatuses, stepsExecuted } = buildAutoAdvancePlan(spec.status, newStatus);
@@ -849,6 +987,26 @@ export async function handleUpdateStatus(params, server) {
                             sddRoutingGate.gateResults.sddModelRouting = 'forced';
                         }
                     }
+                    // SPEC-1356 (T-A3): auto-generate traceability-matrix.json before the
+                    // evidence gate below reads it, so a spec never fails 'done' purely
+                    // because nobody hand-wrote the traceability artifact. Never overwrites
+                    // an existing file. Freshness caveat: when autofill actually writes a
+                    // new file, its evidence has not yet been bound by validate's durable
+                    // receipt, so we block once and ask the caller to re-run validate
+                    // rather than risk certifying stale bindings. See evidence-autofill.ts
+                    // for the full rationale.
+                    if (plannedStatuses.includes('done') &&
+                        !shouldSkipGateForExplicitLegacyHarness('evidence')) {
+                        const autofillGate = await runTraceabilityAutofillGate({
+                            spec,
+                            specId,
+                            projectId,
+                            projectPath: effectiveGatePath,
+                        });
+                        if (autofillGate) {
+                            return autofillGate;
+                        }
+                    }
                     // SPEC-1054: BDD/SDD evidence gates. Non-trivial specs must carry
                     // Discovery before approval, task-plan before implementation, and
                     // traceability/contract evidence before done.
@@ -867,6 +1025,21 @@ export async function handleUpdateStatus(params, server) {
                             }
                         }
                     }
+                    // SPEC-1356 (T-A1): implementationReviewDigest is optional. When the
+                    // caller omits it, derive it automatically from the persisted
+                    // validation-report.json instead of requiring the caller to hand-compute
+                    // a sha256. Failure to derive it fails closed with a clear "run validate
+                    // first" message — identical strength to the explicit-digest path.
+                    let resolvedImplementationReviewDigest = params.implementationReviewDigest;
+                    if (newStatus === 'done' &&
+                        resolvedImplementationReviewDigest === undefined &&
+                        !shouldSkipGateForExplicitLegacyHarness('evidence')) {
+                        const derived = await deriveDoneReviewDigest(specId, projectId);
+                        if ('error' in derived) {
+                            return derived.error;
+                        }
+                        resolvedImplementationReviewDigest = derived.digest;
+                    }
                     // ---------------------------------------------------------------------------
                     // BATCH A (parallel): code-reality + done-gates — independent of each other
                     // SPEC-441: Code reality check before transitioning to 'implementing'
@@ -887,7 +1060,7 @@ export async function handleUpdateStatus(params, server) {
                             : Promise.resolve(null),
                         // Done gates: only relevant for 'done'
                         newStatus === 'done' && !shouldSkipGateForExplicitLegacyHarness('evidence')
-                            ? checkDoneGates(spec, specId, projectId, effectiveGatePath, params.force, params.forceStatusReason ?? params.reason ?? 'No force reason provided')
+                            ? checkDoneGates(spec, specId, projectId, effectiveGatePath, params.force, params.forceStatusReason ?? params.reason ?? 'No force reason provided', undefined, resolvedImplementationReviewDigest)
                             : Promise.resolve(null),
                     ]);
                     // Process code reality result
@@ -969,8 +1142,12 @@ export async function handleUpdateStatus(params, server) {
                             return specReviewWriteError;
                         }
                     }
-                    // Explicit actuals are preserved verbatim. Provider usage and cost are never inferred.
-                    const resolvedActuals = actuals;
+                    // Explicit actuals are preserved verbatim. Provider usage and cost are
+                    // never inferred — synthesizeActuals only fills gaps the caller left
+                    // unmeasured (SPEC-1356 T-A2).
+                    const resolvedActuals = newStatus === 'done' || actuals !== undefined
+                        ? synthesizeActuals(actuals, new Date().toISOString())
+                        : undefined;
                     // Run only fast, read-only transition checks before persistence.
                     const implActions = newStatus === 'implementing'
                         ? await runImplementingActions(projectId, specId, {

package/dist/tools/update-status/transition-guard.js

@@ -255,7 +255,19 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
     catch (error) {
         /* reliability-optional: READINESS_SPEC_UNREADABLE — transition fails closed below */
         reportClassifiedDegradation('READINESS_SPEC_UNREADABLE', error);
-        return readinessUnavailable('READINESS_SPEC_UNREADABLE', error instanceof Error ? error.message : 'spec.md could not be read');
+        // SPEC-1351 (AC4): a missing spec.md (ENOENT) is a distinct, recoverable
+        // situation — surface an actionable message instead of the raw fs error
+        // ("ENOENT: no such file or directory, open '<path>'") that update_status
+        // was previously appending "Transition blocked..." to verbatim.
+        const isMissingFile = typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT';
+        return readinessUnavailable('READINESS_SPEC_UNREADABLE', isMissingFile
+            ? `spec.md is missing at ${spec.specPath}. Recreate the spec via create_spec or restore spec.md from git/backup before retrying this transition.`
+            : error instanceof Error
+                ? error.message
+                : 'spec.md could not be read');
     }
     // Guard: mock environments return undefined; unreadable files return non-string
     if (typeof body !== 'string') {

package/dist/tools/workspace-dashboard-handler.js

@@ -11,6 +11,22 @@ import { verifyStateFiles } from '../engine/cascade-hooks/state-drift-detector.j
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getAsyncAnalysisPath } from './create-spec/post-creation.js';
+import { readTransitionLog } from '../storage/transition-log.js';
+/** SPEC-1351 (AC3): collect ghost-spec quarantine events for a project. */
+async function collectGhostAlerts(projectId) {
+    try {
+        const entries = await readTransitionLog(projectId);
+        return entries
+            .filter((entry) => entry.eventType === 'ghost_spec_quarantined')
+            .map((entry) => ({
+            specId: entry.specId,
+            reason: entry.reason ?? `Spec ${entry.specId}: spec.md missing on disk.`,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 export async function handleWorkspaceOverview(args) {
     const result = await buildWorkspaceOverview(args.healthThreshold);
     if (result.projectCount === 0) {
@@ -188,6 +204,8 @@ export async function handleWorkspaceAlerts(args) {
     const autopilotFailures = [];
     // SPEC-781: collect pending analysis alerts across all projects
     const pendingAnalysisAlerts = [];
+    // SPEC-1351 (AC3): collect quarantined ghost-spec alerts across all projects
+    const ghostAlerts = [];
     await Promise.all(projects.map(async (project) => {
         try {
             const projectId = hashProjectPath(project.path);
@@ -217,9 +235,21 @@ export async function handleWorkspaceAlerts(args) {
         catch {
             // best-effort
         }
+        // SPEC-1351: check for quarantined ghost specs in this project
+        try {
+            const projectId = hashProjectPath(project.path);
+            const ghosts = await collectGhostAlerts(projectId);
+            for (const g of ghosts) {
+                ghostAlerts.push({ projectPath: project.path, ...g });
+            }
+        }
+        catch {
+            // best-effort
+        }
     }));
     if (alerts.length === 0 &&
         autopilotFailures.length === 0 &&
+        ghostAlerts.length === 0 &&
         driftAlerts.length === 0 &&
         pendingAnalysisAlerts.length === 0) {
         return {
@@ -248,6 +278,14 @@ export async function handleWorkspaceAlerts(args) {
             lines.push(`| ${shortPath} | ${f.specId} | ${f.hookName} | ${f.error} | ${shortTime} |`);
         }
     }
+    // SPEC-1351: quarantined ghost-spec alerts
+    if (ghostAlerts.length > 0) {
+        lines.push(``, `## Quarantined Ghost Specs (spec.md missing on disk)`, ``, `| Project | Spec ID | Recovery Action |`, `|---|---|---|`);
+        for (const g of ghostAlerts) {
+            const shortPath = g.projectPath.split('/').slice(-2).join('/');
+            lines.push(`| ${shortPath} | ${g.specId} | ${g.reason} |`);
+        }
+    }
     // SPEC-776: state drift alerts
     if (driftAlerts.length > 0) {
         lines.push(``, `## State File Drift`, ``, `| Project | Alert | Fix |`, `|---|---|---|`);

package/dist/types/evidence-autofill.d.ts

@@ -0,0 +1,34 @@
+import type { Actuals } from './estimation.js';
+/**
+ * Caller-supplied actuals on a `done` transition. Every field is optional:
+ * missing numeric fields are treated as "not measured" and defaulted to 0 by
+ * the done gate; `completedAt`/`notes` default when the whole object is
+ * absent. Any field the caller does supply is always stored verbatim.
+ */
+export type ActualsInput = Partial<Actuals>;
+/** Injectable process runner so tests never shell out to real git. */
+export type EvidenceAutofillExec = (command: string, args: string[], options: {
+    cwd: string;
+}) => Promise<string>;
+export interface AutofillTraceabilityMatrixArgs {
+    projectId: string;
+    specId: string;
+    /** Absolute path to the project working copy; used for `git diff` and file existence checks. */
+    projectPath?: string;
+    /** Raw spec.md content (frontmatter + body) used to derive criteria, scenarios, and `## Files`. */
+    specBody: string;
+    /** Overrides the default `execFile`-based git runner. */
+    exec?: EvidenceAutofillExec;
+    /** Branch to diff against for changed-files detection. Defaults to `main`. */
+    baseBranch?: string;
+}
+export type AutofillTraceabilityMatrixResult = {
+    written: true;
+    path: string;
+    rowCount: number;
+} | {
+    written: false;
+    reason: 'already-exists' | 'no-criteria' | 'write-failed';
+    error?: string;
+};
+//# sourceMappingURL=evidence-autofill.d.ts.map

package/dist/types/evidence-autofill.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evidence-autofill.js.map

package/dist/types/index.d.ts

@@ -30,6 +30,7 @@ export * from './privacy.js';
 export * from './events.js';
 export * from './evidence-gates.js';
 export * from './evidence-index.js';
+export * from './evidence-autofill.js';
 export * from './analytics.js';
 export * from './sdd-flow.js';
 export * from './sdd-model-routing.js';

package/dist/types/index.js

@@ -31,6 +31,7 @@ export * from './privacy.js';
 export * from './events.js';
 export * from './evidence-gates.js';
 export * from './evidence-index.js';
+export * from './evidence-autofill.js';
 export * from './analytics.js';
 export * from './sdd-flow.js';
 export * from './sdd-model-routing.js';

package/dist/types/spec/core.d.ts

@@ -415,5 +415,11 @@ export interface SyncReport {
         specId: string;
         reason: string;
     }[];
+    /** SPEC-1351: Store entries whose spec.md is missing on disk, quarantined during this sync. */
+    ghosts?: {
+        specId: string;
+        specPath: string;
+        reason: string;
+    }[];
 }
 //# sourceMappingURL=core.d.ts.map

package/dist/types/spec/inputs.d.ts

@@ -70,7 +70,8 @@ export interface UpdateStatusInput {
     arbitratedBy?: string;
     /** True when implementation drift requires reconcile_spec before done. */
     reconcileRequired?: boolean;
-    actuals?: Actuals;
+    /** SPEC-1356: all fields optional — missing values are auto-filled by the done gate. */
+    actuals?: Partial<Actuals>;
     autoCreateBranch?: boolean;
     reviewNotes?: string;
     force?: boolean;
@@ -96,7 +97,11 @@ export interface UpdateStatusInput {
     reconciliationRequestId?: string;
     /** Latest canonical implementing transition receipt expected by reconciliation. */
     expectedImplementingTransitionId?: string;
-    /** SHA-256 digest of the independent changes-requested validation report. */
+    /**
+     * SHA-256 of the exact validation-report.json bytes. Required as approved
+     * implementation evidence for done; for review it belongs only to the complete
+     * trusted local-MCP reconciliation tuple.
+     */
     implementationReviewDigest?: string;
     /**
      * SPEC-769: Force-approve a spec that scored below 70 on the readiness gate.

package/dist/types/spec-format.d.ts

@@ -90,7 +90,7 @@ export interface StrictPlanuValidationOptions {
 }
 export interface UpdateStatusBatchInput {
     specIds: string[];
-    status: SpecStatus;
+    status: Exclude<SpecStatus, 'done'>;
     projectId?: string;
     projectPath?: string;
     dryRun?: boolean;

package/dist/types/transition-log.d.ts

@@ -1,5 +1,5 @@
 /** Event types recorded in the transition log. */
-export type TransitionEventType = 'transitioned_to_terminal' | 'frontmatter_resealed' | 'reopen' | 'terminal_drift_detected' | 'transition' | 'handoff.intake' | 'handoff.spec.lock' | 'handoff.review_feedback' | 'handoff.implementation-report' | 'handoff.validation-report' | 'retro_audit' | 'tdd_red_locked' | 'tdd_green_achieved' | 'status_reconciled' | 'housekeeping';
+export type TransitionEventType = 'transitioned_to_terminal' | 'frontmatter_resealed' | 'reopen' | 'terminal_drift_detected' | 'transition' | 'handoff.intake' | 'handoff.spec.lock' | 'handoff.review_feedback' | 'handoff.implementation-report' | 'handoff.validation-report' | 'retro_audit' | 'tdd_red_locked' | 'tdd_green_achieved' | 'status_reconciled' | 'housekeeping' | 'ghost_spec_quarantined';
 /** SPEC-734: Outcome of a gate execution in a transition. */
 export type GateOutcome = 'pass' | 'fail' | 'skip' | 'forced';
 /** SPEC-734: Result of verifying the hash chain integrity of a project's transition log. */

package/dist/types/validation.d.ts

@@ -1,3 +1,5 @@
+import type { ReadinessReport } from './readiness.js';
+import type { SpecQualityReport } from './spec-quality.js';
 /**
  * Origin validator that produced the issue.
  */
@@ -31,11 +33,15 @@ export interface SpecValidationResult {
     /** Optional summary metrics for callers that want them without re-running scorers. */
     metrics?: {
         readinessScore: number;
-        qualityScore: number;
-        qualityGrade: 'A' | 'B' | 'C' | 'D' | 'F';
+        qualityScore?: number;
+        qualityGrade?: 'A' | 'B' | 'C' | 'D' | 'F';
         bddScenarioCount: number;
         criteriaCount: number;
     };
+    /** Readiness evidence generated during this validation invocation. */
+    readinessReport?: ReadinessReport;
+    /** Quality evidence generated during this validation invocation, when available. */
+    qualityReport?: SpecQualityReport;
 }
 /**
  * Options for validateSpecFormat().

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -35,14 +35,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "5.0.0",
-    "@planu/core-darwin-x64": "5.0.0",
-    "@planu/core-linux-arm64-gnu": "5.0.0",
-    "@planu/core-linux-arm64-musl": "5.0.0",
-    "@planu/core-linux-x64-gnu": "5.0.0",
-    "@planu/core-linux-x64-musl": "5.0.0",
-    "@planu/core-win32-arm64-msvc": "5.0.0",
-    "@planu/core-win32-x64-msvc": "5.0.0"
+    "@planu/core-darwin-arm64": "5.1.1",
+    "@planu/core-darwin-x64": "5.1.1",
+    "@planu/core-linux-arm64-gnu": "5.1.1",
+    "@planu/core-linux-arm64-musl": "5.1.1",
+    "@planu/core-linux-x64-gnu": "5.1.1",
+    "@planu/core-linux-x64-musl": "5.1.1",
+    "@planu/core-win32-arm64-msvc": "5.1.1",
+    "@planu/core-win32-x64-msvc": "5.1.1"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -77,6 +77,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --testTimeout=60000 --maxWorkers=4",
+    "test:release-gate": "vitest run --exclude 'tests/integration/**'",
     "test:integration": "vitest run tests/integration",
     "test:website:unit": "vitest run tests/website tests/scripts/generate-website-proof.test.ts tests/scripts/website-tool-counts.test.ts",
     "test:website:browser": "playwright test --config playwright.website.config.ts",
@@ -117,7 +118,7 @@
     "prepublishOnly": "bash scripts/prepublish-guard.sh",
     "prepack": "pnpm build:ts && pnpm package:size",
     "test:debug": "vitest run --inspect-brk --single-thread",
-    "validate": "pnpm build && pnpm typecheck && pnpm verify:typescript-migration && pnpm lint && pnpm format:check && pnpm test",
+    "validate": "pnpm build && pnpm typecheck && pnpm verify:typescript-migration && pnpm lint && pnpm format:check && pnpm test:release-gate",
     "docker:build": "docker build -t planu .",
     "docker:run": "docker compose up",
     "publish:blog": "node scripts/publish-blog.mjs",

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "icon": "assets/plugin/icon.svg",
   "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",