@unbrained/pm-cli 2026.8.7 → 2026.8.9

package/dist/cli.js

@@ -5,13 +5,14 @@
  * Bootstraps the executable pm CLI entrypoint and startup optimizations.
  */
 
-!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]="46833198-bc44-5ed4-b685-51434f93d8df")}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]="81ec2fa2-c616-5978-999d-b76d5f45bafe")}catch(e){}}();
 import fs from "node:fs";
 import * as nodeModule from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { runCliWithBundleIntegrity, } from "./cli/bundle-integrity.js";
+import { runCliWithBundleIntegrity } from "./cli/bundle-integrity.js";
+import { runRuntimeCompatibleCli } from "./cli/runtime-compatibility-boundary.js";
 import { pruneCompileCacheGenerations, resolveCompileCacheGeneration, } from "./sdk/compile-cache.js";
 function enableNodeCompileCache() {
     const { enableCompileCache } = nodeModule;
@@ -90,7 +91,16 @@ export const _testOnly = {
 if (!printFastVersionIfRequested()) {
     enableNodeCompileCache();
     const cliEntrypointPath = fileURLToPath(import.meta.url);
-    await runCliWithBundleIntegrity(process.argv.slice(2), cliEntrypointPath, () => import("./cli-bundle/main.js"), process.stderr.write.bind(process.stderr));
+    const executingVersion = readPackageVersionForPath(cliEntrypointPath);
+    const invocationArgv = process.argv.slice(2);
+    await runRuntimeCompatibleCli({
+        executingVersion,
+        projectRoot: process.cwd(),
+        argv: invocationArgv,
+        allowStale: process.env.PM_ALLOW_STALE_CLI === "1",
+        run: () => runCliWithBundleIntegrity(invocationArgv, cliEntrypointPath, () => import("./cli-bundle/main.js"), process.stderr.write.bind(process.stderr)),
+        writeError: process.stderr.write.bind(process.stderr),
+    });
 }
 //# sourceMappingURL=cli.js.map
-//# debugId=46833198-bc44-5ed4-b685-51434f93d8df
+//# debugId=81ec2fa2-c616-5978-999d-b76d5f45bafe

package/dist/core/diagnostics/remediation.js

@@ -19,7 +19,7 @@
  */
 /** Registry of every non-extension `pm health` / `pm validate` warning code and its remediation. Extension findings keep their richer, contextual `details.triage.remediation` produced by the extension health triage and are intentionally excluded here (see pm-0hnu: "all non-extension checks"). */
 
-!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]="6a350683-275b-5d4d-ae02-45798b115f89")}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]="8daf3070-facb-5775-a813-fb695ac9e3ce")}catch(e){}}();
 export const REMEDIATION_REGISTRY = Object.freeze([
     // --- pm health: directories ---
     {
@@ -188,6 +188,16 @@ export const REMEDIATION_REGISTRY = Object.freeze([
         command: "git rm --cached -r -- <tracked-runtime-directories>",
         summary: "Clone-local tracker runtime artifacts are committed. Run the exact tracked_runtime_cache.remediation_command from the integrity check, commit the index-only removals, and keep the managed .gitignore fence.",
     },
+    {
+        code: "merge_decisions_unreviewed",
+        command: "pm merge reconcile --dry-run",
+        summary: "Review the pending merge receipts, re-apply any intended discarded values, then run pm merge reconcile; lossy receipts require explicit --force acceptance.",
+    },
+    {
+        code: "validate_merge_decisions_unreviewed",
+        command: "pm merge reconcile --dry-run",
+        summary: "Review the pending merge receipts before reconciliation; history-repair alone does not settle them, and lossy receipts require explicit --force acceptance.",
+    },
     // --- pm health: history_drift ---
     // `pm health` rewrites these commands to `pm history-repair --all` in the
     // per-check remediation_map when more than one stream is drifted.
@@ -459,4 +469,4 @@ export function buildRemediationCommands(warnings) {
     return Object.values(buildRemediationMap(warnings));
 }
 //# sourceMappingURL=remediation.js.map
-//# debugId=6a350683-275b-5d4d-ae02-45798b115f89
+//# debugId=8daf3070-facb-5775-a813-fb695ac9e3ce

package/dist/core/history/history.js

@@ -4,7 +4,7 @@
  * Implements append-only history and replay behavior for History.
  */
 
-!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]="5228a53a-603c-5c9f-870b-8ea8e0c5d27a")}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]="ce2dace3-7c86-5edf-8bda-083a0b3e7f2b")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
 import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { runActiveServiceOverride } from "../extensions/index.js";
