@unbrained/pm-cli 2026.7.16 → 2026.7.17

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

@@ -1,55 +1,55 @@
 
-!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){}}();
+!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]="afd69b46-3b50-57d8-b120-4dcf45f8ff19")}catch(e){}}();
 import {
   runDocs
-} from "./chunk-IA5FKNII.js";
+} from "./chunk-X2MGQMZO.js";
 import {
   collectDanglingDependencyReferences,
   createRelationshipKindRegistry
-} from "./chunk-JFTKLTEF.js";
+} from "./chunk-YQCWK2MB.js";
 import {
   scanHistoryDrift
-} from "./chunk-SDQLJWBO.js";
+} from "./chunk-NVZ6NVHJ.js";
 import {
   runFiles
-} from "./chunk-TQSZFPIS.js";
+} from "./chunk-AFGKSHAM.js";
 import {
   isRemoteLinkedArtifactReference
-} from "./chunk-2JKGO6QX.js";
+} from "./chunk-H5IOT54C.js";
 import {
   runUpdate
-} from "./chunk-EACOH7AU.js";
+} from "./chunk-FZGM3PNA.js";
 import {
   wrapOwnershipConflict
-} from "./chunk-UY2ACEMF.js";
+} from "./chunk-ILVOOAT4.js";
 import {
   PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
   TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
   TELEMETRY_SCHEMA_VERSION,
   flushTelemetryQueueNow
-} from "./chunk-ONREO4ST.js";
+} from "./chunk-EY7ZE3TG.js";
 import {
   buildCapabilityContractMetadata,
   buildRegistrationCollisionRemediation,
   collectUnknownCapabilityGuidance,
   readManagedExtensionState,
   runInit
-} from "./chunk-J6EY5V4N.js";
+} from "./chunk-KOEZCHRF.js";
 import {
   collectStaleVectorizationIds,
   runNext
-} from "./chunk-7Z4LKRS4.js";
+} from "./chunk-SPFZV2GR.js";
 import {
   computeContentFieldUtilization
-} from "./chunk-UXONS674.js";
+} from "./chunk-SIJV365F.js";
 import {
   computeMetadataCoverage,
   groupItemsByDimension,
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-2VPAVL7O.js";
+} from "./chunk-CKX4WOPC.js";
 import {
   parseLimit
-} from "./chunk-NVPZIJVR.js";
+} from "./chunk-PT7MCCGD.js";
 import {
   resolveAuthor
 } from "./chunk-CUFW7ITY.js";
@@ -62,7 +62,7 @@ import {
   resolveProviderConfigSource,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-JXQUXVMI.js";
+} from "./chunk-AFSV5HBB.js";
 import {
   ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
   ACTIVITY_FLAG_CONTRACTS,
@@ -152,7 +152,7 @@ import {
   UPGRADE_FLAG_CONTRACTS,
   VALIDATE_FLAG_CONTRACTS,
   compactFlagAliasContracts
-} from "./chunk-3S5QVM5H.js";
+} from "./chunk-NCAFUBJX.js";
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -169,12 +169,12 @@ import {
   parseLinkedTestRegexList,
   parseLinkedTestStringList,
   runCreate
-} from "./chunk-EH2OPHBI.js";
+} from "./chunk-HTXXXF45.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-EJEXHTY5.js";
+} from "./chunk-FHOBCGQO.js";
 import {
   CURRENT_ITEM_FORMAT_VERSION,
   compareTimestampStrings,
@@ -201,7 +201,7 @@ import {
   stableValueEquals,
   toItemRecord,
   writeSettings
-} from "./chunk-Q7A43DS4.js";
+} from "./chunk-P22HGFFI.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -243,7 +243,7 @@ import {
   statusIsTerminal,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-QKECXBBG.js";
+} from "./chunk-KX62NMZC.js";
 
 // dist/sdk/start-task-status.js
 function resolveStartTaskInProgressStatus(statusRegistry) {
@@ -5082,7 +5082,7 @@ function runRemind(title, options, global) {
   return runCreate(createOptions, global);
 }
 
-// dist/cli/commands/stats.js
+// dist/sdk/stats.js
 import fs6 from "node:fs/promises";
 import path6 from "node:path";
 
@@ -5171,7 +5171,7 @@ function computeHistoryStorageStats(streams, options) {
   };
 }
 
