@unbrained/pm-cli 2026.7.14 → 2026.7.16

package/dist/cli-bundle/chunks/{chunk-MKL4CP2I.js → chunk-5ZSLZLDN.js}

@@ -1,57 +1,58 @@
 
-!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]="d5e1e32d-df71-5281-bc83-9c8c5fd37e21")}catch(e){}}();
-import {
-  runFiles
-} from "./chunk-TZ2PSLLT.js";
+!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]="1a18538c-3ee2-5ab6-b7c2-b913c780563a")}catch(e){}}();
 import {
   runDocs
-} from "./chunk-BN62TO2S.js";
-import {
-  isRemoteLinkedArtifactReference
-} from "./chunk-P6MYFH6K.js";
+} from "./chunk-IA5FKNII.js";
 import {
-  collectDanglingDependencyReferences
-} from "./chunk-L24HCJFC.js";
+  collectDanglingDependencyReferences,
+  createRelationshipKindRegistry
+} from "./chunk-JFTKLTEF.js";
 import {
   scanHistoryDrift
-} from "./chunk-QABYZYLU.js";
+} from "./chunk-SDQLJWBO.js";
 import {
-  wrapOwnershipConflict
-} from "./chunk-4RXTMU57.js";
+  runFiles
+} from "./chunk-TQSZFPIS.js";
+import {
+  isRemoteLinkedArtifactReference
+} from "./chunk-2JKGO6QX.js";
 import {
   runUpdate
-} from "./chunk-CIOZ376P.js";
+} from "./chunk-EACOH7AU.js";
 import {
-  resolveAuthor
-} from "./chunk-CUFW7ITY.js";
+  wrapOwnershipConflict
+} from "./chunk-UY2ACEMF.js";
 import {
   PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
   TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
   TELEMETRY_SCHEMA_VERSION,
   flushTelemetryQueueNow
-} from "./chunk-QZ7LT3XE.js";
+} from "./chunk-ONREO4ST.js";
 import {
   buildCapabilityContractMetadata,
   buildRegistrationCollisionRemediation,
   collectUnknownCapabilityGuidance,
   readManagedExtensionState,
   runInit
-} from "./chunk-DVOLZJ3C.js";
+} from "./chunk-J6EY5V4N.js";
 import {
   collectStaleVectorizationIds,
   runNext
-} from "./chunk-BPD26E3P.js";
+} from "./chunk-7Z4LKRS4.js";
 import {
   computeContentFieldUtilization
-} from "./chunk-6TTOHMTB.js";
+} from "./chunk-UXONS674.js";
 import {
   computeMetadataCoverage,
   groupItemsByDimension,
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-Q7E6OYZK.js";
+} from "./chunk-2VPAVL7O.js";
 import {
   parseLimit
-} from "./chunk-3I3LRT2G.js";
+} from "./chunk-NVPZIJVR.js";
+import {
+  resolveAuthor
+} from "./chunk-CUFW7ITY.js";
 import {
   buildVectorizationEmbeddingIdentity,
   hasVectorizationEmbeddingIdentityChanged,
@@ -61,7 +62,7 @@ import {
   resolveProviderConfigSource,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-J4NZOP3I.js";
+} from "./chunk-JXQUXVMI.js";
 import {
   ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
   ACTIVITY_FLAG_CONTRACTS,
@@ -151,7 +152,7 @@ import {
   UPGRADE_FLAG_CONTRACTS,
   VALIDATE_FLAG_CONTRACTS,
   compactFlagAliasContracts
-} from "./chunk-N3CMP4NI.js";
+} from "./chunk-3S5QVM5H.js";
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -168,12 +169,12 @@ import {
   parseLinkedTestRegexList,
   parseLinkedTestStringList,
   runCreate
-} from "./chunk-HL7V2PHX.js";
+} from "./chunk-EH2OPHBI.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-QK2ZN6UL.js";
+} from "./chunk-EJEXHTY5.js";
 import {
   CURRENT_ITEM_FORMAT_VERSION,
   compareTimestampStrings,
@@ -200,7 +201,7 @@ import {
   stableValueEquals,
   toItemRecord,
   writeSettings
-} from "./chunk-GSEADLRH.js";
+} from "./chunk-Q7A43DS4.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -242,7 +243,7 @@ import {
   statusIsTerminal,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-GXXC7QSK.js";
