@unbrained/pm-cli 2026.9.5 → 2026.9.6

package/dist/sdk/governance/health.js

@@ -4,7 +4,7 @@
  * Implements the pm health command surface and its agent-facing runtime behavior.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9f0077a4-4f0a-540f-9951-2e8a640629c9")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cee8abad-51d2-5051-9cb8-81447bf2fd50")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { assertInitializedTracker } from "../environment/tracker-preflight.js";
@@ -1056,10 +1056,12 @@ function summarizeHealthCheckDetails(check, limit) {
     return summarize ? summarize(check.details, limit) : check.details;
 }
 /* c8 ignore stop */
+/** Bound diagnostic detail and warnings while retaining every blocking cause and the authoritative verdict. */
 function applyBriefHealthProjection(result) {
     const warningsSummary = summarizeStringList(result.warnings, BRIEF_HEALTH_DETAIL_LIMIT);
     return {
         ok: result.ok,
+        ...(result.verdict ? { verdict: result.verdict } : {}),
         checks: result.checks.map((check) => ({
             name: check.name,
             status: check.status,
@@ -1082,6 +1084,7 @@ function applyBriefHealthProjection(result) {
 function isSkippedHealthCheck(check) {
     return check.details.skipped === true;
 }
+/** Emit verdicts for checks that ran, retain blocking causes, and name omitted checks for recovery. */
 function applySummaryHealthProjection(result) {
     const warningsSummary = summarizeStringList(result.warnings, BRIEF_HEALTH_DETAIL_LIMIT);
     const omittedChecks = result.checks
@@ -1089,6 +1092,7 @@ function applySummaryHealthProjection(result) {
         .map((check) => check.name);
     return {
         ok: result.ok,
+        ...(result.verdict ? { verdict: result.verdict } : {}),
         checks: result.checks
             .filter((check) => !isSkippedHealthCheck(check))
             .map((check) => ({
@@ -1974,6 +1978,7 @@ function extractHistoryDriftedCount(historyDriftCheck) {
     const counts = historyDriftCheck.check.details.counts;
     return typeof counts?.drifted === "number" ? counts.drifted : 0;
 }
+/** Associate warning producers with their owning checks so findings inherit the correct remediation and severity. */
 function buildHealthRemediationSources(params) {
     return {
         settings: params.normalizedSettingsReadWarnings,
@@ -1985,7 +1990,7 @@ function buildHealthRemediationSources(params) {
         extensions: params.extensionCheck.warnings,
         storage: [
             ...params.historyPolicyWarnings,
-            ...params.historySummary.over_threshold.map((id) => `history_stream_over_compact_threshold:${id}`),
+            ...params.historySummary.warnings,
             ...params.authorAttributionWarnings,
             ...params.staleInProgressWarnings,
             ...params.provenanceWarnings,
@@ -2064,6 +2069,7 @@ function attachHealthRemediationMaps(params) {
         }
     }
 }
+/** Attribute drift to merge receipts only when read-only history repair proves their exact current snapshot. */
 async function correlateMergeReceiptHistoryDriftItems(params) {
     if (params.gitWorkspaceRoot === null ||
         params.pendingMergeReceipts.length === 0) {
@@ -2094,15 +2100,15 @@ async function correlateMergeReceiptHistoryDriftItems(params) {
         if (!receipts || receipts.length === 0)
             continue;
         try {
-            const repair = await runHistoryRepair(id, {
+            await runHistoryRepair(id, {
                 dryRun: true,
                 mergeReceiptProof: {
                     gitWorkspaceRoot: params.gitWorkspaceRoot,
                     receipts,
                 },
             }, params.global);
-            if (repair.merge_receipt_proof?.trusted)
-                attributed.push(id);
+            // An unforced proof-bearing preview rejects untrusted evidence before returning.
+            attributed.push(id);
         }
         catch {
             // Fail closed: generic history-repair guidance remains authoritative.
@@ -2168,6 +2174,8 @@ export async function runHealth(global, options = {}) {
     const normalizedSettingsReadWarnings = [...new Set(settingsReadWarnings)];
     const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
     const strictDirectories = options.strictDirectories === true;
+    const strictExit = options.strictExit === true || options.failOnWarn === true;
+    const requireMergeDrivers = options.requireMergeDrivers === true || strictExit;
     const refreshPolicy = resolveVectorRefreshPolicy(options);
     const directoryState = await scanHealthDirectories(pmRoot, typeRegistry, strictDirectories);
     const settingsValueWarnings = validateSettingsValues(settings);
@@ -2213,13 +2221,13 @@ export async function runHealth(global, options = {}) {
     const provenanceInvalidValues = provenanceResolverHealth.invalid_values;
     const provenanceWarnings = provenanceResolverHealth.warnings;
     const locksCheck = await buildLocksCheck(pmRoot);
-    const integrityCheck = skipPolicy.skipIntegrity
+    const integrityCheck = skipPolicy.skipIntegrity && !requireMergeDrivers
         ? {
             ...buildSkippedHealthCheck("integrity"),
             gitWorkspaceRoot: null,
             pendingMergeReceipts: [],
         }
-        : await buildIntegrityCheck(pmRoot, typeRegistry.type_to_folder, settings.schema, options.requireMergeDrivers === true, items);
+        : await buildIntegrityCheck(pmRoot, typeRegistry.type_to_folder, settings.schema, requireMergeDrivers, items);
     const historyDriftCheck = skipPolicy.skipDrift
         ? buildSkippedHealthCheck("history_drift")
         : await buildHistoryDriftCheck({
@@ -2296,15 +2304,28 @@ export async function runHealth(global, options = {}) {
     // state (queue backlog, unreachable endpoint, corrupt local state) is advisory:
     // it must never flip overall project health to not-ok. Such warnings are still
     // surfaced in `warnings` and the telemetry check's own `warn` status.
-    const blockingWarnings = normalizedWarnings.filter((warning) => !isAdvisoryHealthWarning(warning, options.requireMergeDrivers === true));
+    const blockingWarnings = normalizedWarnings.filter((warning) => !isAdvisoryHealthWarning(warning, requireMergeDrivers));
     const findings = buildHealthFindings({
         warnings: normalizedWarnings,
         checks,
         remediationSources,
-        requireMergeDrivers: options.requireMergeDrivers === true,
+        requireMergeDrivers,
     });
+    const failingChecks = new Set(findings.filter((finding) => finding.severity === "gate_failing").map((finding) => finding.check));
+    const warningChecks = new Set(findings.map((finding) => finding.check));
+    for (const check of checks) {
+        check.ok = !failingChecks.has(check.name);
+        if (warningChecks.has(check.name))
+            check.status = "warn";
+    }
     const result = {
         ok: blockingWarnings.length === 0,
+        verdict: {
+            authority: "ok",
+            ...(strictExit ? { strict_exit: true } : {}),
+            ...(requireMergeDrivers ? { require_merge_drivers: true } : {}),
+            exit_code: strictExit && blockingWarnings.length > 0 ? EXIT_CODE.GENERIC_FAILURE : 0,
+        },
         checks,
         warnings: normalizedWarnings,
         findings,
@@ -2344,4 +2365,4 @@ export const _testOnlyHealthCommand = {
     warningCode,
 };
 //# sourceMappingURL=health.js.map
-//# debugId=9f0077a4-4f0a-540f-9951-2e8a640629c9
+//# debugId=cee8abad-51d2-5051-9cb8-81447bf2fd50

package/dist/sdk/governance/linked-file-report.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeStatusRegistry } from "../../core/schema/runtime-schema.js";
+import { type MissingLinkedPathRow, type OwnerItemMetadata, type StaleLinkOwnerInput } from "../../core/validate/missing-link-owners.js";
+import type { ClassifiedStaleLinkedPath } from "../../core/validate/stale-file-classification.js";
+/** Repair evidence for one path; nested holders use the same ceiling as paths. */
+export interface LinkedFileRepairRow extends MissingLinkedPathRow {
+    /** Same-basename possibilities, not verified relocation instructions. */
+    candidates: string[];
+    /** Whether the classifier withheld additional possible destinations. */
+    candidates_truncated: boolean;
+    /** Unique holder and field pairs referencing this path before projection. */
+    link_count: number;
+    /** Whether the bounded holder list omits any link. */
+    items_truncated: boolean;
+    /** Number of links on nonterminal holders for this path. */
+    active_link_count: number;
+}
+/** Full-population counters and a bounded, consistently structured worklist. */
+export interface LinkedFileRepairReport {
+    /** Distinct stale path count, also the unprojected worklist row count. */
+    missing_linked_path_rows_count: number;
+    /** Paths with owners and candidates joined before either is truncated. */
+    missing_linked_path_rows: LinkedFileRepairRow[];
+    /** Whether any complete path row is omitted. */
+    missing_linked_path_rows_truncated: boolean;
+    /** Unique path, holder and field triples across every lifecycle state. */
+    missing_linked_links_count: number;
+    /** Missing links whose holders are actionable under the workspace registry. */
+    active_missing_linked_links_count: number;
+    /** Missing links on holders with the configured close status. */
+    legacy_closed_missing_linked_links_count: number;
+    /** Missing links on all terminal holders, including the closed subset. */
+    legacy_terminal_missing_linked_links_count: number;
+    /** Distinct paths referenced by at least one active holder. */
+    active_missing_linked_paths_count: number;
+}
+/**
+ * Build an active-first repair worklist with deterministic path/holder sorting. Unknown
+ * statuses and absent holder metadata remain actionable. Infinity explicitly
+ * restores every path and holder; finite limits cap both dimensions equally.
+ */
+export declare function buildLinkedFileRepairReport(links: readonly StaleLinkOwnerInput[], classifications: readonly ClassifiedStaleLinkedPath[], lookup: (id: string) => OwnerItemMetadata | undefined, registry: RuntimeStatusRegistry, limit?: number): LinkedFileRepairReport;

package/dist/sdk/governance/linked-file-report.js

@@ -0,0 +1,72 @@
+/**
+ * @module sdk/governance/linked-file-report
+ *
+ * Joins missing-file evidence with holder lifecycle before projecting a bounded
+ * repair worklist. Counts always describe the complete supplied evidence.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d62bc6ec-c345-5196-93b8-280b5484b18a")}catch(e){}}();
+import { normalizeStatusInput } from "../../core/item/status.js";
+import { buildMissingLinkedPathRows, } from "../../core/validate/missing-link-owners.js";
+/**
+ * Build an active-first repair worklist with deterministic path/holder sorting. Unknown
+ * statuses and absent holder metadata remain actionable. Infinity explicitly
+ * restores every path and holder; finite limits cap both dimensions equally.
+ */
+export function buildLinkedFileRepairReport(links, classifications, lookup, registry, limit = 40) {
+    const ceiling = limit === Infinity
+        ? Infinity
+        : Number.isFinite(limit)
+            ? Math.max(0, Math.floor(limit))
+            : 40;
+    const byPath = new Map(classifications.map((entry) => [entry.path, entry]));
+    const report = {
+        missing_linked_path_rows_count: 0,
+        missing_linked_path_rows: [],
+        missing_linked_path_rows_truncated: false,
+        missing_linked_links_count: 0,
+        active_missing_linked_links_count: 0,
+        legacy_closed_missing_linked_links_count: 0,
+        legacy_terminal_missing_linked_links_count: 0,
+        active_missing_linked_paths_count: 0,
+    };
+    const rows = buildMissingLinkedPathRows(links, lookup).map((row) => {
+        const active = [];
+        const terminal = [];
+        for (const owner of row.items) {
+            const status = normalizeStatusInput(owner.status, registry) ?? owner.status;
+            if (registry.terminal_statuses.has(status)) {
+                terminal.push(owner);
+                if (status === registry.close_status)
+                    report.legacy_closed_missing_linked_links_count += 1;
+            }
+            else {
+                active.push(owner);
+            }
+        }
+        report.missing_linked_links_count += row.items.length;
+        report.active_missing_linked_links_count += active.length;
+        report.legacy_terminal_missing_linked_links_count += terminal.length;
+        if (active.length > 0)
+            report.active_missing_linked_paths_count += 1;
+        const classification = byPath.get(row.path);
+        return {
+            ...row,
+            candidates: classification?.candidates ?? [],
+            candidates_truncated: classification?.candidates_truncated ?? false,
+            link_count: row.items.length,
+            active_link_count: active.length,
+            items: [...active, ...terminal].slice(0, ceiling),
+            items_truncated: row.items.length > ceiling,
+        };
+    });
+    rows.sort((left, right) => Number(right.active_link_count > 0) -
+        Number(left.active_link_count > 0) ||
+        left.path.localeCompare(right.path));
+    report.missing_linked_path_rows_count = rows.length;
+    report.missing_linked_path_rows = rows.slice(0, ceiling);
+    report.missing_linked_path_rows_truncated = rows.length > ceiling;
+    return report;
+}
+//# sourceMappingURL=linked-file-report.js.map
+//# debugId=d62bc6ec-c345-5196-93b8-280b5484b18a

package/dist/sdk/governance/validate.d.ts

@@ -151,7 +151,9 @@ export interface ValidateCountsResult extends Omit<ValidateResult, "fixes"> {
  * Build the counts-only validate projection without mutating the full result.
  * The check envelope and warning codes remain available for gates, while every
  * per-item diagnostic/fix array is removed recursively and scalar counts,
- * totals, statuses, and truncation markers are preserved.
+ * totals, statuses, and true truncation markers are preserved. False truncation
+ * markers are omitted; this sparse convention does not suppress other false or
+ * zero values, and the projection receipt still declares omitted diagnostic rows.
  */
 export declare function projectValidateCounts(result: ValidateResult): ValidateCountsResult;
 interface ValidateMetadataPolicy {
@@ -226,7 +228,8 @@ declare function buildLifecycleCheck(items: ItemWithBody[], includeStaleBlockers
     warnings: string[];
     terminalParentFixRows: TerminalParentFixRow[];
 };
-declare function buildFilesCheck(items: ItemWithBody[], workspaceRoot: string, pmRoot: string, fileScanMode: ValidateFileScanMode, includePmInternals: boolean, verboseFileLists: boolean): Promise<{
+/** Join live filesystem evidence with holder lifecycle, retaining historical rows while warning only on active missing links. */
+declare function buildFilesCheck(items: ItemWithBody[], workspaceRoot: string, pmRoot: string, fileScanMode: ValidateFileScanMode, includePmInternals: boolean, verboseFileLists: boolean, statusRegistry?: RuntimeStatusRegistry): Promise<{
     check: ValidateCheck;
     warnings: string[];
     staleLinkPruneRows: StaleLinkPruneRow[];

package/dist/sdk/governance/validate.js

@@ -4,7 +4,7 @@
  * Implements the pm validate command surface and its agent-facing runtime behavior.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="0d466293-869d-54bb-b07d-facb3be51e8c")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="898c4c05-70ab-5ea4-851e-9e224a85afc4")}catch(e){}}();
 import { assertInitializedTracker } from "../environment/tracker-preflight.js";
 import fs from "node:fs/promises";
 import { realpathSync } from "node:fs";
@@ -18,7 +18,7 @@ import { isFileMissingError } from "../../core/fs/fs-utils.js";
 import { normalizeStatusInput } from "../../core/item/status.js";
 import { resolveItemTypeRegistry } from "../../core/item/type-registry.js";
 import { resolveRuntimeStatusRegistry, } from "../../core/schema/runtime-schema.js";
-import { DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS, DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS, EXIT_CODE, PM_DIRNAME, } from "../../core/shared/constants.js";
+import { DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS, DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS, EXIT_CODE, PM_DIRNAME, SETTINGS_DEFAULTS, } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 import { toNonEmptyStringOrUndefined } from "../../core/shared/primitives.js";
 import { nowIso } from "../../core/shared/time.js";
@@ -30,11 +30,11 @@ import { findDuplicateIssueCodes, } from "../../core/governance/issue-codes.js";
 import { buildMissingByTypeCounts, } from "../../core/validate/missing-by-type.js";
 import { classifyStaleLinkedPaths, summarizeStaleLinkedPathClassifications, } from "../../core/validate/stale-file-classification.js";
 import { isRemoteLinkedArtifactReference } from "../../core/validate/linked-artifact-reference.js";
-import { buildMissingLinkedPathRows, summarizeMissingLinkedPathRows, } from "../../core/validate/missing-link-owners.js";
 import { assertProjectionModeChoice, } from "../output-projection.js";
 import { collectDanglingDependencyReferences } from "../graph/assembly.js";
 import { auditMergeAttributeFence, auditMergeDriverConfiguration, findGitWorkspaceRoot, resolveProjectMergeTypeFolders, } from "../merge/install.js";
 import { inspectMergeReceiptEvidence, partitionMergeReceipts, } from "../merge/receipts.js";
+import { buildLinkedFileRepairReport } from "./linked-file-report.js";
 import { scanStorageIntegrity } from "./storage-integrity.js";
 import { scanTrackedRuntimeCache } from "./tracked-runtime-cache.js";
 import { scanHistoryAuthorAttribution } from "../author-attribution.js";
@@ -166,10 +166,11 @@ const DIAGNOSTIC_LIST_SUMMARY_LIMIT = 5;
 const LINKED_ARTIFACT_MAX_PATH_LENGTH = 4096;
 const LINKED_ARTIFACT_MAX_SEGMENT_LENGTH = 255;
 const execFileAsync = promisify(execFile);
+/** Recursively omit diagnostic arrays and false truncation markers while preserving zero counts and ordinary false values. */
 function projectValidateCountsRecord(record) {
     const projected = {};
     for (const [key, value] of Object.entries(record)) {
-        if (Array.isArray(value)) {
+        if (Array.isArray(value) || (value === false && key.endsWith("_truncated"))) {
             continue;
         }
         projected[key] =
@@ -183,7 +184,9 @@ function projectValidateCountsRecord(record) {
  * Build the counts-only validate projection without mutating the full result.
  * The check envelope and warning codes remain available for gates, while every
  * per-item diagnostic/fix array is removed recursively and scalar counts,
- * totals, statuses, and truncation markers are preserved.
+ * totals, statuses, and true truncation markers are preserved. False truncation
+ * markers are omitted; this sparse convention does not suppress other false or
+ * zero values, and the projection receipt still declares omitted diagnostic rows.
  */
 export function projectValidateCounts(result) {
     return {
@@ -1573,7 +1576,8 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
 }
 /* c8 ignore stop */
 /* c8 ignore start -- files-check candidate filtering/classification permutations are covered by file-audit integration suites */
-async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
+/** Join live filesystem evidence with holder lifecycle, retaining historical rows while warning only on active missing links. */
+async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists, statusRegistry = resolveRuntimeStatusRegistry(SETTINGS_DEFAULTS.schema)) {
     const linkedPathState = await collectLinkedPathScanState(items, workspaceRoot);
     const itemsById = new Map(items.map((item) => [item.id, item]));
     const uniqueMissingLinkedPaths = [
@@ -1601,9 +1605,6 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
     if (partition.strictModeForcesPmInternals) {
         warnings.push("validate_files_tracked_all_strict_forces_pm_internals");
     }
-    if (uniqueMissingLinkedPaths.length > 0) {
-        warnings.push(`validate_files_missing_linked_paths:${uniqueMissingLinkedPaths.length}`);
-    }
     if (orphanedFiles.length > 0) {
         warnings.push(`validate_files_orphaned_paths:${orphanedFiles.length}`);
     }
@@ -1617,29 +1618,11 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         : summarizeFileList(summarizeOrphanedPathRows(orphanedPathRows), false)
             .values;
     const summarizedClassifications = summarizeFileList(summarizeStaleLinkedPathClassifications(classifiedStalePaths), verboseFileLists);
-    // Owner attribution for missing linked paths (GH-210): per-path rows naming
-    // the owning item(s) so cleanup is evidence-based instead of requiring a
-    // reverse lookup. Full structured objects under --verbose-file-lists; compact
-    // `path:classification owner=… field=…` one-liners (capped) otherwise — same
-    // full/summary split as the other file-check lists (file_list_detail_mode).
-    const missingLinkedPathRows = staleLinkPruneRows.map((row) => ({
-        item_id: row.item_id,
-        path: row.path,
-        link_kind: row.link_kind,
-        classification: row.classification,
-    }));
-    const ownerRows = buildMissingLinkedPathRows(missingLinkedPathRows, (id) => {
-        const owner = itemsById.get(id);
-        return owner
-            ? { type: owner.type, title: owner.title, status: owner.status }
-            : undefined;
-    });
-    // Default to token-efficient compact one-liners; expose the full structured
-    // rows (the GH-210 JSON shape) under --verbose-file-lists.
-    const ownerRowDetail = verboseFileLists
-        ? ownerRows
-        : summarizeFileList(summarizeMissingLinkedPathRows(ownerRows), false)
-            .values;
+    const missingLinkedPathRows = staleLinkPruneRows;
+    const repairReport = buildLinkedFileRepairReport(missingLinkedPathRows, classifiedStalePaths, (id) => itemsById.get(id), statusRegistry, verboseFileLists ? Infinity : FILE_LIST_SUMMARY_LIMIT);
+    if (repairReport.active_missing_linked_paths_count > 0) {
+        warnings.push(`validate_files_missing_linked_paths:${repairReport.active_missing_linked_paths_count}`);
+    }
     return {
         check: {
             name: "files",
@@ -1678,11 +1661,11 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
                 missing_linked_paths: summarizedMissing.values,
                 missing_linked_paths_truncated: summarizedMissing.truncated,
                 missing_linked_paths_moved_count: movedStalePathCount,
-                missing_linked_paths_deleted_count: uniqueMissingLinkedPaths.length - movedStalePathCount,
+                missing_linked_paths_deleted_count: classifiedStalePaths.filter((entry) => entry.classification === "deleted").length,
+                missing_linked_paths_malformed_count: classifiedStalePaths.filter((entry) => entry.classification === "malformed").length,
                 missing_linked_path_classifications: summarizedClassifications.values,
                 missing_linked_path_classifications_truncated: summarizedClassifications.truncated,
-                missing_linked_path_rows_count: ownerRows.length,
-                missing_linked_path_rows: ownerRowDetail,
+                ...repairReport,
                 orphaned_paths_count: orphanedFiles.length,
                 orphaned_paths_total: summarizedOrphaned.total,
                 orphaned_paths: summarizedOrphaned.values,
@@ -2076,6 +2059,7 @@ function recordValidateCheck(state, built, fixHintsEnabled) {
     state.checks.push(built.check);
     state.warnings.push(...built.warnings);
 }
+/** Run only selected checks against one resolved workspace context and collect their typed remediation evidence. */
 async function executeRequestedValidateChecks(params) {
     const state = {
         checks: [],
@@ -2108,7 +2092,7 @@ async function executeRequestedValidateChecks(params) {
         recordValidateCheck(state, buildDependencyReferencesCheck(params.items, fullDiagnostics, params.statusRegistry), fixHintsEnabled);
     }
     if (params.requestedChecks.has("files")) {
-        const built = await buildFilesCheck(params.items, params.workspaceRoot, params.pmRoot, params.fileScanMode, Boolean(params.options.includePmInternals), Boolean(params.options.verboseFileLists));
+        const built = await buildFilesCheck(params.items, params.workspaceRoot, params.pmRoot, params.fileScanMode, Boolean(params.options.includePmInternals), Boolean(params.options.verboseFileLists), params.statusRegistry);
         state.staleLinkPruneRows = built.staleLinkPruneRows;
         recordValidateCheck(state, built, fixHintsEnabled);
     }
@@ -2275,4 +2259,4 @@ export async function runValidate(options, global, services = {}) {
 }
 /* c8 ignore stop */
 //# sourceMappingURL=validate.js.map
-//# debugId=0d466293-869d-54bb-b07d-facb3be51e8c
+//# debugId=898c4c05-70ab-5ea4-851e-9e224a85afc4

package/dist/sdk/governance.d.ts

@@ -13,6 +13,7 @@ export * from "./governance/assurance-presets.js";
 export * from "./governance/assurance-runtime.js";
 export * from "./governance/boundary-fixtures.js";
 export * from "./governance/defect-recurrence.js";
+export * from "./governance/defect-recurrence-coverage.js";
 export { runReindex, type ReindexOptions, type ReindexResult, } from "./governance/reindex.js";
 export * from "./governance/stale-work.js";
 export * from "./governance/storage-integrity.js";
@@ -20,6 +21,7 @@ export * from "./governance/status-role-diagnostics.js";
 export * from "./governance/workspace-position.js";
 export { runUpgrade, type UpgradeCliResult, type UpgradeCommandOptions, type UpgradeCommandRunner, type UpgradeCommandRunnerResult, type UpgradePackageResult, type UpgradeResult, } from "./governance/upgrade.js";
 export * from "./governance/validate.js";
+export * from "./governance/linked-file-report.js";
 export * from "./author-attribution.js";
 export * from "./mutation-guard.js";
 export * from "./governance/provenance-health.js";

package/dist/sdk/governance.js

@@ -4,7 +4,7 @@
  * Provides validation, health, integrity, and mutation-policy primitives.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ff251826-36f0-5b92-bee8-ca71d265986c")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5e2aaa83-a109-5e44-b9b3-316501ffadf4")}catch(e){}}();
 export * from "./governance/gc.js";
 export * from "./governance/health.js";
 export * from "./governance/extension-host-version.js";
@@ -15,6 +15,7 @@ export * from "./governance/assurance-presets.js";
 export * from "./governance/assurance-runtime.js";
 export * from "./governance/boundary-fixtures.js";
 export * from "./governance/defect-recurrence.js";
+export * from "./governance/defect-recurrence-coverage.js";
 export { runReindex, } from "./governance/reindex.js";
 export * from "./governance/stale-work.js";
 export * from "./governance/storage-integrity.js";
@@ -22,9 +23,10 @@ export * from "./governance/status-role-diagnostics.js";
 export * from "./governance/workspace-position.js";
 export { runUpgrade, } from "./governance/upgrade.js";
 export * from "./governance/validate.js";
+export * from "./governance/linked-file-report.js";
 export * from "./author-attribution.js";
 export * from "./mutation-guard.js";
 export * from "./governance/provenance-health.js";
 export * from "./similarity.js";
 //# sourceMappingURL=governance.js.map
-//# debugId=ff251826-36f0-5b92-bee8-ca71d265986c
+//# debugId=5e2aaa83-a109-5e44-b9b3-316501ffadf4

package/dist/sdk/history-repair.d.ts

@@ -36,6 +36,13 @@ export interface HistoryRepairCommandOptions {
         gitWorkspaceRoot: string | null;
         receipts: MergeDecisionReceipt[];
     }>;
+    /** Restored-origin evidence checked against the same item snapshot protected by the rewrite transaction. */
+    mergeAbandonmentProof?: {
+        /** Git workspace containing the tracked item. */
+        gitWorkspaceRoot: string;
+        /** Authoritative receipt whose original rebase state must match. */
+        receipt: MergeDecisionReceipt;
+    };
 }
 /** Documents the history repair result payload exchanged by command, SDK, and package integrations. */
 export interface HistoryRepairResult {

package/dist/sdk/history-repair.js

@@ -4,7 +4,7 @@
  * Implements the pm history repair command surface and its agent-facing runtime behavior.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d397bc22-d0ae-5c3d-a1bf-7f4c38ca31be")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9f91f2ee-cebe-592c-92ee-717301fa96ca")}catch(e){}}();
 import { assertInitializedTracker } from "./environment/tracker-preflight.js";
 import { salvageHistoryTail } from "./history/salvage.js";
 import { realpath } from "node:fs/promises";
@@ -30,6 +30,7 @@ import { listAllItemMetadataWithBody, readLocatedItem, } from "../core/store/ite
 import { resolvePmRoot } from "../core/store/paths.js";
 import { readSettings } from "../core/store/settings.js";
 import { resolveHistorySubject } from "./history-redact.js";
+import { isOriginalGitStateRestored } from "./merge/receipt-operation.js";
 import { inspectMergeReceiptEvidence, summarizeMergeReceipt, } from "./merge/receipts.js";
 import { encodeItemScalarDecisionValue, hashItemScalarDecisionValue, } from "./merge/three-way.js";
 import { listInvalidProvenanceHistoryStreamIds, normalizeInvalidHistoryProvenance, } from "./governance/provenance-health.js";
@@ -229,6 +230,24 @@ async function verifyMergeReceiptProof(params) {
         receipt_ids: [],
     };
 }
+/** Refuse a restored-origin audit when its exact item snapshot or clean history has changed. */
+async function assertHistoryRepairAbandonmentProof(proof, context, chainOk, reanchor) {
+    if (proof === undefined)
+        return;
+    const { receipt, gitWorkspaceRoot } = proof;
+    const canonicalPath = context.currentItemPath === null ? null
+        : path.relative(gitWorkspaceRoot, context.currentItemPath).split(path.sep).join("/");
+    if (!chainOk || reanchor.entriesRehashed !== 0 || reanchor.entriesPatchRepaired !== 0 || context.matchedChainBefore !== true ||
+        context.currentItemRawBeforeLock === null || canonicalPath !== receipt.item_path ||
+        receipt.operation === undefined ||
+        !await isOriginalGitStateRestored(gitWorkspaceRoot, receipt.item_path, receipt.operation, context.currentItemRawBeforeLock)) {
+        throw new PmCliError("Restored-origin receipt evidence no longer proves the exact clean item snapshot.", EXIT_CODE.CONFLICT, {
+            code: "merge_reconcile_receipt_evidence_untrusted",
+            recovery: { suggested_retry: "pm merge reconcile --dry-run" },
+        });
+    }
+}
+/** Resolve and verify receipt candidates against loaded item evidence, refusing untrusted preview and apply requests alike. */
 async function resolveHistoryRepairMergeEvidence(params) {
     const requestedReceiptIds = new Set(params.options.mergeReceiptProof?.receipts
         .filter((receipt) => receipt.item_id === params.subjectId)
@@ -256,7 +275,6 @@ async function resolveHistoryRepairMergeEvidence(params) {
         : undefined;
     if (mergeReceiptProof &&
         !mergeReceiptProof.trusted &&
-        params.options.dryRun !== true &&
         params.options.force !== true) {
         throw new PmCliError(`Merge receipt evidence for ${params.subjectId} does not prove the exact item snapshot (${mergeReceiptProof.reason}).`, EXIT_CODE.CONFLICT, {
             code: "merge_reconcile_receipt_evidence_untrusted",
@@ -359,6 +377,7 @@ function collectHistoryRepairWarnings(changed, skippedOps, reconciliation) {
     }
     return warnings;
 }
+/** Revalidate item/history bytes and restored-origin Git proof under the rewrite lock before persisting. */
 async function applyHistoryRepairRewrite(params) {
     return executeHistoryRewrite({
         pmRoot: params.pmRoot,
@@ -366,16 +385,19 @@ async function applyHistoryRepairRewrite(params) {
         settings: params.settings,
         typeRegistry: params.typeRegistry,
         historyRawBeforeLock: params.historyRawBeforeLock,
-        currentItemRawBeforeLock: params.currentItemRawBeforeLock,
+        currentItemRawBeforeLock: params.itemReplayContext.currentItemRawBeforeLock,
         operation: "history-repair",
         author: params.author,
         force: params.force,
-        itemDocument: params.loadedItem?.document ?? null,
-        applyRewrite: async ({ historyRawUnderLock }) => writeHistoryRawWithRollback({
-            historyPath: params.historyPath,
-            nextHistoryRaw: historyEntriesToRaw(params.rewrittenEntries),
-            historyRawUnderLock,
-        }),
+        itemDocument: params.itemReplayContext.loadedItem?.document ?? null,
+        applyRewrite: async ({ historyRawUnderLock }) => {
+            await assertHistoryRepairAbandonmentProof(params.mergeAbandonmentProof, params.itemReplayContext, params.chainOk, params.reanchor);
+            await writeHistoryRawWithRollback({
+                historyPath: params.historyPath,
+                nextHistoryRaw: historyEntriesToRaw(params.rewrittenEntries),
+                historyRawUnderLock,
+            });
+        },
         applyPostRewrite: async () => runActiveOnWriteHooks({
             path: params.historyPath,
             scope: "project",
@@ -395,6 +417,16 @@ export async function runHistoryRepair(id, options, global) {
     }
     return repairHistorySubject({ pmRoot, subject, settings, typeRegistry, options });
 }
+/** Preserve explicit audit requests while reusing exact restored-origin dispositions in verified history. */
+function shouldAppendForcedHistoryAudit(options, historyEntries) {
+    // Receipt persistence can fail after the audited history transaction commits.
+    // Only an identical disposition satisfies a retry; unrelated audits do not.
+    const alreadyRecorded = options.mergeAbandonmentProof !== undefined &&
+        options.auditContext !== undefined &&
+        historyEntries.some((entry) => entry.op === "merge_reconcile" &&
+            stableStringify(entry.context) === stableStringify(options.auditContext));
+    return options.forceAuditEntry === true && !alreadyRecorded;
+}
 /** Reanchor or reconcile one resolved subject, separately from byte-preserving salvage. */
 async function repairHistorySubject(params) {
     const { pmRoot, subject, settings, typeRegistry, options } = params;
@@ -425,6 +457,7 @@ async function repairHistorySubject(params) {
         .filter((version) => version !== undefined));
     const reanchor = reanchorHistoryEntries(provenanceNormalization.entries, itemHashVersion);
     const itemReplayContext = await loadHistoryRepairItemReplay(subject, settings, historyEntries, itemHashVersion);
+    await assertHistoryRepairAbandonmentProof(options.mergeAbandonmentProof, itemReplayContext, chainBefore.ok, reanchor);
     const finalReplay = reanchor.finalDocument;
     const finalReplayHashes = replayHashVerificationCandidates(finalReplay, itemHashVersion);
     let reconcileNeeded = false;
@@ -449,7 +482,7 @@ async function repairHistorySubject(params) {
         reanchor.entriesRehashed > 0,
         reanchor.entriesPatchRepaired > 0,
         reconcileNeeded,
-        options.forceAuditEntry === true,
+        shouldAppendForcedHistoryAudit(options, historyEntries),
         provenanceNormalization.receipt.changed,
     ].some(Boolean);
     const author = resolveAuthor(options.author, settings.author_default);
@@ -490,10 +523,12 @@ async function repairHistorySubject(params) {
             settings,
             typeRegistry,
             historyRawBeforeLock,
-            currentItemRawBeforeLock: itemReplayContext.currentItemRawBeforeLock,
+            itemReplayContext,
+            mergeAbandonmentProof: options.mergeAbandonmentProof,
+            chainOk: chainBefore.ok,
+            reanchor,
             author,
             force: options.force,
-            loadedItem: itemReplayContext.loadedItem,
             historyPath: subject.historyPath,
             rewrittenEntries,
         })));
@@ -620,4 +655,4 @@ export async function runHistoryRepairAll(options, global) {
     };
 }
 //# sourceMappingURL=history-repair.js.map
-//# debugId=d397bc22-d0ae-5c3d-a1bf-7f4c38ca31be
+//# debugId=9f91f2ee-cebe-592c-92ee-717301fa96ca

package/dist/sdk/lifecycle/close.d.ts

@@ -1,3 +1,9 @@
+/**
+ * @module sdk/lifecycle/close
+ *
+ * Implements the pm close command surface and its agent-facing runtime behavior.
+ */
+import type { PmCliErrorRecoveryPayload } from "../../core/shared/errors.js";
 import { type GlobalOptions } from "../runtime-primitives.js";
 import { collectBlockedByIds } from "../actionability.js";
 import { type CloseOperationOptions, type CloseOperationResult } from "../lifecycle-policy.js";
@@ -28,6 +34,8 @@ export interface CloseResult {
     item: Record<string, unknown>;
     /** Changed metadata fields. */
     changed_fields: string[];
+    /** Evidence-only update guidance when acceptance fields are missing. */
+    recovery?: PmCliErrorRecoveryPayload;
     /** Validation and lifecycle receipts. */
     warnings: string[];
 }