-// dist/cli/commands/stats.js
+// dist/sdk/stats.js
 function zeroByType(itemTypes) {
   return itemTypes.reduce((acc, value) => {
     acc[value] = 0;
@@ -5190,9 +5190,6 @@ function countNonEmptyLines(raw) {
   }
   return raw.split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
 }
-function isNotFoundError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
 async function readHistoryStreamContents(pmRoot) {
   const historyDir = path6.join(pmRoot, "history");
   if (!await pathExists(historyDir)) {
@@ -5206,14 +5203,9 @@ async function readHistoryStreamContents(pmRoot) {
   const streams = [];
   for (const file of historyFiles) {
     const historyPath = path6.join(historyDir, file);
-    let raw;
-    try {
-      raw = await fs6.readFile(historyPath, "utf8");
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        continue;
-      }
-      throw error;
+    const raw = await readFileIfExists(historyPath);
+    if (raw === null) {
+      continue;
     }
     await runActiveOnReadHooks({
       path: historyPath,
@@ -5282,7 +5274,7 @@ async function runStats(global, options = {}) {
   };
 }
 
-// dist/cli/commands/telemetry.js
+// dist/sdk/telemetry.js
 import fs7 from "node:fs/promises";
 import path7 from "node:path";
 var TELEMETRY_QUEUE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "events.jsonl");
@@ -5295,19 +5287,32 @@ var TELEMETRY_SUBCOMMANDS = [
   "stats",
   "clear"
 ];
-function nearestRankPercentile(sortedAscending, fraction) {
+var nearestRankPercentile = (sortedAscending, fraction) => {
   const rank = Math.ceil(fraction * sortedAscending.length);
   const index = Math.min(sortedAscending.length - 1, Math.max(0, rank - 1));
   return sortedAscending[index];
-}
-function normalizeTelemetryQueueEntry(entry) {
-  const command = typeof entry.event.command === "string" && entry.event.command.trim().length > 0 ? entry.event.command : "<unknown>";
-  const eventType = typeof entry.event.event_type === "string" && entry.event.event_type.trim().length > 0 ? entry.event.event_type : "unknown";
-  const eventSchemaVersion = typeof entry.event.schema_version === "number" && Number.isFinite(entry.event.schema_version) ? Math.trunc(entry.event.schema_version) : void 0;
-  const clientSchemaVersion = typeof entry.client_schema_version === "number" && Number.isFinite(entry.client_schema_version) ? Math.trunc(entry.client_schema_version) : void 0;
-  return { command, eventType, eventSchemaVersion, clientSchemaVersion };
-}
-function createTelemetryStatsAccumulator() {
+};
+var normalizeTelemetryText = (value, fallback) => {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  return value.trim().length > 0 ? value : fallback;
+};
+var normalizeFiniteInteger = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.trunc(value);
+};
+var normalizeTelemetryQueueEntry = (entry) => {
+  return {
+    command: normalizeTelemetryText(entry.event.command, "<unknown>"),
+    eventType: normalizeTelemetryText(entry.event.event_type, "unknown"),
+    eventSchemaVersion: normalizeFiniteInteger(entry.event.schema_version),
+    clientSchemaVersion: normalizeFiniteInteger(entry.client_schema_version)
+  };
+};
+var createTelemetryStatsAccumulator = () => {
   return {
     count: 0,
     max_attempts: 0,
@@ -5319,9 +5324,20 @@ function createTelemetryStatsAccumulator() {
     error_count: 0,
     resolution_counts: {}
   };
-}
-function recordTelemetryFinishPayload(current, payload) {
-  const durationMs = typeof payload?.duration_ms === "number" && Number.isFinite(payload.duration_ms) ? payload.duration_ms : void 0;
+};
+var readTelemetryDuration = (payload) => {
+  const value = payload?.duration_ms;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+};
+var readTelemetryResolution = (payload) => {
+  const value = payload?.command_resolution;
+  return normalizeTelemetryText(value, "") || void 0;
+};
+var incrementTelemetryCount = (counts, key) => {
+  counts[key] = (counts[key] ?? 0) + 1;
+};
+var recordTelemetryFinishPayload = (current, payload) => {
+  const durationMs = readTelemetryDuration(payload);
   if (durationMs !== void 0) {
     current.finish_durations_ms.push(durationMs);
   }
@@ -5330,30 +5346,31 @@ function recordTelemetryFinishPayload(current, payload) {
   } else {
     current.error_count += 1;
   }
-  const resolution = typeof payload?.command_resolution === "string" && payload.command_resolution.trim().length > 0 ? payload.command_resolution : void 0;
+  const resolution = readTelemetryResolution(payload);
   if (resolution !== void 0) {
-    current.resolution_counts[resolution] = (current.resolution_counts[resolution] ?? 0) + 1;
+    incrementTelemetryCount(current.resolution_counts, resolution);
   }
-}
-function recordTelemetryQueueEntry(grouped, entry) {
+};
+var normalizeTelemetryAttempts = (attempts) => Number.isFinite(attempts) ? Math.max(0, Math.trunc(attempts)) : 0;
+var addTelemetryDimension = (values, value) => {
+  if (value !== void 0) {
+    values.add(value);
+  }
+};
+var recordTelemetryQueueEntry = (grouped, entry) => {
   const normalized = normalizeTelemetryQueueEntry(entry);
   const current = grouped.get(normalized.command) ?? createTelemetryStatsAccumulator();
-  const attempts = Number.isFinite(entry.attempts) ? Math.max(0, Math.trunc(entry.attempts)) : 0;
   current.count += 1;
-  current.max_attempts = Math.max(current.max_attempts, attempts);
-  current.event_type_counts[normalized.eventType] = (current.event_type_counts[normalized.eventType] ?? 0) + 1;
-  if (normalized.eventSchemaVersion !== void 0) {
-    current.event_schema_versions.add(normalized.eventSchemaVersion);
-  }
-  if (normalized.clientSchemaVersion !== void 0) {
-    current.client_schema_versions.add(normalized.clientSchemaVersion);
-  }
+  current.max_attempts = Math.max(current.max_attempts, normalizeTelemetryAttempts(entry.attempts));
+  incrementTelemetryCount(current.event_type_counts, normalized.eventType);
+  addTelemetryDimension(current.event_schema_versions, normalized.eventSchemaVersion);
+  addTelemetryDimension(current.client_schema_versions, normalized.clientSchemaVersion);
   if (normalized.eventType === "command_finish") {
     recordTelemetryFinishPayload(current, entry.event.payload);
   }
   grouped.set(normalized.command, current);
-}
-function buildTelemetryStatsBucket(command, value) {
+};
+var buildTelemetryStatsBucket = (command, value) => {
   const finishCount = value.ok_count + value.error_count;
   const sortedDurations = [...value.finish_durations_ms].sort((left, right) => left - right);
   const resolutionEntries = Object.entries(value.resolution_counts).sort((left, right) => left[0].localeCompare(right[0]));
@@ -5376,8 +5393,8 @@ function buildTelemetryStatsBucket(command, value) {
     } : {},
     ...resolutionEntries.length > 0 ? { command_resolution_counts: Object.fromEntries(resolutionEntries) } : {}
   };
-}
-function normalizeTelemetrySubcommand(value) {
+};
+var normalizeTelemetrySubcommand = (value) => {
   const normalized = (value ?? "status").trim().toLowerCase();
   if (TELEMETRY_SUBCOMMANDS.includes(normalized)) {
     return normalized;
@@ -5391,78 +5408,93 @@ function normalizeTelemetrySubcommand(value) {
       "pm telemetry clear"
     ]
   });
-}
-function parseTelemetryStatsLimit(raw) {
+};
+var throwInvalidTelemetryLimit = () => {
+  throw new PmCliError("--limit must be a positive integer", EXIT_CODE.USAGE);
+};
+var requirePositiveTelemetryLimit = (value) => {
+  if ([!Number.isFinite(value), !Number.isInteger(value), value <= 0].includes(true)) {
+    return throwInvalidTelemetryLimit();
+  }
+  return value;
+};
+var parseTelemetryStringLimit = (raw) => {
+  const trimmed = raw.trim();
+  if ([trimmed.length === 0, !/^\d+$/.test(trimmed)].includes(true)) {
+    return throwInvalidTelemetryLimit();
+  }
+  return requirePositiveTelemetryLimit(Number.parseInt(trimmed, 10));
+};
+var parseTelemetryStatsLimit = (raw) => {
   if (raw === void 0) {
     return DEFAULT_STATS_LIMIT;
   }
   if (typeof raw === "number") {
-    if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw <= 0) {
-      throw new PmCliError("--limit must be a positive integer", EXIT_CODE.USAGE);
-    }
-    return raw;
+    return requirePositiveTelemetryLimit(raw);
   }
-  const trimmed = raw.trim();
-  if (trimmed.length === 0 || !/^\d+$/.test(trimmed)) {
-    throw new PmCliError("--limit must be a positive integer", EXIT_CODE.USAGE);
+  if (typeof raw === "string") {
+    return parseTelemetryStringLimit(raw);
   }
-  const parsed = Number.parseInt(trimmed, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new PmCliError("--limit must be a positive integer", EXIT_CODE.USAGE);
+  return throwInvalidTelemetryLimit();
+};
+var isTelemetryQueueEntry = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  return parsed;
-}
-function parseTelemetryQueue2(raw) {
-  if (raw === null || raw.trim().length === 0) {
-    return {
-      rows_total: 0,
-      valid_entries: 0,
-      invalid_rows: 0,
-      entries: []
-    };
+  const candidate = value;
+  return typeof candidate.attempts === "number" && typeof candidate.event === "object" && candidate.event !== null;
+};
+var parseTelemetryQueueRow = (row) => {
+  try {
+    const parsed = JSON.parse(row);
+    return isTelemetryQueueEntry(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
+};
+var splitTelemetryQueueRows = (raw) => {
+  if (raw === null) {
+    return [];
+  }
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+};
+var parseTelemetryQueue2 = (raw) => {
+  const rows = splitTelemetryQueueRows(raw);
   const entries = [];
-  let rowsTotal = 0;
   let invalidRows = 0;
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    rowsTotal += 1;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (typeof parsed === "object" && parsed !== null && typeof parsed.attempts === "number" && typeof parsed.event === "object" && parsed.event !== null) {
-        entries.push(parsed);
-      } else {
-        invalidRows += 1;
-      }
-    } catch {
+  for (const row of rows) {
+    const parsed = parseTelemetryQueueRow(row);
+    if (parsed === void 0) {
       invalidRows += 1;
+    } else {
+      entries.push(parsed);
     }
   }
   return {
-    rows_total: rowsTotal,
+    rows_total: rows.length,
     valid_entries: entries.length,
     invalid_rows: invalidRows,
     entries
   };
-}
-async function readTelemetryRuntimeState(statePath) {
+};
+var isTelemetryRuntimeState = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseTelemetryRuntimeState2 = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    return isTelemetryRuntimeState(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+var readTelemetryRuntimeState = async (statePath) => {
   const stateRaw = await readFileIfExists(statePath);
   if (stateRaw === null || stateRaw.trim().length === 0) {
     return {};
   }
-  try {
-    const parsed = JSON.parse(stateRaw);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {
-  }
-  return {};
-}
-async function buildTelemetryStatusSummary(globalPmRoot) {
+  return parseTelemetryRuntimeState2(stateRaw);
+};
+var nullableTelemetryStateValue = (value) => value ?? null;
+var buildTelemetryStatusSummary = async (globalPmRoot) => {
   const settings = await readSettings(globalPmRoot);
   const queuePath = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
   const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
@@ -5477,253 +5509,102 @@ async function buildTelemetryStatusSummary(globalPmRoot) {
     queue_rows_total: queue.rows_total,
     queue_entries: queue.valid_entries,
     queue_invalid_rows: queue.invalid_rows,
-    queue_size_bytes: queueRaw === null ? 0 : Buffer.byteLength(queueRaw, "utf8"),
-    last_attempted_flush_at: runtimeState.last_attempted_flush_at ?? null,
-    last_successful_flush_at: runtimeState.last_successful_flush_at ?? null,
-    last_failed_flush_at: runtimeState.last_failed_flush_at ?? null,
-    last_failed_flush_error: runtimeState.last_failed_flush_error ?? null
+    queue_size_bytes: Buffer.byteLength(queueRaw ?? "", "utf8"),
+    last_attempted_flush_at: nullableTelemetryStateValue(runtimeState.last_attempted_flush_at),
+    last_successful_flush_at: nullableTelemetryStateValue(runtimeState.last_successful_flush_at),
+    last_failed_flush_at: nullableTelemetryStateValue(runtimeState.last_failed_flush_at),
+    last_failed_flush_error: nullableTelemetryStateValue(runtimeState.last_failed_flush_error)
   };
-}
-function buildTelemetryStatsBuckets(entries) {
+};
+var buildTelemetryStatsBuckets = (entries) => {
   const grouped = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     recordTelemetryQueueEntry(grouped, entry);
   }
   return [...grouped.entries()].map(([command, value]) => buildTelemetryStatsBucket(command, value)).sort((left, right) => right.count - left.count || left.command.localeCompare(right.command));
-}
-async function runTelemetry(options, _global) {
-  void _global;
-  const subcommand = normalizeTelemetrySubcommand(options.subcommand);
-  const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  const queuePath = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
-  const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
-  if (subcommand === "status") {
-    return {
-      action: "telemetry",
-      subcommand,
-      status: await buildTelemetryStatusSummary(globalPmRoot),
-      generated_at: nowIso()
-    };
-  }
-  if (subcommand === "flush") {
-    const before = await buildTelemetryStatusSummary(globalPmRoot);
-    await flushTelemetryQueueNow(globalPmRoot);
-    const after = await buildTelemetryStatusSummary(globalPmRoot);
-    return {
-      action: "telemetry",
-      subcommand,
-      queue_entries_before: before.queue_entries,
-      queue_entries_after: after.queue_entries,
-      queue_drained: after.queue_entries < before.queue_entries,
-      status: after,
-      generated_at: nowIso()
-    };
-  }
-  if (subcommand === "stats") {
-    const limit = parseTelemetryStatsLimit(options.limit);
-    const queueRaw = await readFileIfExists(queuePath);
-    const queue = parseTelemetryQueue2(queueRaw);
-    const buckets = buildTelemetryStatsBuckets(queue.entries);
-    const selected = buckets.slice(0, limit);
-    return {
-      action: "telemetry",
-      subcommand,
-      limit,
-      total_commands: buckets.length,
-      queue_entries: queue.valid_entries,
-      queue_invalid_rows: queue.invalid_rows,
-      queue_rows_total: queue.rows_total,
-      truncated: buckets.length > selected.length,
-      stats: selected,
-      generated_at: nowIso()
-    };
-  }
-  const settings = await readSettings(globalPmRoot);
-  const previousEnabled = settings.telemetry.enabled;
-  const previousInstallationId = settings.telemetry.installation_id;
-  const previousFirstRunPromptCompleted = settings.telemetry.first_run_prompt_completed;
+};
+var runTelemetryStatus = async (_options, context) => ({
+  action: "telemetry",
+  subcommand: "status",
+  status: await buildTelemetryStatusSummary(context.globalPmRoot),
+  generated_at: nowIso()
+});
+var runTelemetryFlush = async (_options, context) => {
+  const before = await buildTelemetryStatusSummary(context.globalPmRoot);
+  await flushTelemetryQueueNow(context.globalPmRoot);
+  const after = await buildTelemetryStatusSummary(context.globalPmRoot);
+  return {
+    action: "telemetry",
+    subcommand: "flush",
+    queue_entries_before: before.queue_entries,
+    queue_entries_after: after.queue_entries,
+    queue_drained: after.queue_entries < before.queue_entries,
+    status: after,
+    generated_at: nowIso()
+  };
+};
+var runTelemetryStats = async (options, context) => {
+  const limit = parseTelemetryStatsLimit(options.limit);
+  const queueRaw = await readFileIfExists(context.queuePath);
+  const queue = parseTelemetryQueue2(queueRaw);
+  const buckets = buildTelemetryStatsBuckets(queue.entries);
+  const selected = buckets.slice(0, limit);
+  return {
+    action: "telemetry",
+    subcommand: "stats",
+    limit,
+    total_commands: buckets.length,
+    queue_entries: queue.valid_entries,
+    queue_invalid_rows: queue.invalid_rows,
+    queue_rows_total: queue.rows_total,
+    truncated: buckets.length > selected.length,
+    stats: selected,
+    generated_at: nowIso()
+  };
+};
+var runTelemetryClear = async (_options, context) => {
+  const settings = await readSettings(context.globalPmRoot);
+  const settingsChanged = [
+    settings.telemetry.enabled !== false,
+    settings.telemetry.installation_id !== "",
+    settings.telemetry.first_run_prompt_completed !== true
+  ].includes(true);
   settings.telemetry.enabled = false;
   settings.telemetry.first_run_prompt_completed = true;
   settings.telemetry.installation_id = "";
-  const settingsChanged = previousEnabled !== settings.telemetry.enabled || previousInstallationId !== settings.telemetry.installation_id || previousFirstRunPromptCompleted !== settings.telemetry.first_run_prompt_completed;
   if (settingsChanged) {
-    await writeSettings(globalPmRoot, settings, "telemetry:clear");
+    await writeSettings(context.globalPmRoot, settings, "telemetry:clear");
   }
-  const telemetryRuntimePath = path7.join(globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
+  const telemetryRuntimePath = path7.join(context.globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
   const existed = await pathExists(telemetryRuntimePath);
   await fs7.rm(telemetryRuntimePath, { recursive: true, force: true });
-  const queueExistsAfter = await pathExists(queuePath);
-  const stateExistsAfter = await pathExists(statePath);
-  return {
-    action: "telemetry",
-    subcommand,
-    settings_changed: settingsChanged,
-    runtime_dir_removed: existed && !await pathExists(telemetryRuntimePath),
-    queue_exists_after: queueExistsAfter,
-    state_exists_after: stateExistsAfter,
-    status: await buildTelemetryStatusSummary(globalPmRoot),
-    generated_at: nowIso()
-  };
-}
-
-// dist/cli/commands/test.js
-import { spawn } from "node:child_process";
-import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path8 from "node:path";
-
-// dist/core/test/item-test-run-tracking.js
-var DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT = 20;
-function trackedTestRunHistoryLimit() {
-  const raw = process.env.PM_TRACKED_TEST_RUN_HISTORY_LIMIT;
-  if (!raw || raw.trim().length === 0) {
-    return DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT;
-  }
-  return parsed;
-}
-function normalizeTrackedTestRunSummaries(entries) {
-  return [...entries].filter((entry) => entry.run_id.trim().length > 0 && entry.started_at.trim().length > 0 && entry.finished_at.trim().length > 0 && entry.recorded_at.trim().length > 0).sort((left, right) => {
-    const byRecorded = compareTimestampStrings(left.recorded_at, right.recorded_at);
-    if (byRecorded !== 0)
-      return byRecorded;
-    const byRunId = left.run_id.localeCompare(right.run_id);
-    if (byRunId !== 0)
-      return byRunId;
-    return left.kind.localeCompare(right.kind);
-  });
-}
-async function appendTrackedTestRunSummary(options) {
-  const historyLimit = trackedTestRunHistoryLimit();
-  await mutateItem({
-    pmRoot: options.pmRoot,
-    settings: options.settings,
-    id: options.itemId,
-    op: "test_run_track",
-    author: options.author,
-    message: options.message,
-    force: false,
-    mutate(document) {
-      const current = document.metadata.test_runs ?? [];
-      const next = normalizeTrackedTestRunSummaries([
-        ...current,
-        options.entry
-      ]);
-      const bounded = next.length > historyLimit ? next.slice(next.length - historyLimit) : next;
-      document.metadata.test_runs = bounded;
-      return { changedFields: ["test_runs"] };
-    }
-  });
-}
-
-// dist/core/test/run-selectors.js
-var MAX_SELECTOR_ENTRY_LABEL_LENGTH = 100;
-function parseOnlyIndexValue(raw, optionName = "--only-index") {
-  const value = typeof raw === "number" ? raw : Number(String(raw).trim());
-  if (!Number.isInteger(value) || value < 1) {
-    throw new PmCliError(`${optionName} requires a 1-based integer index into the linked-test list (got "${raw}"). Use pm test <id> --list to inspect positions.`, EXIT_CODE.USAGE);
-  }
-  return value;
-}
-function summarizeSelectorEntry(entry) {
-  const label = entry.command ?? entry.path ?? "<no command>";
-  const normalized = label.replaceAll(/\s+/g, " ").trim() || "<no command>";
-  if (normalized.length <= MAX_SELECTOR_ENTRY_LABEL_LENGTH) {
-    return normalized;
-  }
-  return `${normalized.slice(0, MAX_SELECTOR_ENTRY_LABEL_LENGTH - 3)}...`;
-}
-function describeLinkedTestEntries(tests) {
-  return tests.map((entry, index) => `${index + 1}. ${summarizeSelectorEntry(entry)}`).join("; ");
-}
-function activeSelectorKinds(selector) {
-  const kinds = [];
-  if (selector.match !== void 0) {
-    kinds.push("match");
-  }
-  if (selector.onlyIndex !== void 0) {
-    kinds.push("only-index");
-  }
-  if (selector.onlyLast === true) {
-    kinds.push("only-last");
-  }
-  return kinds;
-}
-function entryMatchesSubstring(entry, needle) {
-  const command = entry.command?.toLowerCase() ?? "";
-  const entryPath = entry.path?.toLowerCase() ?? "";
-  return command.includes(needle) || entryPath.includes(needle);
-}
-function resolveLinkedTestRunSelection(tests, selector) {
-  const kinds = activeSelectorKinds(selector);
-  if (kinds.length === 0) {
-    return {
-      selector: null,
-      requested: null,
-      selected: tests,
-      selected_indexes: tests.map((_, index) => index + 1),
-      selected_count: tests.length,
-      skipped_count: 0
-    };
-  }
-  if (kinds.length > 1) {
-    throw new PmCliError(`Combine at most one linked-test selector per run: ${kinds.map((kind2) => `--${kind2}`).join(" and ")} were provided. Pick one of --match, --only-index, --only-last.`, EXIT_CODE.USAGE);
-  }
-  const kind = kinds[0];
-  if (tests.length === 0) {
-    throw new PmCliError(`--${kind} matched no linked tests because this item has none. Add one first with --add, --command, or --add-json.`, EXIT_CODE.USAGE);
-  }
-  if (kind === "match") {
-    const needle = selector.match.trim().toLowerCase();
-    if (needle.length === 0) {
-      throw new PmCliError("--match requires a non-empty substring to match against linked-test command/path values", EXIT_CODE.USAGE);
-    }
-    const selectedIndexes = [];
-    const selected = [];
-    for (let index = 0; index < tests.length; index += 1) {
-      if (entryMatchesSubstring(tests[index], needle)) {
-        selected.push(tests[index]);
-        selectedIndexes.push(index + 1);
-      }
-    }
-    if (selected.length === 0) {
-      throw new PmCliError(`--match "${selector.match}" matched none of the ${tests.length} linked test(s). Available entries: ${describeLinkedTestEntries(tests)}`, EXIT_CODE.USAGE);
-    }
-    return {
-      selector: "match",
-      requested: selector.match,
-      selected,
-      selected_indexes: selectedIndexes,
-      selected_count: selected.length,
-      skipped_count: tests.length - selected.length
-    };
-  }
-  if (kind === "only-index") {
-    const index = parseOnlyIndexValue(selector.onlyIndex);
-    if (index > tests.length) {
-      throw new PmCliError(`--only-index ${index} is out of range: this item has ${tests.length} linked test(s). Available entries: ${describeLinkedTestEntries(tests)}`, EXIT_CODE.USAGE);
-    }
-    return {
-      selector: "only-index",
-      requested: String(index),
-      selected: [tests[index - 1]],
-      selected_indexes: [index],
-      selected_count: 1,
-      skipped_count: tests.length - 1
-    };
-  }
-  return {
-    selector: "only-last",
-    requested: "last",
-    selected: [tests[tests.length - 1]],
-    selected_indexes: [tests.length],
-    selected_count: 1,
-    skipped_count: tests.length - 1
+  return {
+    action: "telemetry",
+    subcommand: "clear",
+    settings_changed: settingsChanged,
+    runtime_dir_removed: existed && !await pathExists(telemetryRuntimePath),
+    queue_exists_after: await pathExists(context.queuePath),
+    state_exists_after: await pathExists(context.statePath),
+    status: await buildTelemetryStatusSummary(context.globalPmRoot),
+    generated_at: nowIso()
   };
-}
+};
+var TELEMETRY_COMMAND_HANDLERS = {
+  status: runTelemetryStatus,
+  flush: runTelemetryFlush,
+  stats: runTelemetryStats,
+  clear: runTelemetryClear
+};
+var runTelemetry = async (options, _global) => {
+  void _global;
+  const subcommand = normalizeTelemetrySubcommand(options.subcommand);
+  const globalPmRoot = resolveGlobalPmRoot(process.cwd());
+  return TELEMETRY_COMMAND_HANDLERS[subcommand](options, {
+    globalPmRoot,
+    queuePath: path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2),
+    statePath: path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2)
+  });
+};
 
 // dist/sdk/test/linked-command-detection.js
 var PM_SUBCOMMANDS_WITH_ITEM_REFERENCE = /* @__PURE__ */ new Set([
@@ -6175,7 +6056,166 @@ function firstPositionalToken(tokens, flagsWithValue = /* @__PURE__ */ new Set()
   return void 0;
 }
 
-// dist/cli/commands/test.js
+// dist/sdk/test/execution.js
+import { spawn } from "node:child_process";
+import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path8 from "node:path";
+
+// dist/core/test/item-test-run-tracking.js
+var DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT = 20;
+function trackedTestRunHistoryLimit() {
+  const raw = process.env.PM_TRACKED_TEST_RUN_HISTORY_LIMIT;
+  if (!raw || raw.trim().length === 0) {
+    return DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT;
+  }
+  return parsed;
+}
+function normalizeTrackedTestRunSummaries(entries) {
+  return [...entries].filter((entry) => entry.run_id.trim().length > 0 && entry.started_at.trim().length > 0 && entry.finished_at.trim().length > 0 && entry.recorded_at.trim().length > 0).sort((left, right) => {
+    const byRecorded = compareTimestampStrings(left.recorded_at, right.recorded_at);
+    if (byRecorded !== 0)
+      return byRecorded;
+    const byRunId = left.run_id.localeCompare(right.run_id);
+    if (byRunId !== 0)
+      return byRunId;
+    return left.kind.localeCompare(right.kind);
+  });
+}
+async function appendTrackedTestRunSummary(options) {
+  const historyLimit = trackedTestRunHistoryLimit();
+  await mutateItem({
+    pmRoot: options.pmRoot,
+    settings: options.settings,
+    id: options.itemId,
+    op: "test_run_track",
+    author: options.author,
+    message: options.message,
+    force: false,
+    mutate(document) {
+      const current = document.metadata.test_runs ?? [];
+      const next = normalizeTrackedTestRunSummaries([
+        ...current,
+        options.entry
+      ]);
+      const bounded = next.length > historyLimit ? next.slice(next.length - historyLimit) : next;
+      document.metadata.test_runs = bounded;
+      return { changedFields: ["test_runs"] };
+    }
+  });
+}
+
+// dist/core/test/run-selectors.js
+var MAX_SELECTOR_ENTRY_LABEL_LENGTH = 100;
+function parseOnlyIndexValue(raw, optionName = "--only-index") {
+  const value = typeof raw === "number" ? raw : Number(String(raw).trim());
+  if (!Number.isInteger(value) || value < 1) {
+    throw new PmCliError(`${optionName} requires a 1-based integer index into the linked-test list (got "${raw}"). Use pm test <id> --list to inspect positions.`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function summarizeSelectorEntry(entry) {
+  const label = entry.command ?? entry.path ?? "<no command>";
+  const normalized = label.replaceAll(/\s+/g, " ").trim() || "<no command>";
+  if (normalized.length <= MAX_SELECTOR_ENTRY_LABEL_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_SELECTOR_ENTRY_LABEL_LENGTH - 3)}...`;
+}
+function describeLinkedTestEntries(tests) {
+  return tests.map((entry, index) => `${index + 1}. ${summarizeSelectorEntry(entry)}`).join("; ");
+}
+function activeSelectorKinds(selector) {
+  const kinds = [];
+  if (selector.match !== void 0) {
+    kinds.push("match");
+  }
+  if (selector.onlyIndex !== void 0) {
+    kinds.push("only-index");
+  }
+  if (selector.onlyLast === true) {
+    kinds.push("only-last");
+  }
+  return kinds;
+}
+function entryMatchesSubstring(entry, needle) {
+  const command = entry.command?.toLowerCase() ?? "";
+  const entryPath = entry.path?.toLowerCase() ?? "";
+  return command.includes(needle) || entryPath.includes(needle);
+}
+function resolveLinkedTestRunSelection(tests, selector) {
+  const kinds = activeSelectorKinds(selector);
+  if (kinds.length === 0) {
+    return {
+      selector: null,
+      requested: null,
+      selected: tests,
+      selected_indexes: tests.map((_, index) => index + 1),
+      selected_count: tests.length,
+      skipped_count: 0
+    };
+  }
+  if (kinds.length > 1) {
+    throw new PmCliError(`Combine at most one linked-test selector per run: ${kinds.map((kind2) => `--${kind2}`).join(" and ")} were provided. Pick one of --match, --only-index, --only-last.`, EXIT_CODE.USAGE);
+  }
+  const kind = kinds[0];
+  if (tests.length === 0) {
+    throw new PmCliError(`--${kind} matched no linked tests because this item has none. Add one first with --add, --command, or --add-json.`, EXIT_CODE.USAGE);
+  }
+  if (kind === "match") {
+    const needle = selector.match.trim().toLowerCase();
+    if (needle.length === 0) {
+      throw new PmCliError("--match requires a non-empty substring to match against linked-test command/path values", EXIT_CODE.USAGE);
+    }
+    const selectedIndexes = [];
+    const selected = [];
+    for (let index = 0; index < tests.length; index += 1) {
+      if (entryMatchesSubstring(tests[index], needle)) {
+        selected.push(tests[index]);
+        selectedIndexes.push(index + 1);
+      }
+    }
+    if (selected.length === 0) {
+      throw new PmCliError(`--match "${selector.match}" matched none of the ${tests.length} linked test(s). Available entries: ${describeLinkedTestEntries(tests)}`, EXIT_CODE.USAGE);
+    }
+    return {
+      selector: "match",
+      requested: selector.match,
+      selected,
+      selected_indexes: selectedIndexes,
+      selected_count: selected.length,
+      skipped_count: tests.length - selected.length
+    };
+  }
+  if (kind === "only-index") {
+    const index = parseOnlyIndexValue(selector.onlyIndex);
+    if (index > tests.length) {
+      throw new PmCliError(`--only-index ${index} is out of range: this item has ${tests.length} linked test(s). Available entries: ${describeLinkedTestEntries(tests)}`, EXIT_CODE.USAGE);
+    }
+    return {
+      selector: "only-index",
+      requested: String(index),
+      selected: [tests[index - 1]],
+      selected_indexes: [index],
+      selected_count: 1,
+      skipped_count: tests.length - 1
+    };
+  }
+  return {
+    selector: "only-last",
+    requested: "last",
+    selected: [tests[tests.length - 1]],
+    selected_indexes: [tests.length],
+    selected_count: 1,
+    skipped_count: tests.length - 1
+  };
+}
+
+// dist/sdk/test/execution.js
 var TEST_OUTPUT_MAX_BUFFER_BYTES = 20 * 1024 * 1024;
 var DEFAULT_LINKED_TEST_TIMEOUT_FORCE_KILL_DELAY_MS = 3e3;
 var DEFAULT_LINKED_TEST_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -6333,7 +6373,17 @@ function resolveLinkedTestEffectiveContextMode(requestedMode, isPmTrackerReadCom
   return requestedMode;
 }
 function hasLinkedTestAssertions(linkedTest) {
-  return (linkedTest.assert_stdout_contains?.length ?? 0) > 0 || (linkedTest.assert_stdout_regex?.length ?? 0) > 0 || (linkedTest.assert_stderr_contains?.length ?? 0) > 0 || (linkedTest.assert_stderr_regex?.length ?? 0) > 0 || typeof linkedTest.assert_stdout_min_lines === "number" || Object.keys(linkedTest.assert_json_field_equals ?? {}).length > 0 || Object.keys(linkedTest.assert_json_field_gte ?? {}).length > 0;
+  return Object.entries(linkedTest).filter(([key]) => key.startsWith("assert_")).some(([, value]) => {
+    if (value === void 0 || value === null)
+      return false;
+    if (Array.isArray(value))
+      return value.length > 0;
+    if (typeof value === "object")
+      return Object.keys(value).length > 0;
+    if (typeof value === "string")
+      return value.trim().length > 0;
+    return true;
+  });
 }
 function buildPmContextMismatchHint(params) {
   const { executionContext, runLevelPmContextMode, linkedOverridePmContextMode } = params;
@@ -6437,6 +6487,12 @@ function parsedLauncherInvokesRecursiveTestAll(parsed) {
   }
   return firstPmSubcommand(parsed.args) === "test-all";
 }
+var SHELL_COMMAND_FLAG_PATTERNS = new Map([
+  ...["sh", "bash", "dash", "zsh"].map((executable) => [executable, /^(?:-c|-[a-z]*c[a-z]*)$/u]),
+  ...["cmd", "cmd.exe"].map((executable) => [executable, /^\/[ck]$/u]),
+  ...["powershell", "powershell.exe", "pwsh", "pwsh.exe"].map((executable) => [executable, /^-(?:c|command)$/u])
+]);
+var PACKAGE_EXEC_EXECUTABLES = /* @__PURE__ */ new Set(["npx", "bunx"]);
 function segmentInvokesRecursiveTestAll(segment) {
   const rawTokens = segment.split(" ").filter((token) => token.length > 0);
   const tokens = stripLeadingEnvAssignments(rawTokens);
@@ -6444,13 +6500,18 @@ function segmentInvokesRecursiveTestAll(segment) {
     return false;
   }
   const [executable, ...args] = tokens;
+  const shellCommandFlagPattern = SHELL_COMMAND_FLAG_PATTERNS.get(executable);
+  if (shellCommandFlagPattern) {
+    const commandFlagIndex = args.findIndex((arg) => shellCommandFlagPattern.test(arg));
+    return commandFlagIndex >= 0 ? segmentInvokesRecursiveTestAll(args.slice(commandFlagIndex + 1).join(" ")) : false;
+  }
   if (isPmExecutableToken(executable) || isPmCliScriptToken(executable)) {
     return firstPmSubcommand(args) === "test-all";
   }
   if (executable === "node" && args.length > 0 && isPmCliScriptToken(args[0])) {
     return firstPmSubcommand(args.slice(1)) === "test-all";
   }
-  if (executable === "npx" || executable === "bunx") {
+  if (PACKAGE_EXEC_EXECUTABLES.has(executable)) {
     return parsedLauncherInvokesRecursiveTestAll(parseNpxCommand(args));
   }
   if (executable === "pnpm") {
@@ -6564,7 +6625,13 @@ function parseLinkedTestTimeoutSeconds(timeoutSecondsRaw, timeoutAliasRaw) {
     throw new PmCliError("--add timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
   }
   const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
-  return timeoutRaw === void 0 ? void 0 : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
+  if (timeoutRaw === void 0)
+    return void 0;
+  const timeout = Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
+  if (timeout <= 0) {
+    throw new PmCliError("--add timeout_seconds must be a positive integer", EXIT_CODE.USAGE);
+  }
+  return timeout;
 }
 function parseAddJsonEntries(raw) {
   if (!raw)
@@ -6762,7 +6829,7 @@ function appendLinkedTestOutputChunk(state, chunk, target) {
     state.stderrBytes += bytes;
   }
   const bufferExceeded = state.stdoutBytes > TEST_OUTPUT_MAX_BUFFER_BYTES || state.stderrBytes > TEST_OUTPUT_MAX_BUFFER_BYTES;
-  if (!state.maxBufferExceeded && bufferExceeded) {
+  if (bufferExceeded) {
     state.maxBufferExceeded = true;
     return true;
   }
@@ -7090,7 +7157,7 @@ function readJsonPathValue(root, fieldPath) {
       current = current[segment];
       continue;
     }
-    if (typeof current !== "object" || current === null || !(segment in current)) {
+    if (typeof current !== "object" || current === null || !Object.prototype.hasOwnProperty.call(current, segment)) {
       return { found: false, value: void 0 };
     }
     current = current[segment];
@@ -7277,7 +7344,7 @@ function buildLinkedTestExecutionContext(params) {
     sandbox_project_item_count: selectedSandboxProjectItemCount,
     source_global_item_count: params.counts.sourceGlobalItemCount,
     sandbox_global_item_count: selectedSandboxGlobalItemCount,
-    mismatch_detected: params.isPmCommand && params.counts.sourceProjectItemCount !== selectedSandboxProjectItemCount,
+    mismatch_detected: params.isPmCommand && (params.counts.sourceProjectItemCount !== selectedSandboxProjectItemCount || params.counts.sourceGlobalItemCount !== selectedSandboxGlobalItemCount),
     project_extensions_seeded: Boolean(params.sourceRoots),
     global_extensions_seeded: Boolean(params.sourceRoots)
   };
@@ -7564,8 +7631,12 @@ function resolveTestRunOptions(options, tests) {
     onlyLast: options.onlyLast
   };
   const runSelection = options.run === true ? resolveLinkedTestRunSelection(tests, selectorInput) : void 0;
+  const defaultTimeoutSeconds = options.timeout === void 0 ? void 0 : parseOptionalNumber(options.timeout, "timeout");
+  if (defaultTimeoutSeconds !== void 0 && defaultTimeoutSeconds <= 0) {
+    throw new PmCliError("Test timeout must be a positive number", EXIT_CODE.USAGE);
+  }
   return {
-    defaultTimeoutSeconds: options.timeout === void 0 ? void 0 : parseOptionalNumber(options.timeout, "timeout"),
+    defaultTimeoutSeconds,
     pmContextMode: parsePmContextMode(options.pmContext),
     runSelection,
     testsToRun: runSelection?.selected ?? tests
@@ -7706,8 +7777,8 @@ async function runTest(id, options, global) {
   };
 }
 
-// dist/cli/commands/test-all.js
-function parseStatus(raw, statusRegistry) {
+// dist/sdk/test/batch.js
+var parseStatus = (raw, statusRegistry) => {
   if (raw === void 0) {
     return void 0;
   }
@@ -7717,14 +7788,18 @@ function parseStatus(raw, statusRegistry) {
     throw new PmCliError(`Invalid --status value "${raw}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
   }
   return normalized;
-}
-function parseTimeout(raw) {
+};
+var parseTimeout = (raw) => {
   if (raw === void 0) {
     return void 0;
   }
-  return parseOptionalNumber(raw, "timeout");
-}
-function parseNonNegativeInteger(raw, flag) {
+  const parsed = parseOptionalNumber(raw, "timeout");
+  if (parsed <= 0) {
+    throw new PmCliError("timeout must be a positive number", EXIT_CODE.USAGE);
+  }
+  return parsed;
+};
+var parseNonNegativeInteger = (raw, flag) => {
   if (raw === void 0) {
     return void 0;
   }
@@ -7733,66 +7808,67 @@ function parseNonNegativeInteger(raw, flag) {
     throw new PmCliError(`${flag} must be a non-negative integer`, EXIT_CODE.USAGE);
   }
   return parsed;
-}
-function formatTrackingError(error) {
+};
+var formatTrackingError = (error) => {
   return error instanceof Error ? error.message : String(error);
-}
-function resolveTrackedRunId2() {
+};
+var resolveTrackedRunId2 = () => {
   const fromEnv = process.env.PM_BACKGROUND_TEST_RUN_ID?.trim();
   if (fromEnv && fromEnv.length > 0) {
     return fromEnv;
   }
   return `test-all-local-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function normalizeCommand(command) {
+};
+var normalizeCommand = (command) => {
   return command.trim().replaceAll(/\s+/g, " ");
-}
-function normalizeEnvSetSignature(value) {
+};
+var normalizeEnvSetSignature = (value) => {
   if (!value || Object.keys(value).length === 0) {
     return "{}";
   }
   return JSON.stringify(Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right))));
-}
-function normalizeEnvClearSignature(value) {
+};
+var normalizeEnvClearSignature = (value) => {
   if (!value || value.length === 0) {
     return "[]";
   }
   return JSON.stringify([...value].sort((left, right) => left.localeCompare(right)));
-}
-function normalizePmContextModeSignature(value) {
+};
+var normalizePmContextModeSignature = (value) => {
   const normalized = value?.trim().toLowerCase();
   return normalized && normalized.length > 0 ? normalized : "none";
-}
-function normalizeAssertionSignature(test) {
+};
+var normalizeAssertionStrings = (values) => [...new Set(values ?? [])].sort((left, right) => left.localeCompare(right));
+var normalizeAssertionMap = (value) => Object.fromEntries(Object.entries(value ?? {}).sort(([left], [right]) => left.localeCompare(right)));
+var normalizeAssertionLineCount = (value) => typeof value === "number" ? value : void 0;
+var normalizeAssertionSignature = (test) => {
   const normalized = {
-    assert_stdout_contains: [
-      ...new Set(test.assert_stdout_contains ?? [])
-    ].sort((left, right) => left.localeCompare(right)),
-    assert_stdout_regex: [...new Set(test.assert_stdout_regex ?? [])].sort((left, right) => left.localeCompare(right)),
-    assert_stderr_contains: [
-      ...new Set(test.assert_stderr_contains ?? [])
-    ].sort((left, right) => left.localeCompare(right)),
-    assert_stderr_regex: [...new Set(test.assert_stderr_regex ?? [])].sort((left, right) => left.localeCompare(right)),
-    assert_stdout_min_lines: typeof test.assert_stdout_min_lines === "number" ? test.assert_stdout_min_lines : void 0,
-    assert_json_field_equals: Object.fromEntries(Object.entries(test.assert_json_field_equals ?? {}).sort(([left], [right]) => left.localeCompare(right))),
-    assert_json_field_gte: Object.fromEntries(Object.entries(test.assert_json_field_gte ?? {}).sort(([left], [right]) => left.localeCompare(right)))
+    assert_stdout_contains: normalizeAssertionStrings(test.assert_stdout_contains),
+    assert_stdout_regex: normalizeAssertionStrings(test.assert_stdout_regex),
+    assert_stderr_contains: normalizeAssertionStrings(test.assert_stderr_contains),
+    assert_stderr_regex: normalizeAssertionStrings(test.assert_stderr_regex),
+    assert_stdout_min_lines: normalizeAssertionLineCount(test.assert_stdout_min_lines),
+    assert_json_field_equals: normalizeAssertionMap(test.assert_json_field_equals),
+    assert_json_field_gte: normalizeAssertionMap(test.assert_json_field_gte)
   };
   return JSON.stringify(normalized);
-}
-function buildLinkedTestKey(test) {
-  const command = test.command?.trim();
-  if (command && command.length > 0) {
-    const envSet = normalizeEnvSetSignature(test.env_set);
-    const envClear = normalizeEnvClearSignature(test.env_clear);
-    const pmContextMode = normalizePmContextModeSignature(test.pm_context_mode);
-    const sharedHostSafe = test.shared_host_safe === true ? "true" : "false";
-    const assertions = normalizeAssertionSignature(test);
-    return `command:${test.scope}:${normalizeCommand(command)}:${envSet}:${envClear}:${pmContextMode}:${sharedHostSafe}:${assertions}`;
+};
+var resolveLinkedTestTargetSignature = (test) => {
+  const command = resolveOptionalEnvironmentValue(test.command);
+  if (command !== void 0) {
+    return `command:${test.scope}:${normalizeCommand(command)}`;
   }
-  const linkedPath = test.path?.trim() ?? "";
-  return `path:${test.scope}:${linkedPath}`;
-}
-function maxTimeoutSeconds(current, candidate) {
+  return `path:${test.scope}:${resolveOptionalEnvironmentValue(test.path) ?? ""}`;
+};
+var buildLinkedTestKey = (test) => {
+  const envSet = normalizeEnvSetSignature(test.env_set);
+  const envClear = normalizeEnvClearSignature(test.env_clear);
+  const pmContextMode = normalizePmContextModeSignature(test.pm_context_mode);
+  const sharedHostSafe = test.shared_host_safe === true ? "true" : "false";
+  const assertions = normalizeAssertionSignature(test);
+  return `${resolveLinkedTestTargetSignature(test)}:${envSet}:${envClear}:${pmContextMode}:${sharedHostSafe}:${assertions}`;
+};
+var maxTimeoutSeconds = (current, candidate) => {
   if (candidate === void 0) {
     return current;
   }
@@ -7800,8 +7876,8 @@ function maxTimeoutSeconds(current, candidate) {
     return candidate;
   }
   return current;
-}
-function countStatuses(runResults) {
+};
+var countStatuses = (runResults) => {
   let passed = 0;
   let failed = 0;
   let skipped = 0;
@@ -7817,13 +7893,13 @@ function countStatuses(runResults) {
     skipped += 1;
   }
   return { passed, failed, skipped };
-}
-function mergeFailureCategoryCounts(target, source) {
+};
+var mergeFailureCategoryCounts = (target, source) => {
   for (const [key, value] of Object.entries(source)) {
     target[key] += value;
   }
-}
-function emitTestAllProgress(options, message) {
+};
+var emitTestAllProgress = (options, message) => {
   if (options.progress !== true) {
     return;
   }
@@ -7832,8 +7908,8 @@ function emitTestAllProgress(options, message) {
 `);
   } catch {
   }
-}
-async function collectTestAllItemTests(filteredItems, global, pmRoot) {
+};
+var collectTestAllItemTests = async (filteredItems, global, pmRoot) => {
   const itemTests = [];
   let linkedTests = 0;
   for (const item of filteredItems) {
@@ -7845,8 +7921,8 @@ async function collectTestAllItemTests(filteredItems, global, pmRoot) {
     itemTests.push({ item, tests: readResult.tests });
   }
   return { itemTests, linkedTests };
-}
-async function selectTestAllItems(params) {
+};
+var selectTestAllItems = async (params) => {
   const statusRegistry = resolveRuntimeStatusRegistry(params.settings.schema);
   const typeRegistry = resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations());
   const statusFilter = parseStatus(params.options.status, statusRegistry);
@@ -7856,8 +7932,8 @@ async function selectTestAllItems(params) {
   const statusFilteredItems = allItems.filter((item) => statusFilter ? item.status === statusFilter : true).sort((a, b) => a.id.localeCompare(b.id));
   const filteredItems = limitFilter === void 0 ? statusFilteredItems.slice(offsetFilter) : statusFilteredItems.slice(offsetFilter, offsetFilter + limitFilter);
   return { filteredItems, statusFilter, limitFilter, offsetFilter };
-}
-function buildEffectiveTimeoutByKey(itemTests) {
+};
+var buildEffectiveTimeoutByKey = (itemTests) => {
   const effectiveTimeoutByKey = /* @__PURE__ */ new Map();
   for (const { tests } of itemTests) {
     for (const test of tests) {
@@ -7870,8 +7946,8 @@ function buildEffectiveTimeoutByKey(itemTests) {
     }
   }
   return effectiveTimeoutByKey;
-}
-async function runTestAllItem(entry, context) {
+};
+var runTestAllItem = async (entry, context) => {
   const testsToRun = [];
   const keyedTests = entry.tests.map((test) => {
     const key = buildLinkedTestKey(test);
@@ -7932,12 +8008,18 @@ async function runTestAllItem(entry, context) {
       failure_categories: failureCategories
     }
   };
-}
-async function appendTestAllItemTracking(entry, summary, context) {
+};
+var trackedRunFailed = (summary, options) => [
+  summary.failed > 0,
+  options.failOnSkipped === true && summary.skipped > 0
+].includes(true);
+var optionalTrue = (value) => value ? true : void 0;
+var appendTestAllItemTracking = async (entry, summary, context) => {
   if (!context.trackingEnabled) {
     return [];
   }
   try {
+    const failed = trackedRunFailed(summary, context.options);
     await appendTrackedTestRunSummary({
       pmRoot: context.pmRoot,
       settings: context.settings,
@@ -7947,7 +8029,7 @@ async function appendTestAllItemTracking(entry, summary, context) {
       entry: {
         run_id: context.trackingRunId,
         kind: "test-all",
-        status: summary.failed > 0 || context.options.failOnSkipped === true && summary.skipped > 0 ? "failed" : "passed",
+        status: failed ? "failed" : "passed",
         started_at: context.runStartedAt,
         finished_at: nowIso(),
         recorded_at: nowIso(),
@@ -7958,7 +8040,7 @@ async function appendTestAllItemTracking(entry, summary, context) {
         skipped: summary.skipped,
         items: 1,
         linked_tests: entry.tests.length,
-        fail_on_skipped_triggered: context.options.failOnSkipped === true && summary.skipped > 0 ? true : void 0
+        fail_on_skipped_triggered: optionalTrue(context.options.failOnSkipped === true && summary.skipped > 0)
       }
     });
   } catch (error) {
@@ -7967,11 +8049,17 @@ async function appendTestAllItemTracking(entry, summary, context) {
     ];
   }
   return [];
-}
-function buildTestAllItemRunContext(params) {
-  const trackingAttemptRaw = process.env.PM_BACKGROUND_TEST_RUN_ATTEMPT?.trim();
-  const trackingParsedAttempt = trackingAttemptRaw ? Number.parseInt(trackingAttemptRaw, 10) : Number.NaN;
-  const trackingResumedFrom = process.env.PM_BACKGROUND_TEST_RUN_RESUMED_FROM?.trim();
+};
+var resolveTrackingAttempt = () => {
+  const raw = process.env.PM_BACKGROUND_TEST_RUN_ATTEMPT?.trim();
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed >= 1 ? parsed : void 0;
+};
+var resolveOptionalEnvironmentValue = (value) => {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+};
+var buildTestAllItemRunContext = (params) => {
   return {
     pmRoot: params.pmRoot,
     settings: params.settings,
@@ -7986,12 +8074,12 @@ function buildTestAllItemRunContext(params) {
     trackingEnabled: params.settings.testing.record_results_to_items === true,
     trackingAuthor: resolveAuthor(void 0, params.settings.author_default),
     trackingRunId: resolveTrackedRunId2(),
-    trackingAttempt: Number.isFinite(trackingParsedAttempt) && trackingParsedAttempt >= 1 ? trackingParsedAttempt : void 0,
-    trackingResumedFrom: trackingResumedFrom && trackingResumedFrom.length > 0 ? trackingResumedFrom : void 0,
+    trackingAttempt: resolveTrackingAttempt(),
+    trackingResumedFrom: resolveOptionalEnvironmentValue(process.env.PM_BACKGROUND_TEST_RUN_RESUMED_FROM),
     runStartedAt: params.runStartedAt
   };
-}
-function initializeTestAllAccumulation(options, linkedTests, filteredItems) {
+};
+var initializeTestAllAccumulation = (options, linkedTests, filteredItems) => {
   const accumulation = {
     results: [],
     passed: 0,
@@ -8007,8 +8095,8 @@ function initializeTestAllAccumulation(options, linkedTests, filteredItems) {
     accumulation.trackingWarnings.push(`empty_linked_test_selection:items=${filteredItems.length};linked_tests=0;fail_on_empty_test_run=true`);
   }
   return { accumulation, failOnEmptyTestRunTriggered };
-}
-async function runTestAllItems(itemTests, context, accumulation) {
+};
+var runTestAllItems = async (itemTests, context, accumulation) => {
   for (const [itemIndex, entry] of itemTests.entries()) {
     emitTestAllProgress(context.options, `item ${itemIndex + 1}/${itemTests.length} start id=${entry.item.id} linked_tests=${entry.tests.length}`);
     const execution = await runTestAllItem(entry, context);
@@ -8020,16 +8108,16 @@ async function runTestAllItems(itemTests, context, accumulation) {
     accumulation.results.push(execution.result);
     emitTestAllProgress(context.options, `item ${itemIndex + 1}/${itemTests.length} end id=${entry.item.id} status=${execution.failed === 0 ? "passed" : "failed"} passed=${execution.passed} failed=${execution.failed} skipped=${execution.skipped}`);
   }
-}
-function appendContextPreflightWarning(options, accumulation) {
+};
+var appendContextPreflightWarning = (options, accumulation) => {
   if (options.checkContext !== true) {
     return;
   }
   const allRunResults = accumulation.results.flatMap((entry) => entry.run_results);
   const preflight = summarizeContextPreflight(allRunResults);
   accumulation.trackingWarnings.push(`context_preflight:checked_pm_commands=${preflight.checked_pm_commands};tracker_read_commands=${preflight.tracker_read_commands};mismatches=${preflight.mismatches};auto_remediated=${preflight.auto_remediated}`);
-}
-function buildTestAllResult(params) {
+};
+var buildTestAllResult = (params) => {
   return {
     ok: params.ok,
     totals: {
@@ -8048,43 +8136,77 @@ function buildTestAllResult(params) {
     warnings: params.accumulation.trackingWarnings.length > 0 ? params.accumulation.trackingWarnings : void 0,
     results: params.accumulation.results
   };
-}
-async function runTestAll(options, global) {
+};
+var buildTestAllSelectionProgress = (params) => [
+  `selection items=${params.filteredItems.length}`,
+  `linked_tests=${params.linkedTests}`,
+  params.statusFilter === void 0 ? "" : `status=${params.statusFilter}`,
+  params.limitFilter === void 0 ? "" : `limit=${params.limitFilter}`,
+  params.offsetFilter > 0 ? `offset=${params.offsetFilter}` : ""
+].filter((entry) => entry.length > 0).join(" ");
+var prepareTestAllRun = async (options, global) => {
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
   if (!await pathExists(getSettingsPath(pmRoot))) {
     throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
   }
   const settings = await readSettings(pmRoot);
-  const { filteredItems, statusFilter, limitFilter, offsetFilter } = await selectTestAllItems({ pmRoot, settings, options });
+  const selection = await selectTestAllItems({ pmRoot, settings, options });
   const defaultTimeoutSeconds = parseTimeout(options.timeout);
   const runStartedAt = nowIso();
-  const { itemTests, linkedTests } = await collectTestAllItemTests(filteredItems, global, pmRoot);
-  emitTestAllProgress(options, `selection items=${filteredItems.length} linked_tests=${linkedTests}${statusFilter ? ` status=${statusFilter}` : ""}${limitFilter === void 0 ? "" : ` limit=${limitFilter}`}${offsetFilter > 0 ? ` offset=${offsetFilter}` : ""}`);
-  const { accumulation, failOnEmptyTestRunTriggered } = initializeTestAllAccumulation(options, linkedTests, filteredItems);
-  const itemRunContext = buildTestAllItemRunContext({
+  const collected = await collectTestAllItemTests(selection.filteredItems, global, pmRoot);
+  emitTestAllProgress(options, buildTestAllSelectionProgress({
+    ...selection,
+    linkedTests: collected.linkedTests
+  }));
+  return {
     pmRoot,
     settings,
-    options,
-    itemTests,
+    filteredItems: selection.filteredItems,
+    itemTests: collected.itemTests,
+    linkedTests: collected.linkedTests,
     defaultTimeoutSeconds,
     runStartedAt
+  };
+};
+var resolveTestAllOutcome = (params) => {
+  const failOnSkippedTriggered = params.options.failOnSkipped === true && params.accumulation.skipped > 0;
+  const ok = ![
+    params.accumulation.failed > 0,
+    failOnSkippedTriggered,
+    params.failOnEmptyTestRunTriggered
+  ].includes(true);
+  return { failOnSkippedTriggered, ok };
+};
+var runTestAll = async (options, global) => {
+  const prepared = await prepareTestAllRun(options, global);
+  const { accumulation, failOnEmptyTestRunTriggered } = initializeTestAllAccumulation(options, prepared.linkedTests, prepared.filteredItems);
+  const itemRunContext = buildTestAllItemRunContext({
+    pmRoot: prepared.pmRoot,
+    settings: prepared.settings,
+    options,
+    itemTests: prepared.itemTests,
+    defaultTimeoutSeconds: prepared.defaultTimeoutSeconds,
+    runStartedAt: prepared.runStartedAt
   });
-  await runTestAllItems(itemTests, itemRunContext, accumulation);
-  const failOnSkippedTriggered = options.failOnSkipped === true && accumulation.skipped > 0;
+  await runTestAllItems(prepared.itemTests, itemRunContext, accumulation);
   appendContextPreflightWarning(options, accumulation);
-  const ok = accumulation.failed === 0 && failOnSkippedTriggered !== true && failOnEmptyTestRunTriggered !== true;
-  emitTestAllProgress(options, `end status=${ok ? "passed" : "failed"} items=${filteredItems.length} linked_tests=${linkedTests} passed=${accumulation.passed} failed=${accumulation.failed} skipped=${accumulation.skipped}`);
+  const outcome = resolveTestAllOutcome({
+    options,
+    accumulation,
+    failOnEmptyTestRunTriggered
+  });
+  emitTestAllProgress(options, `end status=${outcome.ok ? "passed" : "failed"} items=${prepared.filteredItems.length} linked_tests=${prepared.linkedTests} passed=${accumulation.passed} failed=${accumulation.failed} skipped=${accumulation.skipped}`);
   return buildTestAllResult({
-    ok,
-    filteredItems,
-    linkedTests,
+    ok: outcome.ok,
+    filteredItems: prepared.filteredItems,
+    linkedTests: prepared.linkedTests,
     accumulation,
-    failOnSkippedTriggered,
+    failOnSkippedTriggered: outcome.failOnSkippedTriggered,
     failOnEmptyTestRunTriggered
   });
-}
+};
 
-// dist/cli/commands/test-runs.js
+// dist/sdk/test/runs.js
 import os from "node:os";
 
 // dist/core/test/background-runs.js
@@ -8919,7 +9041,7 @@ async function readBackgroundTestRunLogs(pmRoot, runId, stream, tail) {
   };
 }
 
-// dist/cli/commands/test-runs.js
+// dist/sdk/test/runs.js
 var BACKGROUND_STATUS_VALUES = [
   "queued",
   "running",
@@ -11269,7 +11391,14 @@ export {
   runEvent,
   runRemind,
   runStats,
+  TELEMETRY_SUBCOMMANDS,
   runTelemetry,
+  extractReferencedPmItemIdsFromCommand,
+  summarizeContextPreflight,
+  classifyLinkedTestFailure,
+  countFailureCategories,
+  resolveLinkedTestFailureExitCode,
+  runLinkedTests,
   runTest,
   runTestAll,
   runStartBackgroundRun,
@@ -11283,6 +11412,6 @@ export {
   runValidate,
   runValidate2
 };
-//# sourceMappingURL=chunk-5ZSLZLDN.js.map
+//# sourceMappingURL=chunk-HF63SBLC.js.map
 
-//# debugId=1a18538c-3ee2-5ab6-b7c2-b913c780563a
+//# debugId=afd69b46-3b50-57d8-b120-4dcf45f8ff19