@@ -13,7 +13,7 @@ import { canonicalDocument } from "../item/item-format.js";
 import { toItemRecord } from "../item/item-record.js";
 import { orderObject, sha256Hex, stableStringify, } from "../shared/serialization.js";
 import { nowIso } from "../shared/time.js";
-import { resolveHistoryAgentIdentity, resolveHistoryAuthorSource, } from "../shared/author.js";
+import { diagnoseAgentIdentity, resolveHistoryAgentIdentity, resolveHistoryAuthorSource, } from "../shared/author.js";
 import { removeHistoryEventIndexForHistoryPath, updateHistoryEventIndexAfterAppend, } from "./event-index.js";
 import { invalidateHistoryDriftCacheForPath } from "./drift-cache.js";
 const EMPTY_LEGACY_HASH_DOCUMENT = {
@@ -128,6 +128,15 @@ export function createHistoryEntry(params) {
     const rawPatch = jsonPatch.compare(beforePatchCanonical, afterPatchCanonical);
     const patch = normalizeHistoryPatchOps(beforePatchCanonical, rawPatch);
     const agentIdentity = resolveHistoryAgentIdentity(params.author);
+    const provenanceOutcomes = agentIdentity.harness
+        ? Object.fromEntries(Object.entries(diagnoseAgentIdentity().provenance_outcomes).filter(([, outcome]) => outcome.status === "failed"))
+        : undefined;
+    const context = provenanceOutcomes === undefined || Object.keys(provenanceOutcomes).length === 0
+        ? params.context
+        : {
+            ...params.context,
+            agent_provenance_outcomes: provenanceOutcomes,
+        };
     return {
         ts: params.nowIso,
         author: params.author,
@@ -151,7 +160,7 @@ export function createHistoryEntry(params) {
         before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
         after_hash: sha256Hex(stableStringify(afterHashCanonical)),
         message: params.message === undefined ? undefined : params.message,
-        ...(params.context === undefined ? {} : { context: params.context }),
+        ...(context === undefined ? {} : { context }),
     };
 }
 function isRecord(value) {
@@ -233,4 +242,4 @@ export const _testOnly = {
     isDefinedPointerPath,
 };
 //# sourceMappingURL=history.js.map
-//# debugId=5228a53a-603c-5c9f-870b-8ea8e0c5d27a
+//# debugId=ce2dace3-7c86-5edf-8bda-083a0b3e7f2b

package/dist/core/item/actionability.d.ts

@@ -1,7 +1,13 @@
 import type { RuntimeStatusRegistry } from "../schema/runtime-schema.js";
 import type { ItemMetadata, ItemStatus } from "../../types/index.js";
+/** Built-in ordering kinds that must remain reachable by blocker resolution. */
+export declare const ACTIONABILITY_ORDERING_KINDS: readonly string[];
 /** Collects the blocker item ids declared by an item: the legacy scalar `blocked_by` field plus every `blocked_by` dependency edge. Ids are trimmed, de-duplicated, and returned in stable lexicographic order. This is the single source of truth for "what must close before this item can proceed", shared by `pm next` readiness classification and the close-time auto-unblock sweep. */
 export declare function collectBlockedByIds(item: Pick<ItemMetadata, "blocked_by" | "dependencies">): string[];
+/** Build every forward and reverse blocker set in one corpus pass. */
+export declare function indexBlockedByIds(corpus: readonly ItemMetadata[]): Map<string, string[]>;
+/** Collect blockers from both an item's forward declarations and corpus-level reverse `blocks` edges. */
+export declare function collectBlockedByIdsFromCorpus(item: ItemMetadata, corpus: readonly ItemMetadata[]): string[];
 /** A blocker reference resolved against the corpus and annotated with its state. */
 export interface ResolvedBlocker {
     /** Stable identifier used to reference this record across commands and storage. */
@@ -13,7 +19,7 @@ export interface ResolvedBlocker {
     /** True when the blocker no longer gates work because the referenced item is terminal. */
     resolved: boolean;
 }
-/** Resolves an item's declared blockers against a corpus index, annotating each with the blocker's title/status and whether it still gates work. Unknown ids remain unresolved: silently treating a typo as satisfied would dispatch work whose prerequisite was never completed. Terminal referenced items alone are resolved. */
+/** Resolves an item's blockers against a corpus index with reverse `blocks` support. */
 export declare function resolveItemBlockers(item: Pick<ItemMetadata, "blocked_by" | "dependencies">, itemsById: Map<string, ItemMetadata>, statusRegistry: RuntimeStatusRegistry): ResolvedBlocker[];
 /**
  * Collects the normalized (trimmed, lowercased) ids of every corpus item that is

package/dist/core/item/actionability.js

@@ -10,10 +10,17 @@
  * `blocked_by` resolution a single source of truth.
  */
 
-!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]="bf429f76-9722-5e34-a5f0-6ced8d1ed667")}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]="de8a82e1-0b02-5d5a-9086-686529a1ccab")}catch(e){}}();
 import { isTerminalStatus, normalizeStatusForRegistry } from "./status.js";
 /** Dependency kind that marks "this item is blocked by the referenced item". */
 const BLOCKED_BY_DEPENDENCY_KIND = "blocked_by";