+} from "./chunk-QKECXBBG.js";
 
 // dist/sdk/start-task-status.js
 function resolveStartTaskInProgressStatus(statusRegistry) {
@@ -559,12 +560,12 @@ var TOOLS = [
   },
   {
     name: "pm_get",
-    description: "Read one pm item. Pass options.depth='brief' or options.fields='id,title,status' for low-token inspection.",
+    description: "Read one pm item with shared SDK projections. Pass options.depth='brief' or options.fields='id,title,status' for low-token inspection, options.fields='id,schedule.start_at' for schedule context, or options.at='7' / an ISO timestamp for a verified mutation-free historical read. Parent results include bounded child counts, samples, and continuation metadata.",
     inputSchema: objectSchema({
       id: idSchema,
       options: {
         type: "object",
-        description: "Get options such as depth=brief|standard|deep|full or fields=id,title,status."
+        description: "Get options such as depth=brief|standard|deep|full, fields=id,title,status, or at=<version|ISO timestamp>."
       }
     }, ["id"])
   },
@@ -720,7 +721,7 @@ var TOOLS = [
   },
   {
     name: "pm_deps",
-    description: "List, add, or remove dependencies for a pm item. Use options.add to declare a dependency and options.remove to drop one; omit both to list current dependencies.",
+    description: "Read dependency trees/graphs or one bounded explainable relationship context packet. Use options.format=context with depth, node, edge, token, and cursor bounds.",
     inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, [
       "id"
     ])
@@ -2372,7 +2373,7 @@ async function runContracts(options, global) {
   return result;
 }
 
-// dist/cli/commands/gc.js
+// dist/sdk/governance/gc.js
 import fs3 from "node:fs/promises";
 import path3 from "node:path";
 
@@ -2725,7 +2726,7 @@ async function runLockGc(pmRoot, options) {
   return result;
 }
 
-// dist/cli/commands/gc.js
+// dist/sdk/governance/gc.js
 var GC_SCOPE_VALUES = [
   "index",
   "embeddings",
@@ -2960,9 +2961,104 @@ async function runGc(global, options = {}) {
   };
 }
 
-// dist/cli/commands/health.js
+// dist/sdk/author-attribution.js
 import fs4 from "node:fs/promises";
 import path4 from "node:path";
+var HISTORY_AUTHOR_ATTRIBUTION_BASELINE = "2026-07-15T06:22:12.276Z";
+var HISTORY_AUTHOR_ATTRIBUTION_BASELINE_MS = Date.parse(HISTORY_AUTHOR_ATTRIBUTION_BASELINE);
+var HISTORY_AUTHOR_EVENT_CLASSIFICATIONS = [
+  ["attributed", "attributed"],
+  ["legacy_unknown", "actionable_unknown"]
+];
+var historyStringValue = (value) => typeof value === "string" ? value : "";
+var classifyHistoryAuthorEvent = (parsed) => {
+  const record = parsed ?? {};
+  const author = historyStringValue(record.author).trim().toLowerCase();
+  const authorClass = Number(["", "unknown"].includes(author));
+  const timestampClass = Number(Date.parse(historyStringValue(record.ts)) >= HISTORY_AUTHOR_ATTRIBUTION_BASELINE_MS);
+  return HISTORY_AUTHOR_EVENT_CLASSIFICATIONS[authorClass][timestampClass];
+};
+var inspectHistoryAuthorStream = (itemId, raw, sampleLimit = 20) => {
+  const samples = [];
+  const unknownCounts = {
+    legacy_unknown: 0,
+    actionable_unknown: 0
+  };
+  const boundedSampleLimit = Math.max(0, sampleLimit);
+  let checkedEvents = 0;
+  for (const [index, line] of raw.split(/\r?\n/).entries()) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    checkedEvents += 1;
+    const classification = classifyHistoryAuthorEvent(parsed);
+    if (classification === "attributed") {
+      continue;
+    }
+    unknownCounts[classification] += 1;
+    if (samples.length < boundedSampleLimit) {
+      samples.push({ item_id: itemId, line: index + 1 });
+    }
+  }
+  return {
+    checked_events: checkedEvents,
+    unknown_event_count: unknownCounts.legacy_unknown + unknownCounts.actionable_unknown,
+    legacy_unknown_event_count: unknownCounts.legacy_unknown,
+    actionable_unknown_event_count: unknownCounts.actionable_unknown,
+    samples
+  };
+};
+var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
+  const historyDirectory = path4.join(pmRoot, "history");
+  let fileNames;
+  try {
+    fileNames = (await fs4.readdir(historyDirectory)).filter((fileName) => fileName.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+  } catch {
+    fileNames = [];
+  }
+  const affectedItemIds = /* @__PURE__ */ new Set();
+  const samples = [];
+  let checkedStreams = 0;
+  let checkedEvents = 0;
+  let unknownEventCount = 0;
+  let legacyUnknownEventCount = 0;
+  let actionableUnknownEventCount = 0;
+  for (const fileName of fileNames) {
+    let raw;
+    try {
+      raw = await fs4.readFile(path4.join(historyDirectory, fileName), "utf8");
+    } catch {
+      continue;
+    }
+    const itemId = fileName.slice(0, -".jsonl".length);
+    const inspected = inspectHistoryAuthorStream(itemId, raw, sampleLimit - samples.length);
+    checkedStreams += 1;
+    checkedEvents += inspected.checked_events;
+    unknownEventCount += inspected.unknown_event_count;
+    legacyUnknownEventCount += inspected.legacy_unknown_event_count;
+    actionableUnknownEventCount += inspected.actionable_unknown_event_count;
+    if (inspected.unknown_event_count > 0) {
+      affectedItemIds.add(itemId);
+    }
+    samples.push(...inspected.samples);
+  }
+  return {
+    checked_streams: checkedStreams,
+    checked_events: checkedEvents,
+    unknown_event_count: unknownEventCount,
+    legacy_unknown_event_count: legacyUnknownEventCount,
+    actionable_unknown_event_count: actionableUnknownEventCount,
+    affected_item_ids: [...affectedItemIds].sort((left, right) => left.localeCompare(right)),
+    samples
+  };
+};
+
+// dist/sdk/governance/health.js
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
 
 // dist/core/diagnostics/remediation.js
 var REMEDIATION_REGISTRY = Object.freeze([
@@ -3111,6 +3207,11 @@ var REMEDIATION_REGISTRY = Object.freeze([
     command: "pm history-compact <id>",
     summary: "The history stream exceeds the configured compaction threshold; compact it (pm history-compact --all-streams sweeps every over-threshold stream in one pass)."
   },
+  {
+    code: "history_unknown_author_events",
+    command: "pm validate --check-history-drift --fix-hints",
+    summary: "Historical mutations lack attributable authorship. Configure PM_AUTHOR, pass global --author, or set author_default so future audit events are attributable."
+  },
   // --- pm health: locks ---
   {
     code: "locks_stale_count",
@@ -3280,6 +3381,11 @@ var REMEDIATION_REGISTRY = Object.freeze([
     command: "pm history-repair <id>",
     summary: "Re-anchor the history chains of the items with a broken history chain."
   },
+  {
+    code: "validate_history_unknown_author_events",
+    command: "pm config project set author_default <stable-agent-id>",
+    summary: "Historical mutations lack attributable authorship. Set a stable default or use invocation-wide --author for future events; existing audit history remains append-only."
+  },
   // --- pm validate: command_references ---
   {
     code: "validate_command_references_stale_pm_ids",
@@ -3323,12 +3429,12 @@ function buildRemediationCommands(warnings) {
   return Object.values(buildRemediationMap(warnings));
 }
 
-// dist/cli/commands/health.js
+// dist/sdk/governance/health.js
 var PM_TELEMETRY_SOURCE_CONTEXT_SET = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
 var STALE_VECTORIZATION_SUMMARY_LIMIT = 25;
 var BRIEF_HEALTH_DETAIL_LIMIT = 8;
-var TELEMETRY_QUEUE_RELATIVE_PATH = path4.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH = path4.join("runtime", "telemetry", "state.json");
+var TELEMETRY_QUEUE_RELATIVE_PATH = path5.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH = path5.join("runtime", "telemetry", "state.json");
 var TELEMETRY_ENDPOINT_PROBE_TIMEOUT_MS = 2500;
 var TELEMETRY_QUEUE_HIGH_WATER_MARK = 500;
 var TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD = TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS - 3;
@@ -3360,29 +3466,29 @@ function isExpectedUnmanagedExtension(name, directory) {
 }
 async function isDirectory(targetPath) {
   try {
-    const stats = await fs4.stat(targetPath);
+    const stats = await fs5.stat(targetPath);
     return stats.isDirectory();
   } catch {
     return false;
   }
 }
 async function countHistoryStreams(pmRoot, compactPolicy) {
-  const historyDir = path4.join(pmRoot, "history");
+  const historyDir = path5.join(pmRoot, "history");
   if (!await isDirectory(historyDir)) {
     return { count: 0, warnings: [], over_threshold: [], max_entries: null };
   }
-  const historyFiles = (await fs4.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+  const historyFiles = (await fs5.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   const policyActive = compactPolicy.enabled;
   const maxEntries = policyActive ? compactPolicy.max_entries : null;
   const warnings = [];
   const overThreshold = [];
   for (const fileName of historyFiles) {
-    const streamPath = path4.join(historyDir, fileName);
+    const streamPath = path5.join(historyDir, fileName);
     warnings.push(...await runActiveOnReadHooks({ path: streamPath, scope: "project" }));
     if (!policyActive) {
       continue;
     }
-    const raw = await fs4.readFile(streamPath, "utf8");
+    const raw = await fs5.readFile(streamPath, "utf8");
     let entries = 0;
     for (const line of raw.split(/\r?\n/)) {
       if (line.trim().length > 0) {
@@ -3404,16 +3510,16 @@ async function countHistoryStreams(pmRoot, compactPolicy) {
   };
 }
 function normalizeRelativePath(pmRoot, targetPath) {
-  return path4.relative(pmRoot, targetPath).replaceAll("\\", "/");
+  return path5.relative(pmRoot, targetPath).replaceAll("\\", "/");
 }
 async function listItemDocumentPaths(pmRoot, typeToFolder) {
   const folders = [...new Set(Object.values(typeToFolder))].sort((left, right) => left.localeCompare(right));
   const itemPaths = [];
   for (const folder of folders) {
-    const directoryPath = path4.join(pmRoot, folder);
+    const directoryPath = path5.join(pmRoot, folder);
     let entries = [];
     try {
-      entries = await fs4.readdir(directoryPath);
+      entries = await fs5.readdir(directoryPath);
     } catch (error) {
       if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
         continue;
@@ -3424,7 +3530,7 @@ async function listItemDocumentPaths(pmRoot, typeToFolder) {
       if (!ITEM_FILE_EXTENSIONS.some((extension) => entry.toLowerCase().endsWith(extension))) {
         continue;
       }
-      itemPaths.push(path4.join(directoryPath, entry));
+      itemPaths.push(path5.join(directoryPath, entry));
     }
   }
   itemPaths.sort((left, right) => normalizeRelativePath(pmRoot, left).localeCompare(normalizeRelativePath(pmRoot, right)));
@@ -3444,7 +3550,7 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
     const relativePath = normalizeRelativePath(pmRoot, itemPath);
     let raw = "";
     try {
-      raw = await fs4.readFile(itemPath, "utf8");
+      raw = await fs5.readFile(itemPath, "utf8");
     } catch {
       itemUnreadable.push(relativePath);
       continue;
@@ -3473,13 +3579,13 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
     }
   }
   const formatVersionScan = scanItemFormatVersions(formatVersionEntries);
-  const historyDir = path4.join(pmRoot, "history");
+  const historyDir = path5.join(pmRoot, "history");
   const historyUnreadable = [];
   const historyConflictMarkers = [];
   const historyInvalidJson = [];
   let historyFiles = [];
   try {
-    historyFiles = (await fs4.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+    historyFiles = (await fs5.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   } catch (error) {
     if (shouldReportHistoryDirectoryUnreadable(error)) {
       historyUnreadable.push("history");
@@ -3487,10 +3593,10 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
   }
   for (const fileName of historyFiles) {
     const itemId = fileName.slice(0, -".jsonl".length);
-    const historyPath = path4.join(historyDir, fileName);
+    const historyPath = path5.join(historyDir, fileName);
     let raw = "";
     try {
-      raw = await fs4.readFile(historyPath, "utf8");
+      raw = await fs5.readFile(historyPath, "utf8");
     } catch {
       historyUnreadable.push(itemId);
       continue;
@@ -3966,8 +4072,19 @@ var HEALTH_DETAIL_SUMMARIZERS = {
       capability_guidance: summarizeRecordList(details.capability_guidance, limit)
     };
   },
-  // Storage details are already compact counters; keep the pre-refactor pass-through shape.
-  storage: (details) => details,
+  storage: (details, limit) => {
+    const authorAttribution = typeof details.author_attribution === "object" && details.author_attribution !== null ? details.author_attribution : void 0;
+    return {
+      ...details,
+      ...authorAttribution ? {
+        author_attribution: {
+          ...authorAttribution,
+          affected_item_ids: summarizeStringList(authorAttribution.affected_item_ids, limit),
+          samples: summarizeRecordList(authorAttribution.samples, limit)
+        }
+      } : {}
+    };
+  },
   locks: (details) => ({
     active_lock_count: details.active_lock_count,
     stale_lock_count: details.stale_lock_count,
@@ -4273,8 +4390,8 @@ async function probeTelemetryEndpointHealth(endpoint) {
 }
 async function buildTelemetryCheck(settings, options) {
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  const queuePath = path4.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
-  const statePath = path4.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
+  const queuePath = path5.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
+  const statePath = path5.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
   const queueRaw = await readFileIfExists(queuePath);
   const queueExists = queueRaw !== null;
   const queueSizeBytes = queueRaw ? Buffer.byteLength(queueRaw, "utf8") : 0;
@@ -4605,7 +4722,7 @@ async function scanHealthDirectories(pmRoot, typeRegistry, strictDirectories) {
   const missingOptionalDirs = [];
   const hookWarnings = [];
   for (const relativeDir of [...requiredDirs, ...optionalDirs]) {
-    const directoryPath = path4.join(pmRoot, relativeDir);
+    const directoryPath = path5.join(pmRoot, relativeDir);
     hookWarnings.push(...await runActiveOnReadHooks({
       path: directoryPath,
       scope: "project"
@@ -4685,13 +4802,20 @@ function buildSettingsValuesHealthCheck(settingWarnings) {
     details: { warnings: settingWarnings }
   };
 }
-function buildStorageHealthCheck(items, settings, historySummary) {
+var resolveUnknownAuthorEventCount = (authorAttribution) => authorAttribution.unknown_event_count ?? 0;
+var resolveActionableUnknownAuthorEventCount = (authorAttribution) => authorAttribution.actionable_unknown_event_count ?? resolveUnknownAuthorEventCount(authorAttribution);
+function buildStorageHealthCheck(items, settings, historySummary, authorAttribution) {
+  const unknownAuthorEventCount = resolveUnknownAuthorEventCount(authorAttribution);
+  const actionableUnknownAuthorEventCount = resolveActionableUnknownAuthorEventCount(authorAttribution);
+  const hasAuthorEvents = unknownAuthorEventCount > 0;
+  const hasActionableAuthorWarnings = actionableUnknownAuthorEventCount > 0;
   return {
     name: "storage",
-    status: historySummary.over_threshold.length === 0 ? "ok" : "warn",
+    status: historySummary.over_threshold.length === 0 && !hasActionableAuthorWarnings ? "ok" : "warn",
     details: {
       items: items.length,
       history_streams: historySummary.count,
+      ...hasAuthorEvents ? { author_attribution: authorAttribution } : {},
       ...historySummary.max_entries !== null ? {
         compact_policy: {
           enabled: settings.history.compact_policy.enabled,
@@ -4714,6 +4838,7 @@ function collectHealthWarnings(params) {
     ...params.extensionCheck.warnings,
     ...params.historyPolicyWarnings,
     ...params.historySummary.warnings,
+    ...params.authorAttributionWarnings,
     ...params.locksCheck.warnings,
     ...params.integrityCheck.warnings,
     ...params.historyDriftCheck.warnings,
@@ -4733,7 +4858,10 @@ function buildHealthRemediationSources(params) {
     settings_values: params.settingWarnings,
     telemetry: params.telemetryCheck.warnings,
     extensions: params.extensionCheck.warnings,
-    storage: params.historySummary.over_threshold.map((id) => `history_stream_over_compact_threshold:${id}`),
+    storage: [
+      ...params.historySummary.over_threshold.map((id) => `history_stream_over_compact_threshold:${id}`),
+      ...params.authorAttributionWarnings
+    ],
     locks: params.locksCheck.warnings,
     integrity: params.integrityCheck.warnings,
     history_drift: params.historyDriftCheck.warnings,
@@ -4807,6 +4935,9 @@ async function runHealth(global, options = {}) {
     commandLabel: "health"
   });
   const historySummary = await countHistoryStreams(pmRoot, settings.history.compact_policy);
+  const authorAttribution = await scanHistoryAuthorAttribution(pmRoot);
+  const actionableUnknownAuthorEventCount = resolveActionableUnknownAuthorEventCount(authorAttribution);
+  const authorAttributionWarnings = actionableUnknownAuthorEventCount > 0 ? [`history_unknown_author_events:${actionableUnknownAuthorEventCount}`] : [];
   const locksCheck = await buildLocksCheck(pmRoot);
   const integrityCheck = skipPolicy.skipIntegrity ? buildSkippedHealthCheck("integrity") : await buildIntegrityCheck(pmRoot, typeRegistry.type_to_folder, settings.schema);
   const historyDriftCheck = skipPolicy.skipDrift ? buildSkippedHealthCheck("history_drift") : await buildHistoryDriftCheck(pmRoot, itemsWithBody);
@@ -4817,7 +4948,7 @@ async function runHealth(global, options = {}) {
     buildSettingsValuesHealthCheck(settingWarnings),
     telemetryCheck.check,
     extensionCheck.check,
-    buildStorageHealthCheck(items, settings, historySummary),
+    buildStorageHealthCheck(items, settings, historySummary, authorAttribution),
     locksCheck.check,
     integrityCheck.check,
     historyDriftCheck.check,
@@ -4832,6 +4963,7 @@ async function runHealth(global, options = {}) {
     extensionCheck,
     historyPolicyWarnings: historyPolicy.warnings,
     historySummary,
+    authorAttributionWarnings,
     locksCheck,
     integrityCheck,
     historyDriftCheck,
@@ -4846,6 +4978,7 @@ async function runHealth(global, options = {}) {
       telemetryCheck,
       extensionCheck,
       historySummary,
+      authorAttributionWarnings,
       locksCheck,
       integrityCheck,
       historyDriftCheck,
@@ -4863,6 +4996,29 @@ async function runHealth(global, options = {}) {
   };
   return projectHealthResult(result, options, skipPolicy.summaryMode);
 }
+var _testOnlyHealthCommand = {
+  buildExtensionHealthTriageSummary,
+  buildCapabilityContractMetadata,
+  buildVectorizationProviderDetails,
+  collectUnknownCapabilityGuidance,
+  isAdvisoryHealthWarning,
+  isDirectory,
+  isExpectedUnmanagedExtension,
+  listItemDocumentPaths,
+  normalizeEndpointForDisplay,
+  normalizeExtensionNameForMatch,
+  parseTelemetryQueue,
+  probeTelemetryEndpointHealth,
+  resolveActionableUnknownAuthorEventCount,
+  resolveUnknownAuthorEventCount,
+  selectStaleItemDetail,
+  summarizeHealthCheckDetails,
+  summarizeExtensionList,
+  summarizeRecordList,
+  summarizeStringList,
+  telemetryEnvFlagEnabled,
+  warningCode
+};
 
 // dist/cli/commands/scheduling-shortcuts.js
 var DEFAULT_DURATION = "1h";
@@ -4927,8 +5083,8 @@ function runRemind(title, options, global) {
 }
 
 // dist/cli/commands/stats.js
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import fs6 from "node:fs/promises";
+import path6 from "node:path";
 
 // dist/core/history/history-storage-stats.js
 function shouldReplaceExtreme(candidate, current, candidateTieBreaker, currentTieBreaker, direction, tieDirection = "min") {
@@ -5038,7 +5194,7 @@ function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 async function readHistoryStreamContents(pmRoot) {
-  const historyDir = path5.join(pmRoot, "history");
+  const historyDir = path6.join(pmRoot, "history");
   if (!await pathExists(historyDir)) {
     return [];
   }
@@ -5046,13 +5202,13 @@ async function readHistoryStreamContents(pmRoot) {
     path: historyDir,
     scope: "project"
   });
-  const historyFiles = (await fs5.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((a, b) => a.localeCompare(b));
+  const historyFiles = (await fs6.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((a, b) => a.localeCompare(b));
   const streams = [];
   for (const file of historyFiles) {
-    const historyPath = path5.join(historyDir, file);
+    const historyPath = path6.join(historyDir, file);
     let raw;
     try {
-      raw = await fs5.readFile(historyPath, "utf8");
+      raw = await fs6.readFile(historyPath, "utf8");
     } catch (error) {
       if (isNotFoundError(error)) {
         continue;
@@ -5127,11 +5283,11 @@ async function runStats(global, options = {}) {
 }
 
 // dist/cli/commands/telemetry.js
-import fs6 from "node:fs/promises";
-import path6 from "node:path";
-var TELEMETRY_QUEUE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "state.json");
-var TELEMETRY_RUNTIME_RELATIVE_PATH = path6.join("runtime", "telemetry");
+import fs7 from "node:fs/promises";
+import path7 from "node:path";
+var TELEMETRY_QUEUE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "state.json");
+var TELEMETRY_RUNTIME_RELATIVE_PATH = path7.join("runtime", "telemetry");
 var DEFAULT_STATS_LIMIT = 20;
 var TELEMETRY_SUBCOMMANDS = [
   "status",
@@ -5308,8 +5464,8 @@ async function readTelemetryRuntimeState(statePath) {
 }
 async function buildTelemetryStatusSummary(globalPmRoot) {
   const settings = await readSettings(globalPmRoot);
-  const queuePath = path6.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
-  const statePath = path6.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
+  const queuePath = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
+  const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
   const queueRaw = await readFileIfExists(queuePath);
   const queue = parseTelemetryQueue2(queueRaw);
   const runtimeState = await readTelemetryRuntimeState(statePath);
@@ -5339,8 +5495,8 @@ async function runTelemetry(options, _global) {
   void _global;
   const subcommand = normalizeTelemetrySubcommand(options.subcommand);
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  const queuePath = path6.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
-  const statePath = path6.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
+  const queuePath = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
+  const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
   if (subcommand === "status") {
     return {
       action: "telemetry",
@@ -5393,9 +5549,9 @@ async function runTelemetry(options, _global) {
   if (settingsChanged) {
     await writeSettings(globalPmRoot, settings, "telemetry:clear");
   }
-  const telemetryRuntimePath = path6.join(globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
+  const telemetryRuntimePath = path7.join(globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
   const existed = await pathExists(telemetryRuntimePath);
-  await fs6.rm(telemetryRuntimePath, { recursive: true, force: true });
+  await fs7.rm(telemetryRuntimePath, { recursive: true, force: true });
   const queueExistsAfter = await pathExists(queuePath);
   const stateExistsAfter = await pathExists(statePath);
   return {
@@ -5414,7 +5570,7 @@ async function runTelemetry(options, _global) {
 import { spawn } from "node:child_process";
 import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 
 // dist/core/test/item-test-run-tracking.js
 var DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT = 20;
@@ -5569,14 +5725,227 @@ function resolveLinkedTestRunSelection(tests, selector) {
   };
 }
 
-// dist/cli/commands/test/linked-command-detection.js
-var PM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--path"]);
-var NPX_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
-  "-p",
-  "--package",
-  "-c",
-  "--call"
+// dist/sdk/test/linked-command-detection.js
+var PM_SUBCOMMANDS_WITH_ITEM_REFERENCE = /* @__PURE__ */ new Set([
+  "get",
+  "history",
+  "restore",
+  "update",
+  "close",
+  "delete",
+  "append",
+  "claim",
+  "release",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "docs",
+  "deps",
+  "test"
+]);
+var PM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "--pm-path",
+  "--path",
+  "--author"
 ]);
+var PM_ITEM_REFERENCE_FLAGS_WITH_VALUE = {
+  get: /* @__PURE__ */ new Set([
+    "--depth",
+    "--fields",
+    "--tree-depth",
+    "--tree_depth",
+    "--at",
+    "--format"
+  ]),
+  history: /* @__PURE__ */ new Set(["--limit", "--field", "--format"]),
+  restore: /* @__PURE__ */ new Set(["--message"]),
+  update: /* @__PURE__ */ new Set([
+    "--title",
+    "-t",
+    "--description",
+    "-d",
+    "--body",
+    "-b",
+    "--status",
+    "-s",
+    "--close-reason",
+    "--close_reason",
+    "--priority",
+    "-p",
+    "--type",
+    "--tags",
+    "--add-tags",
+    "--add_tags",
+    "--remove-tags",
+    "--remove_tags",
+    "--deadline",
+    "--estimated-minutes",
+    "--estimate",
+    "--estimated_minutes",
+    "--acceptance-criteria",
+    "--ac",
+    "--acceptance_criteria",
+    "--definition-of-ready",
+    "--definition_of_ready",
+    "--order",
+    "--rank",
+    "--goal",
+    "--objective",
+    "--value",
+    "--impact",
+    "--outcome",
+    "--why-now",
+    "--why_now",
+    "--message",
+    "--assignee",
+    "--parent",
+    "--reviewer",
+    "--risk",
+    "--confidence",
+    "--sprint",
+    "--release",
+    "--blocked-by",
+    "--blocked_by",
+    "--blocked-reason",
+    "--blocked_reason",
+    "--unblock-note",
+    "--unblock_note",
+    "--reporter",
+    "--severity",
+    "--environment",
+    "--repro-steps",
+    "--repro_steps",
+    "--resolution",
+    "--expected-result",
+    "--expected_result",
+    "--expected",
+    "--actual-result",
+    "--actual_result",
+    "--actual",
+    "--affected-version",
+    "--affected_version",
+    "--fixed-version",
+    "--fixed_version",
+    "--component",
+    "--regression",
+    "--customer-impact",
+    "--customer_impact",
+    "--dep",
+    "--dep-remove",
+    "--dep_remove",
+    "--comment",
+    "--note",
+    "--learning",
+    "--file",
+    "--test",
+    "--doc",
+    "--reminder",
+    "--event",
+    "--type-option",
+    "--type_option",
+    "--field",
+    "--unset",
+    "--body-file"
+  ]),
+  close: /* @__PURE__ */ new Set([
+    "--reason",
+    "-r",
+    "--close-reason",
+    "--duplicate-of",
+    "-d",
+    "--message",
+    "-m",
+    "--validate-close",
+    "--resolution",
+    "--expected-result",
+    "--expected_result",
+    "--expected",
+    "--actual-result",
+    "--actual_result",
+    "--actual"
+  ]),
+  delete: /* @__PURE__ */ new Set(["--message"]),
+  append: /* @__PURE__ */ new Set(["--body", "--text", "--message"]),
+  claim: /* @__PURE__ */ new Set([
+    "--assignee",
+    "--message",
+    "--type",
+    "--tag",
+    "--priority",
+    "--assignee-filter",
+    "--parent",
+    "--sprint",
+    "--release",
+    "--max-attempts"
+  ]),
+  release: /* @__PURE__ */ new Set(["--assignee", "--message"]),
+  comments: /* @__PURE__ */ new Set([
+    "--add",
+    "--body",
+    "--comment",
+    "--file",
+    "--edit",
+    "--delete",
+    "--limit",
+    "--message"
+  ]),
+  notes: /* @__PURE__ */ new Set([
+    "--add",
+    "--file",
+    "--edit",
+    "--delete",
+    "--limit",
+    "--message"
+  ]),
+  learnings: /* @__PURE__ */ new Set([
+    "--add",
+    "--file",
+    "--edit",
+    "--delete",
+    "--limit",
+    "--message"
+  ]),
+  files: /* @__PURE__ */ new Set([
+    "--add",
+    "--add-glob",
+    "--remove",
+    "--migrate",
+    "--note",
+    "--message"
+  ]),
+  docs: /* @__PURE__ */ new Set([
+    "--add",
+    "--add-glob",
+    "--remove",
+    "--migrate",
+    "--note",
+    "--message"
+  ]),
+  deps: /* @__PURE__ */ new Set([
+    "--format",
+    "--max-depth",
+    "--collapse",
+    "--node-limit",
+    "--edge-limit",
+    "--token-budget",
+    "--cursor"
+  ]),
+  test: /* @__PURE__ */ new Set([
+    "--add",
+    "--add-json",
+    "--remove",
+    "--match",
+    "--only-index",
+    "--timeout",
+    "--env-set",
+    "--env-clear",
+    "--pm-context",
+    "--message"
+  ])
+};
+var NPX_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-p", "--package"]);
+var NPX_COMMAND_STRING_FLAGS = /* @__PURE__ */ new Set(["-c", "--call"]);
 var PNPM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
   "-c",
   "-C",
@@ -5606,6 +5975,37 @@ var SCRIPT_RUN_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
 function splitNormalizedCommandSegments(normalizedCommand) {
   return normalizedCommand.split(/&&|\|\||\||;/).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
 }
+function extractPmInvocationArgsFromSegment(segment) {
+  const tokens = stripLeadingEnvAssignments(segment.split(" ").filter((token) => token.length > 0));
+  if (tokens.length === 0)
+    return null;
+  const [executable, ...args] = tokens;
+  if (isPmExecutableToken(executable) || isPmCliScriptToken(executable)) {
+    return args;
+  }
+  if (executable === "node" && args[0] && isPmCliScriptToken(args[0])) {
+    return args.slice(1);
+  }
+  const invocation = executable === "npx" || executable === "bunx" ? parseNpxCommand(args) : executable === "pnpm" ? parsePnpmDlxCommand(args) : executable === "npm" ? parseNpmExecCommand(args) : null;
+  return invocation && (isPmExecutableToken(invocation.command) || isPmCliPackageToken(invocation.command)) ? invocation.args : null;
+}
+var extractReferencedPmItemIdsFromCommand = (command, idPrefix = "pm") => {
+  const normalizedPrefix = idPrefix.trim().toLowerCase().replace(/-+$/, "");
+  if (normalizedPrefix.length === 0)
+    return [];
+  const normalizedCommand = command.trim().replaceAll("\\", "/").replaceAll('"', "").replaceAll("'", "").replaceAll(/\s+/g, " ").toLowerCase();
+  const ids = /* @__PURE__ */ new Set();
+  for (const segment of splitNormalizedCommandSegments(normalizedCommand)) {
+    const invocationArgs = extractPmInvocationArgsFromSegment(segment);
+    const context = invocationArgs ? resolvePmSubcommandContext(invocationArgs) : null;
+    const candidate = context && PM_SUBCOMMANDS_WITH_ITEM_REFERENCE.has(context.subcommand) ? firstPositionalToken(context.remaining, PM_ITEM_REFERENCE_FLAGS_WITH_VALUE[context.subcommand]) : void 0;
+    const normalizedCandidate = candidate?.trim().toLowerCase();
+    if (normalizedCandidate?.startsWith(`${normalizedPrefix}-`) === true && normalizedCandidate.length > normalizedPrefix.length + 1) {
+      ids.add(candidate);
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+};
 function stripLeadingEnvAssignments(tokens) {
   let start = 0;
   if (tokens[start] === "env") {
@@ -5675,15 +6075,16 @@ function parseNpxCommand(tokens) {
     if (!token.startsWith("-")) {
       break;
     }
-    if (token.includes("=")) {
-      index += 1;
-      continue;
+    const inlineCommandMatch = /^(?:-c|--call)=(.*)$/.exec(token);
+    if (inlineCommandMatch) {
+      const command2 = inlineCommandMatch[1];
+      return command2 ? { command: command2, args: tokens.slice(index + 1) } : null;
     }
-    if (NPX_FLAGS_WITH_VALUE.has(token)) {
-      index += 2;
-      continue;
+    if (NPX_COMMAND_STRING_FLAGS.has(token)) {
+      index += 1;
+      break;
     }
-    index += 1;
+    index += NPX_FLAGS_WITH_VALUE.has(token) && !token.includes("=") ? 2 : 1;
   }
   const command = tokens[index];
   if (!command) {
@@ -5758,11 +6159,18 @@ function resolvePmSubcommandContext(args) {
   }
   return null;
 }
-function firstPositionalToken(tokens) {
-  for (const token of tokens) {
+function firstPositionalToken(tokens, flagsWithValue = /* @__PURE__ */ new Set()) {
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--") {
+      return tokens[index + 1];
+    }
     if (!token.startsWith("-")) {
       return token;
     }
+    if (!token.includes("=") && (PM_GLOBAL_FLAGS_WITH_VALUE.has(token) || flagsWithValue.has(token))) {
+      index += 1;
+    }
   }
   return void 0;
 }
@@ -5793,24 +6201,6 @@ var LINKED_TEST_INFRA_COLLISION_PATTERNS = [
   /web server[^.\n]*already running/i,
   /failed to listen on/i
 ];
-var PM_SUBCOMMANDS_WITH_ITEM_REFERENCE = /* @__PURE__ */ new Set([
-  "get",
-  "history",
-  "restore",
-  "update",
-  "close",
-  "delete",
-  "append",
-  "claim",
-  "release",
-  "comments",
-  "notes",
-  "learnings",
-  "files",
-  "docs",
-  "deps",
-  "test"
-]);
 var PM_TRACKER_READ_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "activity",
   "calendar",
@@ -5987,51 +6377,6 @@ function mergeEnvClearDirectives(entries, optionName) {
   }
   return [...new Set(values)];
 }
-function looksLikePrefixedItemId(token, idPrefix) {
-  const normalizedPrefix = idPrefix.trim().toLowerCase().replace(/-+$/, "");
-  if (normalizedPrefix.length === 0) {
-    return false;
-  }
-  const normalized = token.trim().toLowerCase();
-  if (!normalized.startsWith(`${normalizedPrefix}-`)) {
-    return false;
-  }
-  return normalized.length > normalizedPrefix.length + 1;
-}
-function extractPmInvocationArgsFromSegment(segment) {
-  const rawTokens = segment.split(" ").filter((token) => token.length > 0);
-  const tokens = stripLeadingEnvAssignments(rawTokens);
-  if (tokens.length === 0) {
-    return null;
-  }
-  const [executable, ...args] = tokens;
-  if (isPmExecutableToken(executable) || isPmCliScriptToken(executable)) {
-    return args;
-  }
-  if (executable === "node" && args.length > 0 && isPmCliScriptToken(args[0])) {
-    return args.slice(1);
-  }
-  return extractPackageManagerPmInvocationArgs(executable, args);
-}
-function extractPackageManagerPmInvocationArgs(executable, args) {
-  const parsed = parsePackageManagerPmInvocation(executable, args);
-  if (!parsed || !isPmExecutableToken(parsed.command) && !isPmCliPackageToken(parsed.command)) {
-    return null;
-  }
-  return parsed.args;
-}
-function parsePackageManagerPmInvocation(executable, args) {
-  if (executable === "npx" || executable === "bunx") {
-    return parseNpxCommand(args);
-  }
-  if (executable === "pnpm") {
-    return parsePnpmDlxCommand(args);
-  }
-  if (executable === "npm") {
-    return parseNpmExecCommand(args);
-  }
-  return null;
-}
 function commandInvokesPmCli(command) {
   const normalizedCommand = normalizeCommandForValidation(command);
   return splitNormalizedCommandSegments(normalizedCommand).some((segment) => extractPmInvocationArgsFromSegment(segment) !== null);
@@ -6050,31 +6395,6 @@ function commandInvokesPmTrackerReadCommand(command) {
     return PM_TRACKER_READ_SUBCOMMANDS.has(context.subcommand);
   });
 }
-function extractReferencedPmItemIdsFromCommand(command, idPrefix = "pm") {
-  const normalizedCommand = normalizeCommandForValidation(command);
-  const ids = /* @__PURE__ */ new Set();
-  for (const segment of splitNormalizedCommandSegments(normalizedCommand)) {
-    const invocationArgs = extractPmInvocationArgsFromSegment(segment);
-    if (!invocationArgs) {
-      continue;
-    }
-    const context = resolvePmSubcommandContext(invocationArgs);
-    if (!context) {
-      continue;
-    }
-    if (!PM_SUBCOMMANDS_WITH_ITEM_REFERENCE.has(context.subcommand)) {
-      continue;
-    }
-    const candidate = firstPositionalToken(context.remaining);
-    if (!candidate) {
-      continue;
-    }
-    if (looksLikePrefixedItemId(candidate, idPrefix)) {
-      ids.add(candidate);
-    }
-  }
-  return [...ids].sort((left, right) => left.localeCompare(right));
-}
 function resolveDirectRunnerSubcommand(parsed) {
   if (!parsed) {
     return void 0;
@@ -6184,7 +6504,7 @@ function packageManagerInvokesUnsafeDirectTestRunner(executable, args) {
     return isDirectTestRunnerSubcommand(parseNpxCommand(args)?.command);
   }
   if (executable === "pnpm" || executable === "npm") {
-    return isDirectTestRunnerSubcommand(parsePackageManagerPmInvocation(executable, args)?.command) || firstDirectTestRunnerSubcommand(executable, args) === "vitest";
+    return isDirectTestRunnerSubcommand((executable === "pnpm" ? parsePnpmDlxCommand(args) : parseNpmExecCommand(args))?.command) || firstDirectTestRunnerSubcommand(executable, args) === "vitest";
   }
   return (executable === "yarn" || executable === "bun") && firstDirectTestRunnerSubcommand(executable, args) === "vitest";
 }
@@ -6661,7 +6981,7 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
   if (!await pathExists(sourcePath)) {
     return;
   }
-  await mkdir(path7.dirname(targetPath), { recursive: true });
+  await mkdir(path8.dirname(targetPath), { recursive: true });
   try {
     if (recursive) {
       await cp(sourcePath, targetPath, { recursive: true, force: true });
@@ -6677,9 +6997,9 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
 }
 async function seedLinkedTestSandbox(sandboxPmPath, sandboxGlobalPath, sourceRoots) {
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.projectPmRoot), getSettingsPath(sandboxPmPath));
-  await copyIntoSandboxIfPresent(path7.join(sourceRoots.projectPmRoot, "extensions"), path7.join(sandboxPmPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path8.join(sourceRoots.projectPmRoot, "extensions"), path8.join(sandboxPmPath, "extensions"), true);
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.globalPmRoot), getSettingsPath(sandboxGlobalPath));
-  await copyIntoSandboxIfPresent(path7.join(sourceRoots.globalPmRoot, "extensions"), path7.join(sandboxGlobalPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path8.join(sourceRoots.globalPmRoot, "extensions"), path8.join(sandboxGlobalPath, "extensions"), true);
 }
 async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
   if (!await pathExists(sourceRoot)) {
@@ -6690,8 +7010,8 @@ async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
     if (LINKED_TEST_TRACKER_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const sourcePath = path7.join(sourceRoot, entry.name);
-    const targetPath = path7.join(sandboxRoot, entry.name);
+    const sourcePath = path8.join(sourceRoot, entry.name);
+    const targetPath = path8.join(sandboxRoot, entry.name);
     if (entry.isDirectory()) {
       await copyIntoSandboxIfPresent(sourcePath, targetPath, true);
       continue;
@@ -6711,7 +7031,7 @@ async function countLinkedTestItemFiles(pmRoot) {
     if (!entry.isDirectory() || LINKED_TEST_ITEM_COUNT_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const folderPath = path7.join(pmRoot, entry.name);
+    const folderPath = path8.join(pmRoot, entry.name);
     let files;
     try {
       files = await readdir(folderPath, { withFileTypes: true });
@@ -6906,10 +7226,10 @@ ${stderr}`;
 function createLinkedTestSandboxLayout(sandboxRoot) {
   return {
     root: sandboxRoot,
-    schemaProjectPmPath: path7.join(sandboxRoot, "schema", "project", ".agents", "pm"),
-    schemaGlobalPmPath: path7.join(sandboxRoot, "schema", "global"),
-    trackerProjectPmPath: path7.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
-    trackerGlobalPmPath: path7.join(sandboxRoot, "tracker", "global")
+    schemaProjectPmPath: path8.join(sandboxRoot, "schema", "project", ".agents", "pm"),
+    schemaGlobalPmPath: path8.join(sandboxRoot, "schema", "global"),
+    trackerProjectPmPath: path8.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
+    trackerGlobalPmPath: path8.join(sandboxRoot, "tracker", "global")
   };
 }
 async function initializeLinkedTestSandboxes(layout) {
@@ -7109,7 +7429,7 @@ async function runSingleLinkedTest(params) {
 }
 async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
   const results = [];
-  const sandboxRoot = await mkdtemp(path7.join(tmpdir(), "pm-linked-test-"));
+  const sandboxRoot = await mkdtemp(path8.join(tmpdir(), "pm-linked-test-"));
   const layout = createLinkedTestSandboxLayout(sandboxRoot);
   const runLevelPmContextMode = parsePmContextMode(options?.pmContext);
   const progressMode = options?.progress === true ? "always" : "auto";
@@ -7768,10 +8088,10 @@ async function runTestAll(options, global) {
 import os from "node:os";
 
 // dist/core/test/background-runs.js
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import path8 from "node:path";
+import path9 from "node:path";
 var BACKGROUND_RUN_ACTIVE_STATUSES = /* @__PURE__ */ new Set([
   "queued",
   "running"
@@ -7809,7 +8129,7 @@ function buildBackgroundTestRunFingerprint(kind, commandArgs, pmRoot) {
   const payload = {
     kind,
     command: normalizeCommandArgs(commandArgs),
-    pm_root: path8.resolve(pmRoot)
+    pm_root: path9.resolve(pmRoot)
   };
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -7864,8 +8184,8 @@ async function listBackgroundRunRecordPaths(pmRoot) {
   if (!await pathExists(recordsRoot)) {
     return [];
   }
-  const entries = await fs7.readdir(recordsRoot, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path8.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
+  const entries = await fs8.readdir(recordsRoot, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path9.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
 }
 function parseLinuxRssStatus(raw) {
   const match = raw.match(/^VmRSS:\s+(\d+)\s+kB$/m);
@@ -7879,7 +8199,7 @@ async function readLinuxRssBytes(pid) {
     return void 0;
   }
   try {
-    const raw = await fs7.readFile(`/proc/${pid}/status`, "utf8");
+    const raw = await fs8.readFile(`/proc/${pid}/status`, "utf8");
     return parseLinuxRssStatus(raw);
   } catch {
     return void 0;
@@ -7907,7 +8227,7 @@ async function readLinuxCpuSeconds(pid) {
     return {};
   }
   try {
-    const raw = await fs7.readFile(`/proc/${pid}/stat`, "utf8");
+    const raw = await fs8.readFile(`/proc/${pid}/stat`, "utf8");
     return parseLinuxCpuStat(raw);
   } catch {
     return {};
@@ -8043,18 +8363,18 @@ function tailLines(value, limit) {
 async function resolveBackgroundCliEntry(cwd) {
   const configured = process.env.PM_BACKGROUND_CLI_ENTRY?.trim();
   if (configured && configured.length > 0) {
-    const resolvedConfigured = path8.resolve(cwd, configured);
+    const resolvedConfigured = path9.resolve(cwd, configured);
     if (await pathExists(resolvedConfigured)) {
       return resolvedConfigured;
     }
   }
-  const distEntry = path8.resolve(cwd, "dist", "cli.js");
+  const distEntry = path9.resolve(cwd, "dist", "cli.js");
   if (await pathExists(distEntry)) {
     return distEntry;
   }
   const argvEntry = process.argv[1]?.trim();
   if (argvEntry && argvEntry.length > 0) {
-    const resolvedArgvEntry = path8.resolve(cwd, argvEntry);
+    const resolvedArgvEntry = path9.resolve(cwd, argvEntry);
     if (await pathExists(resolvedArgvEntry)) {
       return resolvedArgvEntry;
     }
@@ -8111,8 +8431,8 @@ async function startBackgroundTestRun(options) {
   const stdoutPath = getTestRunStdoutPath(options.pmRoot, runId);
   const stderrPath = getTestRunStderrPath(options.pmRoot, runId);
   const resultPath = getTestRunResultPath(options.pmRoot, runId);
-  await fs7.writeFile(stdoutPath, "", "utf8");
-  await fs7.writeFile(stderrPath, "", "utf8");
+  await fs8.writeFile(stdoutPath, "", "utf8");
+  await fs8.writeFile(stderrPath, "", "utf8");
   const record = {
     id: runId,
     kind: options.kind,
@@ -8191,7 +8511,7 @@ async function spawnBackgroundTestRunWorker(options) {
 }
 async function appendFileOrdered(queue, filePath, text) {
   await queue;
-  await fs7.appendFile(filePath, text, "utf8");
+  await fs8.appendFile(filePath, text, "utf8");
 }
 function resolvePositiveEnvInteger(name, fallback) {
   const parsed = Number.parseInt(process.env[name] ?? "", 10);
@@ -8770,11 +9090,11 @@ async function runTestRunsWorker(runId, global) {
   };
 }
 
-// dist/cli/commands/validate.js
-import fs8 from "node:fs/promises";
+// dist/sdk/governance/validate.js
+import fs9 from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
-import path9 from "node:path";
+import path10 from "node:path";
 import { promisify } from "node:util";
 
 // dist/core/validate/fix-planning.js
@@ -9080,8 +9400,8 @@ function buildMissingLinkedPathRows(rows, lookup) {
       });
     }
   }
-  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path10, bucket]) => ({
-    path: path10,
+  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path11, bucket]) => ({
+    path: path11,
     classification: bucket.classification,
     items: [...bucket.owners.values()].map((owner) => {
       const metadata = lookup(owner.item_id);
@@ -9111,7 +9431,7 @@ function summarizeMissingLinkedPathRows(rows) {
   return lines;
 }
 
-// dist/cli/commands/validate.js
+// dist/sdk/governance/validate.js
 var FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
 var FILE_SCAN_ROOT_FILES = [
   "README.md",
@@ -9222,6 +9542,7 @@ var METADATA_TRUNCATED_KEY_BY_FIELD = {
   release: "missing_release_truncated"
 };
 var GIT_LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
+var GIT_LS_FILES_TIMEOUT_MS = 1e4;
 var FILE_LIST_SUMMARY_LIMIT = 40;
 var DIAGNOSTIC_LIST_SUMMARY_LIMIT = 5;
 var LINKED_ARTIFACT_MAX_PATH_LENGTH = 4096;
@@ -9417,16 +9738,16 @@ function resolveFileScanMode(scanMode) {
   throw new PmCliError(`Unknown --scan-mode value "${scanMode}". Supported values: ${VALIDATE_FILE_SCAN_MODES.join(", ")}.`, EXIT_CODE.USAGE);
 }
 function resolveWorkspaceRoot(pmRoot) {
-  const resolvedPmRoot = path9.resolve(pmRoot);
+  const resolvedPmRoot = path10.resolve(pmRoot);
   const normalizedPmRoot = resolvedPmRoot.replaceAll("\\", "/");
   if (normalizedPmRoot.endsWith("/.agents/pm")) {
-    return path9.dirname(path9.dirname(resolvedPmRoot));
+    return path10.dirname(path10.dirname(resolvedPmRoot));
   }
-  const resolvedCwd = path9.resolve(process.cwd());
+  const resolvedCwd = path10.resolve(process.cwd());
   const canonicalPmRoot = realpathForWorkspaceRoot(resolvedPmRoot);
   const canonicalCwd = realpathForWorkspaceRoot(resolvedCwd);
-  const relativeFromPmRoot = path9.relative(canonicalPmRoot, canonicalCwd);
-  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path9.isAbsolute(relativeFromPmRoot);
+  const relativeFromPmRoot = path10.relative(canonicalPmRoot, canonicalCwd);
+  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path10.isAbsolute(relativeFromPmRoot);
   if (cwdInsidePmRoot) {
     return resolvedPmRoot;
   }
@@ -9436,14 +9757,14 @@ function realpathForWorkspaceRoot(inputPath) {
   try {
     return realpathSync.native(inputPath);
   } catch {
-    return path9.resolve(inputPath);
+    return path10.resolve(inputPath);
   }
 }
 async function listFilesRecursive(basePath, relativePath, output) {
-  const targetDirectory = relativePath.length > 0 ? path9.join(basePath, relativePath) : basePath;
+  const targetDirectory = relativePath.length > 0 ? path10.join(basePath, relativePath) : basePath;
   let entries;
   try {
-    entries = await fs8.readdir(targetDirectory, { withFileTypes: true });
+    entries = await fs9.readdir(targetDirectory, { withFileTypes: true });
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return;
@@ -9454,7 +9775,7 @@ async function listFilesRecursive(basePath, relativePath, output) {
     if (entry.name.startsWith(".")) {
       continue;
     }
-    const childRelative = relativePath.length > 0 ? path9.join(relativePath, entry.name) : entry.name;
+    const childRelative = relativePath.length > 0 ? path10.join(relativePath, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (DIRECTORY_IGNORE_SET.has(entry.name)) {
         continue;
@@ -9474,9 +9795,9 @@ async function collectDefaultProjectFileCandidates(workspaceRoot) {
     await listFilesRecursive(workspaceRoot, directory, discovered);
   }
   for (const candidate of FILE_SCAN_ROOT_FILES) {
-    const absolute = path9.join(workspaceRoot, candidate);
+    const absolute = path10.join(workspaceRoot, candidate);
     try {
-      const stats = await fs8.stat(absolute);
+      const stats = await fs9.stat(absolute);
       if (stats.isFile()) {
         discovered.push(normalizeRelativePath2(candidate));
       }
@@ -9491,7 +9812,8 @@ async function collectTrackedGitFileCandidates(workspaceRoot) {
       cwd: workspaceRoot,
       encoding: "utf8",
       maxBuffer: GIT_LS_FILES_MAX_BUFFER,
-      windowsHide: true
+      windowsHide: true,
+      timeout: GIT_LS_FILES_TIMEOUT_MS
     });
     const discovered = stdout.split("\0").map((value) => normalizeRelativePath2(value)).filter((value) => value.length > 0);
     return [...new Set(discovered)].sort((left, right) => left.localeCompare(right));
@@ -9505,7 +9827,7 @@ function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
   if (configuredDefault.length > 0) {
     prefixes.add(configuredDefault);
   }
-  const relativePmRoot = normalizeRelativeDirectoryPath(path9.relative(workspaceRoot, pmRoot));
+  const relativePmRoot = normalizeRelativeDirectoryPath(path10.relative(workspaceRoot, pmRoot));
   if (relativePmRoot.length > 0 && !relativePmRoot.startsWith("..")) {
     prefixes.add(relativePmRoot);
   }
@@ -9851,7 +10173,7 @@ function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function buildLifecycleDependencyGraph(activeItems, idPrefix = "pm") {
+function buildLifecycleDependencyGraph(activeItems, idPrefix = "pm", relationshipRegistry = createRelationshipKindRegistry()) {
   const activeItemIds = new Set(activeItems.map((item) => item.id));
   const graph = /* @__PURE__ */ new Map();
   const sortedItems = [...activeItems].sort((left, right) => left.id.localeCompare(right.id));
@@ -9862,6 +10184,12 @@ function buildLifecycleDependencyGraph(activeItems, idPrefix = "pm") {
       edges.add(blockedBy);
     }
     for (const dependency of item.dependencies ?? []) {
+      const dependencyKind = toMeaningfulString(dependency.kind);
+      if (!dependencyKind)
+        continue;
+      const relationshipDefinition = relationshipRegistry.resolve(dependencyKind);
+      if (!relationshipDefinition?.ordering)
+        continue;
       const dependencyId = toMeaningfulString(dependency.id);
       if (!dependencyId || !activeItemIds.has(dependencyId)) {
         continue;
@@ -9979,30 +10307,30 @@ function resolveLifecycleDependencyCycleSamplePath(component, graph) {
     return [start, start];
   }
   const componentSet = new Set(component);
-  const path10 = [start];
+  const path11 = [start];
   const visited = /* @__PURE__ */ new Set([start]);
   const search = (current) => {
     const neighbors = (graph.get(current) ?? []).filter((candidate) => componentSet.has(candidate));
     for (const next of neighbors) {
-      if (next === start && path10.length > 1) {
-        path10.push(start);
+      if (next === start && path11.length > 1) {
+        path11.push(start);
         return true;
       }
       if (visited.has(next)) {
         continue;
       }
       visited.add(next);
-      path10.push(next);
+      path11.push(next);
       if (search(next)) {
         return true;
       }
-      path10.pop();
+      path11.pop();
       visited.delete(next);
     }
     return false;
   };
   if (search(start)) {
-    return [...path10];
+    return [...path11];
   }
   return [...component, start];
 }
@@ -10260,12 +10588,12 @@ function linkedArtifactPathExceedsFilesystemLimits(artifactPath) {
   return normalized.length > LINKED_ARTIFACT_MAX_PATH_LENGTH || normalized.split(/[\\/]/).some((segment) => segment.length > LINKED_ARTIFACT_MAX_SEGMENT_LENGTH);
 }
 async function linkedArtifactIsMissing(workspaceRoot, artifactPath) {
-  const absolutePath = path9.isAbsolute(artifactPath) ? artifactPath : path9.resolve(workspaceRoot, artifactPath);
+  const absolutePath = path10.isAbsolute(artifactPath) ? artifactPath : path10.resolve(workspaceRoot, artifactPath);
   if (linkedArtifactPathExceedsFilesystemLimits(absolutePath)) {
     return false;
   }
   try {
-    const stats = await fs8.stat(absolutePath);
+    const stats = await fs9.stat(absolutePath);
     return !stats.isFile() && !stats.isDirectory();
   } catch (error) {
     const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
@@ -10639,7 +10967,7 @@ function buildFormatVersionCheck(items, verboseDiagnostics) {
   };
 }
 var VALIDATE_AUTO_FIX_MESSAGE = "pm validate auto-fix";
-async function applyValidateFix(fix, global) {
+async function applyValidateFix(fix, global, services) {
   switch (fix.kind) {
     case "set_resolution":
     case "set_close_reason":
@@ -10660,7 +10988,10 @@ async function applyValidateFix(fix, global) {
       } else {
         updateOptions.unset = ["parent"];
       }
-      await runUpdate(fix.item_id, updateOptions, global);
+      if (!services.runUpdate) {
+        throw new PmCliError("Applying validate metadata/lifecycle fixes requires a runUpdate mutation service.", EXIT_CODE.USAGE);
+      }
+      await services.runUpdate(fix.item_id, updateOptions, global);
       return;
     }
     case "prune_file_link": {
@@ -10677,7 +11008,7 @@ function pruneBatchKey(fix) {
   }
   return `${fix.kind}:${fix.item_id}`;
 }
-async function applyValidateFixes(applicable, global) {
+async function applyValidateFixes(applicable, global, services) {
   const applied = [];
   const failed = [];
   const pruneBatches = /* @__PURE__ */ new Map();
@@ -10685,7 +11016,7 @@ async function applyValidateFixes(applicable, global) {
     const batchKey = pruneBatchKey(fix);
     if (batchKey === null) {
       try {
-        await applyValidateFix(fix, global);
+        await applyValidateFix(fix, global, services);
         applied.push(fix);
       } catch (error) {
         failed.push({ fix, error });
@@ -10718,6 +11049,44 @@ async function applyValidateFixes(applicable, global) {
   }
   return { applied, failed };
 }
+var _testOnlyValidateCommand = {
+  applyValidateFix,
+  applyValidateFixes,
+  attachValidateFixHints,
+  buildCommandReferencesCheck,
+  buildDependencyReferencesCheck,
+  buildCloseReasonBackfillRows,
+  buildFilesCheck,
+  buildLifecycleCheck,
+  buildLifecycleDependencyGraph,
+  buildLifecycleParentGraph,
+  buildEstimateBackfillRows,
+  buildMetadataCounts,
+  buildMissingFieldOccurrences,
+  buildOrphanedPathRows,
+  classifyOrphanedPath,
+  collectDefaultProjectFileCandidates,
+  collectTrackedGitFileCandidates,
+  detectLifecycleDependencyCycles,
+  detectLifecycleParentCycles,
+  escapeRegExp,
+  extractItemIds,
+  findLifecycleDependencyCycleComponents,
+  isMetadataFieldMissing,
+  linkedArtifactPathExceedsFilesystemLimits,
+  listFilesRecursive,
+  resolveDependencyCycleSeverity,
+  resolveParentCycleSeverity,
+  resolveFileScanMode,
+  resolveLifecycleDependencyCycleSamplePath,
+  resolveRequestedChecks,
+  resolveValidateMetadataProfile,
+  resolveWorkspaceRoot,
+  sharedDirectoryPrefixLength,
+  summarizeOrphanedPathRows,
+  summarizeDuplicateIssueCodes,
+  toMeaningfulString
+};
 function recordValidateCheck(state, built, fixHintsEnabled) {
   if (fixHintsEnabled) {
     attachValidateFixHints(built.check, built.warnings);
@@ -10783,7 +11152,7 @@ function planValidateFixes(options, state, settings) {
   }
   return planned;
 }
-async function buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) {
+async function buildValidateFixesSummary(options, state, settings, grantedFixScopes, global, services) {
   if (options.autoFix !== true && options.pruneMissing !== true) {
     return void 0;
   }
@@ -10793,7 +11162,7 @@ async function buildValidateFixesSummary(options, state, settings, grantedFixSco
   const appliedFixRows = [];
   const failedFixRows = [];
   if (!dryRun) {
-    const applied = await applyValidateFixes(applicable, global);
+    const applied = await applyValidateFixes(applicable, global, services);
     appliedFixRows.push(...applied.applied.map(toFixOutputRow));
     failedFixRows.push(...applied.failed.map(({ fix, error }) => ({
       ...toFixOutputRow(fix),
@@ -10818,7 +11187,7 @@ async function buildValidateFixesSummary(options, state, settings, grantedFixSco
     failed_fixes: failedFixRows
   };
 }
-async function runValidate(options, global) {
+async function runValidate(options, global, services = {}) {
   const fixesRequested = options.autoFix === true || options.pruneMissing === true;
   if (options.dryRun === true && !fixesRequested) {
     throw new PmCliError("--dry-run requires --auto-fix or --prune-missing (there is nothing to preview otherwise).", EXIT_CODE.USAGE);
@@ -10837,6 +11206,12 @@ async function runValidate(options, global) {
   const itemReadWarnings = [];
   const items = await listAllItemMetadataWithBody(pmRoot, settings.item_format, typeRegistry.type_to_folder, itemReadWarnings, settings.schema);
   const requestedChecks = resolveRequestedChecks(options);
+  if (requestedChecks.has("history_drift")) {
+    const authorAttribution = await scanHistoryAuthorAttribution(pmRoot);
+    if (authorAttribution.actionable_unknown_event_count > 0) {
+      itemReadWarnings.push(`validate_history_unknown_author_events:${authorAttribution.actionable_unknown_event_count}`);
+    }
+  }
   const metadataProfileSource = typeof options.metadataProfile === "string" ? "option" : "settings";
   const metadataProfile = resolveValidateMetadataProfile(typeof options.metadataProfile === "string" ? options.metadataProfile : settings.validation.metadata_profile);
   const metadataPolicy = resolveValidateMetadataPolicy(metadataProfile, metadataProfileSource, settings.validation.metadata_required_fields);
@@ -10861,7 +11236,7 @@ async function runValidate(options, global) {
     fileScanMode,
     initialWarnings: [...new Set(itemReadWarnings)]
   });
-  const fixes = fixesRequested ? await buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) : void 0;
+  const fixes = fixesRequested ? await buildValidateFixesSummary(options, state, settings, grantedFixScopes, global, services) : void 0;
   const normalizedWarnings = [...new Set(state.warnings)].sort((left, right) => left.localeCompare(right));
   const hasErrors = state.checks.some((check) => check.status === "error");
   return {
@@ -10874,6 +11249,11 @@ async function runValidate(options, global) {
   };
 }
 
+// dist/cli/commands/validate.js
+var runValidate2 = (options, global) => runValidate(options, global, {
+  runUpdate: (id, updateOptions, updateGlobal) => runUpdate(id, updateOptions, updateGlobal)
+});
+
 export {
   resolveStartTaskInProgressStatus,
   runClaim,
@@ -10881,7 +11261,10 @@ export {
   runRelease,
   runContracts,
   runGc,
+  inspectHistoryAuthorStream,
+  scanHistoryAuthorAttribution,
   runHealth,
+  _testOnlyHealthCommand,
   runMeet,
   runEvent,
   runRemind,
@@ -10896,8 +11279,10 @@ export {
   runTestRunsStop,
   runTestRunsResume,
   runTestRunsWorker,
-  runValidate
+  _testOnlyValidateCommand,
+  runValidate,
+  runValidate2
 };
-//# sourceMappingURL=chunk-MKL4CP2I.js.map
+//# sourceMappingURL=chunk-5ZSLZLDN.js.map
 
-//# debugId=d5e1e32d-df71-5281-bc83-9c8c5fd37e21
+//# debugId=1a18538c-3ee2-5ab6-b7c2-b913c780563a