+/** Reverse dependency kind that marks "this item blocks the referenced item". */
+const BLOCKS_DEPENDENCY_KIND = "blocks";
+/** Built-in ordering kinds that must remain reachable by blocker resolution. */
+export const ACTIONABILITY_ORDERING_KINDS = Object.freeze([
+    BLOCKED_BY_DEPENDENCY_KIND,
+    BLOCKS_DEPENDENCY_KIND,
+]);
 /** Retired placeholder that explicitly means an item has no active blocker. */
 const NO_ACTIVE_BLOCKER_SENTINEL = "no-active-blocker";
 /**
@@ -28,23 +35,66 @@ function normalizeItemId(id) {
 /** Collects the blocker item ids declared by an item: the legacy scalar `blocked_by` field plus every `blocked_by` dependency edge. Ids are trimmed, de-duplicated, and returned in stable lexicographic order. This is the single source of truth for "what must close before this item can proceed", shared by `pm next` readiness classification and the close-time auto-unblock sweep. */
 export function collectBlockedByIds(item) {
     const ids = new Set();
-    const scalar = typeof item.blocked_by === "string" ? item.blocked_by.trim() : "";
-    if (scalar.length > 0 && scalar.toLowerCase() !== NO_ACTIVE_BLOCKER_SENTINEL) {
+    const scalar = typeof item.blocked_by === "string" ? normalizeItemId(item.blocked_by) : "";
+    if (scalar.length > 0 && scalar !== NO_ACTIVE_BLOCKER_SENTINEL) {
         ids.add(scalar);
     }
     for (const dependency of item.dependencies ?? []) {
+        const dependencyId = typeof dependency.id === "string" ? normalizeItemId(dependency.id) : "";
         if (dependency.kind === BLOCKED_BY_DEPENDENCY_KIND &&
-            typeof dependency.id === "string" &&
-            dependency.id.trim().length > 0 &&
-            dependency.id.trim().toLowerCase() !== NO_ACTIVE_BLOCKER_SENTINEL) {
-            ids.add(dependency.id.trim());
+            dependencyId.length > 0 &&
+            dependencyId !== NO_ACTIVE_BLOCKER_SENTINEL) {
+            ids.add(dependencyId);
         }
     }
     return [...ids].sort((left, right) => left.localeCompare(right));
 }
+/** Build every forward and reverse blocker set in one corpus pass. */
+export function indexBlockedByIds(corpus) {
+    const idsByItem = new Map();
+    for (const item of corpus) {
+        const itemId = normalizeItemId(item.id);
+        if (itemId.length === 0)
+            continue;
+        idsByItem.set(itemId, new Set(collectBlockedByIds(item)));
+    }
+    for (const candidate of corpus) {
+        const candidateId = normalizeItemId(candidate.id);
+        if (candidateId.length === 0)
+            continue;
+        for (const dependency of candidate.dependencies ?? []) {
+            const targetId = dependency.kind === BLOCKS_DEPENDENCY_KIND &&
+                typeof dependency.id === "string"
+                ? normalizeItemId(dependency.id)
+                : "";
+            if (targetId.length === 0 || targetId === NO_ACTIVE_BLOCKER_SENTINEL) {
+                continue;
+            }
+            const blockerIds = idsByItem.get(targetId) ?? new Set();
+            blockerIds.add(candidateId);
+            idsByItem.set(targetId, blockerIds);
+        }
+    }
+    return new Map([...idsByItem].map(([itemId, blockerIds]) => [
+        itemId,
+        [...blockerIds].sort((left, right) => left.localeCompare(right)),
+    ]));
+}
+/** Collect blockers from both an item's forward declarations and corpus-level reverse `blocks` edges. */
+export function collectBlockedByIdsFromCorpus(item, corpus) {
+    const itemId = normalizeItemId(item.id);
+    return itemId.length > 0
+        ? (indexBlockedByIds(corpus).get(itemId) ?? collectBlockedByIds(item))
+        : collectBlockedByIds(item);
+}
 /** Resolves an item's declared blockers against a corpus index, annotating each with the blocker's title/status and whether it still gates work. Unknown ids remain unresolved: silently treating a typo as satisfied would dispatch work whose prerequisite was never completed. Terminal referenced items alone are resolved. */
-export function resolveItemBlockers(item, itemsById, statusRegistry) {
-    return collectBlockedByIds(item).map((id) => {
+function resolveItemBlockersWithIndex(item, itemsById, statusRegistry, blockerIdsByItem) {
+    const itemWithId = item;
+    const blockerIds = typeof itemWithId.id === "string"
+        ? (blockerIdsByItem?.get(normalizeItemId(itemWithId.id)) ??
+            collectBlockedByIdsFromCorpus(itemWithId, [...itemsById.values()]))
+        : collectBlockedByIds(item);
+    return blockerIds.map((id) => {
         const blocker = itemsById.get(normalizeItemId(id));
         if (!blocker) {
             return { id, title: null, status: null, resolved: false };
@@ -57,6 +107,10 @@ export function resolveItemBlockers(item, itemsById, statusRegistry) {
         };
     });
 }
+/** Resolves an item's blockers against a corpus index with reverse `blocks` support. */
+export function resolveItemBlockers(item, itemsById, statusRegistry) {
+    return resolveItemBlockersWithIndex(item, itemsById, statusRegistry);
+}
 /**
  * Collects the normalized (trimmed, lowercased) ids of every corpus item that is
  * blocked under the single shared edge-aware definition: a non-terminal item
@@ -70,6 +124,7 @@ export function resolveItemBlockers(item, itemsById, statusRegistry) {
  */
 export function collectDependencyBlockedIds(corpus, statusRegistry) {
     const itemsById = new Map(corpus.map((item) => [normalizeItemId(item.id), item]));
+    const blockerIdsByItem = indexBlockedByIds(corpus);
     // Same candidate gate as computeActionabilityReport: active statuses plus
     // lifecycle-blocked statuses, so the two surfaces classify identically.
     const candidateStatuses = new Set([
@@ -83,7 +138,7 @@ export function collectDependencyBlockedIds(corpus, statusRegistry) {
             continue;
         const lifecycleBlocked = statusRegistry.blocked_statuses.has(normalizedStatus);
         if (lifecycleBlocked ||
-            resolveItemBlockers(item, itemsById, statusRegistry).some((blocker) => !blocker.resolved)) {
+            resolveItemBlockersWithIndex(item, itemsById, statusRegistry, blockerIdsByItem).some((blocker) => !blocker.resolved)) {
             blocked.add(normalizeItemId(item.id));
         }
     }
@@ -122,6 +177,7 @@ function indexCorpus(corpus) {
     const itemsById = new Map();
     const childrenByParent = new Map();
     const blockedByReverse = new Map();
+    const blockerIdsByItem = indexBlockedByIds(corpus);
     for (const item of corpus) {
         // Index keys are normalized (lowercased) for case-insensitive resolution;
         // stored values keep the item's original-case id for display.
@@ -133,14 +189,14 @@ function indexCorpus(corpus) {
             siblings.push(item);
             childrenByParent.set(parentKey, siblings);
         }
-        for (const blockerId of collectBlockedByIds(item)) {
+        for (const blockerId of blockerIdsByItem.get(normalizeItemId(item.id))) {
             const blockerKey = normalizeItemId(blockerId);
             const dependents = blockedByReverse.get(blockerKey) ?? [];
             dependents.push(item.id);
             blockedByReverse.set(blockerKey, dependents);
         }
     }
-    return { itemsById, childrenByParent, blockedByReverse };
+    return { itemsById, childrenByParent, blockedByReverse, blockerIdsByItem };
 }
 /**
  * Partitions a candidate set into ready vs blocked leaf work using the corpus to
@@ -154,7 +210,7 @@ function indexCorpus(corpus) {
  * the candidate order so the caller can apply its own ranking.
  */
 export function computeActionabilityReport(candidates, corpus, statusRegistry) {
-    const { itemsById, childrenByParent, blockedByReverse } = indexCorpus(corpus);
+    const { itemsById, childrenByParent, blockedByReverse, blockerIdsByItem } = indexCorpus(corpus);
     const activeStatuses = new Set([
         ...resolveActiveStatusSet(statusRegistry),
         ...statusRegistry.blocked_statuses,
@@ -176,7 +232,7 @@ export function computeActionabilityReport(candidates, corpus, statusRegistry) {
             containerCount += 1;
             continue;
         }
-        const openBlockers = resolveItemBlockers(item, itemsById, statusRegistry).filter((blocker) => !blocker.resolved);
+        const openBlockers = resolveItemBlockersWithIndex(item, itemsById, statusRegistry, blockerIdsByItem).filter((blocker) => !blocker.resolved);
         const unblocks = (blockedByReverse.get(normalizeItemId(item.id)) ?? [])
             .filter((dependentId) => nonTerminalIds.has(normalizeItemId(dependentId)))
             .sort((left, right) => left.localeCompare(right));
@@ -201,4 +257,4 @@ export function computeActionabilityReport(candidates, corpus, statusRegistry) {
     };
 }
 //# sourceMappingURL=actionability.js.map
-//# debugId=bf429f76-9722-5e34-a5f0-6ced8d1ed667
+//# debugId=de8a82e1-0b02-5d5a-9086-686529a1ccab

package/dist/core/output/output.js

@@ -4,7 +4,7 @@
  * Formats compact human and machine output for Output.
  */
 
-!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]="4a84286a-e1e3-5465-94c9-b44f8e4472d5")}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]="b52d2756-f640-5f53-981f-05fa23fa1718")}catch(e){}}();
 import { getActiveCommandContext, runActiveCommandOverride, runActiveRendererOverride, runActiveServiceOverrideSync, setActiveCommandResult, } from "../extensions/index.js";
 import { EXIT_CODE } from "../shared/constants.js";
 import { isHostOutputSuppressed } from "./output-control.js";
@@ -12,6 +12,7 @@ import { projectMutationResult } from "./mutation-projection.js";
 import { attachReadOutputContracts } from "../../sdk/context-intent-contracts.js";
 import { attachOutputTokenAccounting } from "../../sdk/output-token-accounting.js";
 import { resolveReadOutputEncoding } from "../../sdk/read-output-contracts.js";
+const DECLARED_PROCESS_EXIT_CODES = new Set(Object.values(EXIT_CODE));
 const NATIVE_OUTPUT_MARKER = "__pm_native_output";
 let streamErrorHandlersInstalled = false;
 function isPlainObject(value) {
@@ -388,6 +389,12 @@ export function formatOutput(result, options) {
 }
 /** Implements print result for the public runtime surface of this module. */
 export function printResult(result, options) {
+    if (isPlainObject(result) &&
+        Number.isInteger(result.exit_code) &&
+        DECLARED_PROCESS_EXIT_CODES.has(Number(result.exit_code)) &&
+        (process.exitCode === undefined || process.exitCode === EXIT_CODE.SUCCESS)) {
+        process.exitCode = Number(result.exit_code);
+    }
     const projected = options.idOnly
         ? projectMutationResult(result, { idOnly: true })
         : options.fullChangedFields
@@ -417,4 +424,4 @@ export const outputTestOnly = {
     renderToonValue,
 };
 //# sourceMappingURL=output.js.map
-//# debugId=4a84286a-e1e3-5465-94c9-b44f8e4472d5
+//# debugId=b52d2756-f640-5f53-981f-05fa23fa1718

package/dist/core/sentry/helpers.d.ts

@@ -15,6 +15,16 @@ export declare function sentryFinishCommandSpan(ok: boolean, error?: string, met
     command_resolution?: TelemetryCommandResolution;
     resolution_stage?: TelemetryResolutionStage;
 }): void;
+/**
+ * Tag value recorded when a captured error declares no canonical pm error code.
+ *
+ * The release reliability gate classifies Sentry issues from the `pm.error_code`
+ * and `pm.exit_code` tags and fails closed when either is absent. Emitting this
+ * sentinel keeps the producer side of that contract total: an undeclared runtime
+ * fault is still classifiable (and still blocks, because it resolves to no
+ * catalog contract) instead of being unjudgeable for lack of a tag.
+ */
+export declare const UNCLASSIFIED_CAPTURED_ERROR_CODE = "unclassified_runtime_error";
 /** Implements sentry capture cli error for the public runtime surface of this module. */
 export declare function sentryCaptureCliError(error: unknown): void;
 /** Implements sentry log cli usage error for the public runtime surface of this module. */

package/dist/core/sentry/helpers.js

@@ -4,7 +4,7 @@
  * Integrates Sentry instrumentation and release diagnostics for Helpers.
  */
 
-!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]="48cce5c1-5cca-53cc-8991-f97669251a72")}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]="ffe56aed-b794-5bf4-99fd-e3c5fe065163")}catch(e){}}();
 import { getSentry } from "./instrument.js";
 import { PmCliError } from "../shared/errors.js";
 import { EXIT_CODE } from "../shared/constants.js";
@@ -110,6 +110,60 @@ export function sentryFinishCommandSpan(ok, error, metadata) {
     activeCommandSpan.end();
     activeCommandSpan = undefined;
 }
+/**
+ * Tag value recorded when a captured error declares no canonical pm error code.
+ *
+ * The release reliability gate classifies Sentry issues from the `pm.error_code`
+ * and `pm.exit_code` tags and fails closed when either is absent. Emitting this
+ * sentinel keeps the producer side of that contract total: an undeclared runtime
+ * fault is still classifiable (and still blocks, because it resolves to no
+ * catalog contract) instead of being unjudgeable for lack of a tag.
+ */
+export const UNCLASSIFIED_CAPTURED_ERROR_CODE = "unclassified_runtime_error";
+/**
+ * Reads the declared error contract carried by a thrown value, if any.
+ *
+ * There is deliberately no `PmCliError` special case: `shouldCaptureCliError`
+ * rejects every `PmCliError` before capture, so such a branch would be
+ * unreachable — and a `PmCliError` carries a public `code` and a numeric
+ * `exitCode`, so the general path below would classify it identically anyway.
+ */
+function readCapturedErrorContract(error) {
+    const candidate = typeof error === "object" && error !== null
+        ? error
+        : undefined;
+    const hasDeclaredExitCode = typeof candidate?.exitCode === "number";
+    const exitCode = hasDeclaredExitCode
+        ? Math.trunc(candidate?.exitCode)
+        : EXIT_CODE.GENERIC_FAILURE;
+    // A declared pm code always travels with a numeric exit code. Requiring both
+    // halves keeps a Node errno error (string `code`, no `exitCode`) from being
+    // reported as though it were a catalog contract.
+    const hasDeclaredErrorCode = typeof candidate?.code === "string" &&
+        candidate.code.length > 0 &&
+        hasDeclaredExitCode;
+    return {
+        error_code: hasDeclaredErrorCode
+            ? candidate?.code
+            : UNCLASSIFIED_CAPTURED_ERROR_CODE,
+        exit_code: exitCode,
+    };
+}
+/**
+ * Builds the contract tags every captured event carries.
+ *
+ * These are attached to the event itself rather than to the ambient scope
+ * because the scope writer (`sentryFinishCommandSpan`) returns early when no
+ * command span is active, and the unknown-error path captures before that
+ * writer runs.
+ */
+function buildCapturedErrorTags(error) {
+    const contract = readCapturedErrorContract(error);
+    return {
+        "pm.error_code": contract.error_code,
+        "pm.exit_code": String(contract.exit_code),
+    };
+}
 /** Implements sentry capture cli error for the public runtime surface of this module. */
 export function sentryCaptureCliError(error) {
     if (!shouldCaptureCliError(error))
@@ -117,6 +171,7 @@ export function sentryCaptureCliError(error) {
     const Sentry = getSentry();
     if (!Sentry)
         return;
+    const tags = buildCapturedErrorTags(error);
     if (error instanceof Error) {
         const extras = {};
         if ("exitCode" in error &&
@@ -127,10 +182,10 @@ export function sentryCaptureCliError(error) {
             typeof error.context === "object") {
             extras.error_context = error.context;
         }
-        Sentry.captureException(error, { extra: extras });
+        Sentry.captureException(error, { extra: extras, tags });
     }
     else {
-        Sentry.captureException(new Error(String(error)));
+        Sentry.captureException(new Error(String(error)), { tags });
     }
 }
 /** Implements sentry log cli usage error for the public runtime surface of this module. */
@@ -215,4 +270,4 @@ export async function sentryFlush(timeoutMs = 3000) {
     }
 }
 //# sourceMappingURL=helpers.js.map
-//# debugId=48cce5c1-5cca-53cc-8991-f97669251a72
+//# debugId=ffe56aed-b794-5bf4-99fd-e3c5fe065163

package/dist/core/shared/author.d.ts

@@ -19,6 +19,19 @@ export interface AgentProvenanceObservation {
  * selected harness declared the dimension but exposed no value this run.
  */
 export type AgentProvenance = Readonly<Record<string, AgentProvenanceObservation | null>>;
+/** Bounded reason explaining why one declared provenance dimension was absent. */
+export type AgentProvenanceAbsenceReason = "harness_unavailable" | "resolver_failed" | "resolver_not_configured" | "probes_disabled" | "invalid_value";
+/** Machine-readable resolution outcome for one provenance dimension. */
+export interface AgentProvenanceOutcome {
+    /** Whether the dimension resolved without retaining private source material. */
+    status: "resolved" | "unavailable" | "failed";
+    /** Stable bounded reason for absent or rejected values. */
+    reason?: AgentProvenanceAbsenceReason;
+    /** Resolver name when a bounded local resolver was attempted. */
+    resolver?: AgentProvenanceResolver;
+    /** Stable inference contract version used by downstream analytics. */
+    rule_version: "v1";
+}
 /** Privacy-bounded MCP client metadata that can participate in agent detection. */
 export interface AgentClientInfo {
     /** Client or harness name reported during protocol initialization. */
@@ -72,6 +85,11 @@ export interface DetectedAgentIdentity {
     /** Stable declared episode identity when the session supplied one. */
     episode?: AgentEpisodeIdentity;
 }
+/** Agent identity plus explicit outcomes for every built-in provenance dimension. */
+export interface DiagnosedAgentIdentity extends DetectedAgentIdentity {
+    /** Resolution outcomes that distinguish absence from resolver failure. */
+    provenance_outcomes: Readonly<Record<string, AgentProvenanceOutcome>>;
+}
 /** Public, privacy-safe identity resolution result shared by CLI and SDK hosts. */
 export interface ResolvedAuthorIdentity extends DetectedAgentIdentity {
     /** Stable author value written to mutation history. */
@@ -126,6 +144,13 @@ export declare function runWithWorkspaceHarnessSignalDescriptors<T>(descriptors:
  * traversal, or network requests.
  */
 export declare function detectAgentIdentity(signals?: HarnessDetectionSignals): DetectedAgentIdentity;
+/**
+ * Diagnose provenance without exposing environment values, paths, or probe data.
+ *
+ * This additive SDK contract keeps legacy `detectAgentIdentity` projections
+ * stable while giving health checks and history writers explicit absence states.
+ */
+export declare function diagnoseAgentIdentity(signals?: HarnessDetectionSignals): DiagnosedAgentIdentity;
 /** Reads the invocation-wide author override through the canonical environment seam. */
 export declare function readAuthorEnvironment(): string | undefined;
 /** Updates or clears the invocation-wide author override through the canonical environment seam. */