@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-C5JBZRPU.js

@@ -0,0 +1,1985 @@
+import {
+  LINKED_TEST_PM_CONTEXT_MODE_VALUES,
+  LINKED_TEST_PROTECTED_ENV_KEYS,
+  looksLikeStructuredLinkedTestEntry,
+  normalizeStructuredLinkedTestEntry,
+  parseLinkedTestAssertionEqualsMap,
+  parseLinkedTestAssertionGteMap,
+  parseLinkedTestBoolean,
+  parseLinkedTestContextMode,
+  parseLinkedTestEnvClear,
+  parseLinkedTestEnvSet,
+  parseLinkedTestJsonEntries,
+  parseLinkedTestMinLines,
+  parseLinkedTestRegexList,
+  parseLinkedTestStringList
+} from "./chunk-GPLPTGOV.js";
+import {
+  createStdinTokenResolver,
+  parseCsvKv,
+  parseOptionalNumber
+} from "./chunk-AZYGZGGI.js";
+import {
+  runInit
+} from "./chunk-GZRDYONU.js";
+import {
+  locateItem,
+  mutateItem,
+  readLocatedItem
+} from "./chunk-5VAA4YHR.js";
+import {
+  compareTimestampStrings,
+  nowIso
+} from "./chunk-FLZSGSQR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  stableValueEquals
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  ITEM_FILE_EXTENSIONS,
+  SCOPE_VALUES,
+  getSettingsPath,
+  pathExists,
+  resolveGlobalPmRoot,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-LK6XLOGP.js";
+
+// 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 path from "node:path";
+
+// dist/core/test/item-test-run-tracking.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] = "7681f869-8f0d-5927-86ac-af1ef0dfd5fd");
+  } catch (e2) {
+  }
+})();
+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
+!(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] = "bdcc9109-f60d-5068-b2c2-bcc9dc9d5e50");
+  } catch (e2) {
+  }
+})();
+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/cli/commands/test/linked-command-detection.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] = "5d95440c-7913-547a-ae78-d9fe282d8edb");
+  } catch (e2) {
+  }
+})();
+var PM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--path"]);
+var NPX_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-p", "--package", "-c", "--call"]);
+var PNPM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-c",
+  "-C",
+  "--config",
+  "--dir",
+  "--filter",
+  "--workspace-dir"
+]);
+var NPM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-C", "--prefix", "--userconfig", "--cache"]);
+var YARN_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--cwd"]);
+var BUN_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--cwd"]);
+var NPM_EXEC_SUBCOMMANDS = /* @__PURE__ */ new Set(["exec", "x"]);
+var SCRIPT_RUN_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "run-script"]);
+var SCRIPT_RUN_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-C", "--dir", "--cwd", "-w", "--workspace", "--filter"]);
+function splitNormalizedCommandSegments(normalizedCommand) {
+  return normalizedCommand.split(/&&|\|\||\||;/).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function stripLeadingEnvAssignments(tokens) {
+  let start = 0;
+  if (tokens[start] === "env") {
+    start += 1;
+  }
+  while (start < tokens.length) {
+    const token = tokens[start];
+    if (/^(?:[a-z_][a-z0-9_]*|\$env:[a-z_][a-z0-9_]*)=.*/.test(token)) {
+      start += 1;
+      continue;
+    }
+    break;
+  }
+  return tokens.slice(start);
+}
+function firstPmSubcommand(args) {
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      if (PM_GLOBAL_FLAGS_WITH_VALUE.has(token)) {
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function isPmExecutableToken(token) {
+  return token === "pm" || token === "pm.cmd" || token === "pm.exe" || token.endsWith("/pm") || token.endsWith("/pm.cmd") || token.endsWith("/pm.exe");
+}
+function normalizePackageSpecifier(token) {
+  const trimmed = token.trim();
+  if (!trimmed.startsWith("@")) {
+    const versionSeparator2 = trimmed.indexOf("@");
+    return versionSeparator2 === -1 ? trimmed : trimmed.slice(0, versionSeparator2);
+  }
+  const scopeSeparator = trimmed.indexOf("/");
+  if (scopeSeparator === -1) {
+    return trimmed;
+  }
+  const versionSeparator = trimmed.indexOf("@", scopeSeparator + 1);
+  return versionSeparator === -1 ? trimmed : trimmed.slice(0, versionSeparator);
+}
+function isPmCliPackageToken(token) {
+  const normalizedSpecifier = normalizePackageSpecifier(token);
+  return normalizedSpecifier === "pm-cli" || normalizedSpecifier.endsWith("/pm-cli") || token === "pm-cli" || token.endsWith("/pm-cli");
+}
+function isPmCliScriptToken(token) {
+  return token === "dist/cli.js" || token === "./dist/cli.js" || token.endsWith("/dist/cli.js");
+}
+function parseNpxCommand(tokens) {
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token === "--") {
+      index += 1;
+      break;
+    }
+    if (!token.startsWith("-")) {
+      break;
+    }
+    if (token.includes("=")) {
+      index += 1;
+      continue;
+    }
+    if (NPX_FLAGS_WITH_VALUE.has(token)) {
+      index += 2;
+      continue;
+    }
+    index += 1;
+  }
+  const command = tokens[index];
+  if (!command) {
+    return null;
+  }
+  return {
+    command,
+    args: tokens.slice(index + 1)
+  };
+}
+function parseLauncherSubcommand(tokens, flagsWithValue) {
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token === "--") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      if (token.includes("=")) {
+        index += 1;
+        continue;
+      }
+      if (flagsWithValue.has(token)) {
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    return {
+      subcommand: token,
+      args: tokens.slice(index + 1)
+    };
+  }
+  return null;
+}
+function parsePnpmDlxCommand(tokens) {
+  const parsed = parseLauncherSubcommand(tokens, PNPM_GLOBAL_FLAGS_WITH_VALUE);
+  if (parsed?.subcommand !== "dlx") {
+    return null;
+  }
+  return parseNpxCommand(parsed.args);
+}
+function parseNpmExecCommand(tokens) {
+  const parsed = parseLauncherSubcommand(tokens, NPM_GLOBAL_FLAGS_WITH_VALUE);
+  if (!parsed || !NPM_EXEC_SUBCOMMANDS.has(parsed.subcommand)) {
+    return null;
+  }
+  return parseNpxCommand(parsed.args);
+}
+function resolvePmSubcommandContext(args) {
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      if (PM_GLOBAL_FLAGS_WITH_VALUE.has(token)) {
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    return {
+      subcommand: token,
+      remaining: args.slice(index + 1)
+    };
+  }
+  return null;
+}
+function firstPositionalToken(tokens) {
+  for (const token of tokens) {
+    if (!token.startsWith("-")) {
+      return token;
+    }
+  }
+  return void 0;
+}
+
+// dist/cli/commands/test.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] = "caa941ed-c848-506c-9a3c-3d4959be0246");
+  } catch (e2) {
+  }
+})();
+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;
+var DEFAULT_LINKED_TEST_PIPE_CLOSE_GRACE_MS = 5e3;
+var MAX_LINKED_TEST_COMMAND_LABEL_LENGTH = 120;
+var LINKED_TEST_TRACKER_DIRS_TO_SKIP = /* @__PURE__ */ new Set(["locks", "extensions", "runtime"]);
+var LINKED_TEST_ITEM_COUNT_DIRS_TO_SKIP = /* @__PURE__ */ new Set(["history", "index", "search", "extensions", "locks", "runtime"]);
+var LINKED_TEST_INFRA_COLLISION_PATTERNS = [
+  /eaddrinuse/i,
+  /address already in use/i,
+  /port\s+\d+\s+is already in use/i,
+  /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",
+  "context",
+  "ctx",
+  "deps",
+  "get",
+  "health",
+  "history",
+  "list",
+  "list-all",
+  "list-blocked",
+  "list-canceled",
+  "list-closed",
+  "list-draft",
+  "list-in-progress",
+  "list-open",
+  "search",
+  "stats",
+  "test-all",
+  "validate"
+]);
+function readPositiveIntegerEnv(name, fallback) {
+  const raw = process.env[name];
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+function linkedTestTimeoutForceKillDelayMs() {
+  return readPositiveIntegerEnv("PM_LINKED_TEST_TIMEOUT_FORCE_KILL_DELAY_MS", DEFAULT_LINKED_TEST_TIMEOUT_FORCE_KILL_DELAY_MS);
+}
+function linkedTestHeartbeatIntervalMs() {
+  return readPositiveIntegerEnv("PM_LINKED_TEST_HEARTBEAT_INTERVAL_MS", DEFAULT_LINKED_TEST_HEARTBEAT_INTERVAL_MS);
+}
+function linkedTestPipeCloseGraceMs() {
+  return readPositiveIntegerEnv("PM_LINKED_TEST_PIPE_CLOSE_GRACE_MS", DEFAULT_LINKED_TEST_PIPE_CLOSE_GRACE_MS);
+}
+function resolveAuthor(candidate, fallback) {
+  const resolved = candidate ?? process.env.PM_AUTHOR ?? fallback;
+  const trimmed = resolved.trim();
+  return trimmed || "unknown";
+}
+function resolveTrackedRunId(kind) {
+  const fromEnv = process.env.PM_BACKGROUND_TEST_RUN_ID?.trim();
+  if (fromEnv && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return `${kind}-local-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function summarizeRunResultStatuses(results) {
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const entry of results) {
+    if (entry.status === "passed") {
+      passed += 1;
+      continue;
+    }
+    if (entry.status === "failed") {
+      failed += 1;
+      continue;
+    }
+    skipped += 1;
+  }
+  return { passed, failed, skipped };
+}
+function summarizeContextPreflight(runResults) {
+  let checkedPmCommands = 0;
+  let trackerReadCommands = 0;
+  let mismatches = 0;
+  let autoRemediated = 0;
+  for (const result of runResults) {
+    const context = result.execution_context;
+    if (!context || context.is_pm_command !== true) {
+      continue;
+    }
+    checkedPmCommands += 1;
+    if (context.is_pm_tracker_read_command === true) {
+      trackerReadCommands += 1;
+    }
+    if (context.mismatch_detected === true) {
+      mismatches += 1;
+    }
+    if (context.auto_pm_context_applied === true) {
+      autoRemediated += 1;
+    }
+  }
+  return {
+    checked_pm_commands: checkedPmCommands,
+    tracker_read_commands: trackerReadCommands,
+    mismatches,
+    auto_remediated: autoRemediated
+  };
+}
+function ensureScope(raw) {
+  const value = raw ?? "project";
+  if (!SCOPE_VALUES.includes(value)) {
+    throw new PmCliError(`Invalid scope "${raw}"`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function parsePmContextMode(raw) {
+  if (!raw) {
+    return "schema";
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (LINKED_TEST_PM_CONTEXT_MODE_VALUES.includes(normalized)) {
+    return normalized;
+  }
+  throw new PmCliError(`Invalid --pm-context value "${raw}". Expected one of: ${LINKED_TEST_PM_CONTEXT_MODE_VALUES.join(", ")}`, EXIT_CODE.USAGE);
+}
+function resolveLinkedTestRequestedContextMode(linkedTest, runLevelMode, overrideLinkedPmContext) {
+  if (overrideLinkedPmContext) {
+    return runLevelMode;
+  }
+  if (typeof linkedTest.pm_context_mode !== "string" || linkedTest.pm_context_mode.trim().length === 0) {
+    return runLevelMode;
+  }
+  return parsePmContextMode(linkedTest.pm_context_mode);
+}
+function resolveLinkedTestEffectiveContextMode(requestedMode, isPmTrackerReadCommand) {
+  if (requestedMode === "auto") {
+    return isPmTrackerReadCommand ? "tracker" : "schema";
+  }
+  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;
+}
+function buildPmContextMismatchHint(params) {
+  const { executionContext, runLevelPmContextMode, linkedOverridePmContextMode } = params;
+  if (!executionContext.is_pm_tracker_read_command || !executionContext.mismatch_detected) {
+    return "";
+  }
+  if (runLevelPmContextMode === "tracker" && linkedOverridePmContextMode === "schema") {
+    return " Linked test metadata pm_context_mode=schema overrides run-level --pm-context tracker. Set pm_context_mode=tracker (or auto) on the linked test, or remove the override, to run against seeded tracker data.";
+  }
+  if (executionContext.pm_context_mode === "schema") {
+    return " Use --pm-context tracker to run PM tracker-read commands against seeded tracker data.";
+  }
+  return "";
+}
+function mergeEnvSetDirectives(entries, optionName) {
+  const merged = {};
+  if (!entries) {
+    return merged;
+  }
+  for (const entry of entries) {
+    const parsed = parseLinkedTestEnvSet(entry, optionName);
+    if (!parsed) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function mergeEnvClearDirectives(entries, optionName) {
+  if (!entries) {
+    return [];
+  }
+  const values = [];
+  for (const entry of entries) {
+    const parsed = parseLinkedTestEnvClear(entry, optionName);
+    if (parsed) {
+      values.push(...parsed);
+    }
+  }
+  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);
+}
+function commandInvokesPmTrackerReadCommand(command) {
+  const normalizedCommand = normalizeCommandForValidation(command);
+  return splitNormalizedCommandSegments(normalizedCommand).some((segment) => {
+    const invocationArgs = extractPmInvocationArgsFromSegment(segment);
+    if (!invocationArgs) {
+      return false;
+    }
+    const context = resolvePmSubcommandContext(invocationArgs);
+    if (!context) {
+      return false;
+    }
+    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;
+  }
+  if (!SCRIPT_RUN_SUBCOMMANDS.has(parsed.subcommand)) {
+    return parsed.subcommand;
+  }
+  return parseLauncherSubcommand(parsed.args, SCRIPT_RUN_FLAGS_WITH_VALUE)?.subcommand;
+}
+function firstDirectTestRunnerSubcommand(executable, args) {
+  if (executable === "npx" || executable === "bunx") {
+    return parseNpxCommand(args)?.command;
+  }
+  if (executable === "pnpm") {
+    return resolveDirectRunnerSubcommand(parseLauncherSubcommand(args, PNPM_GLOBAL_FLAGS_WITH_VALUE));
+  }
+  if (executable === "npm") {
+    return resolveDirectRunnerSubcommand(parseLauncherSubcommand(args, NPM_GLOBAL_FLAGS_WITH_VALUE));
+  }
+  if (executable === "yarn") {
+    return resolveDirectRunnerSubcommand(parseLauncherSubcommand(args, YARN_GLOBAL_FLAGS_WITH_VALUE));
+  }
+  if (executable === "bun") {
+    return resolveDirectRunnerSubcommand(parseLauncherSubcommand(args, BUN_GLOBAL_FLAGS_WITH_VALUE));
+  }
+  return void 0;
+}
+function isDirectTestRunnerSubcommand(token) {
+  if (!token) {
+    return false;
+  }
+  return token === "vitest" || token === "test" || token.startsWith("test:");
+}
+function parsedLauncherInvokesRecursiveTestAll(parsed) {
+  if (!parsed) {
+    return false;
+  }
+  if (!isPmExecutableToken(parsed.command) && !isPmCliPackageToken(parsed.command)) {
+    return false;
+  }
+  return firstPmSubcommand(parsed.args) === "test-all";
+}
+function segmentInvokesRecursiveTestAll(segment) {
+  const rawTokens = segment.split(" ").filter((token) => token.length > 0);
+  const tokens = stripLeadingEnvAssignments(rawTokens);
+  if (tokens.length === 0) {
+    return false;
+  }
+  const [executable, ...args] = tokens;
+  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") {
+    return parsedLauncherInvokesRecursiveTestAll(parseNpxCommand(args));
+  }
+  if (executable === "pnpm") {
+    return parsedLauncherInvokesRecursiveTestAll(parsePnpmDlxCommand(args));
+  }
+  if (executable === "npm") {
+    return parsedLauncherInvokesRecursiveTestAll(parseNpmExecCommand(args));
+  }
+  return false;
+}
+function invokesRecursiveTestAllCommand(command) {
+  const normalized = normalizeCommandForValidation(command);
+  return splitNormalizedCommandSegments(normalized).some((segment) => segmentInvokesRecursiveTestAll(segment));
+}
+function assertNoRecursiveTestAllCommand(command) {
+  if (!invokesRecursiveTestAllCommand(command))
+    return;
+  throw new PmCliError('Linked test commands must not invoke "pm test-all"; this creates recursive orchestration.', EXIT_CODE.USAGE);
+}
+function normalizeCommandForValidation(command) {
+  return command.trim().replaceAll("\\", "/").replaceAll('"', "").replaceAll("'", "").replaceAll(/\s+/g, " ").toLowerCase();
+}
+function commandUsesSandboxRunner(normalizedCommand) {
+  return normalizedCommand.includes("node scripts/run-tests.mjs ") || normalizedCommand.endsWith("node scripts/run-tests.mjs") || normalizedCommand.includes("node ./scripts/run-tests.mjs ") || normalizedCommand.endsWith("node ./scripts/run-tests.mjs");
+}
+function segmentHasExplicitSandboxEnv(normalizedSegment) {
+  const hasExplicitPmPath = /\bpm_path\s*=/.test(normalizedSegment) || /\$env:pm_path\s*=/.test(normalizedSegment);
+  const hasExplicitPmGlobalPath = /\bpm_global_path\s*=/.test(normalizedSegment) || /\$env:pm_global_path\s*=/.test(normalizedSegment);
+  return hasExplicitPmPath && hasExplicitPmGlobalPath;
+}
+function segmentInvokesUnsafeDirectTestRunner(normalizedSegment) {
+  const rawTokens = normalizedSegment.split(" ").filter((token) => token.length > 0);
+  const tokens = stripLeadingEnvAssignments(rawTokens);
+  if (tokens.length === 0) {
+    return false;
+  }
+  const [executable, ...args] = tokens;
+  if (executable === "vitest" || executable.endsWith("/vitest") || executable.endsWith("/vitest.mjs")) {
+    return true;
+  }
+  if (executable === "node") {
+    return nodeArgsInvokeUnsafeDirectTestRunner(args);
+  }
+  return packageManagerInvokesUnsafeDirectTestRunner(executable, args);
+}
+function nodeArgsInvokeUnsafeDirectTestRunner(args) {
+  return args.includes("--test") || args.some((arg) => arg === "vitest" || arg === "vitest.mjs" || arg.endsWith("/vitest") || arg.endsWith("/vitest.mjs"));
+}
+function packageManagerInvokesUnsafeDirectTestRunner(executable, args) {
+  if (executable === "npx" || executable === "bunx") {
+    return isDirectTestRunnerSubcommand(parseNpxCommand(args)?.command);
+  }
+  if (executable === "pnpm" || executable === "npm") {
+    return isDirectTestRunnerSubcommand(parsePackageManagerPmInvocation(executable, args)?.command) || firstDirectTestRunnerSubcommand(executable, args) === "vitest";
+  }
+  return (executable === "yarn" || executable === "bun") && firstDirectTestRunnerSubcommand(executable, args) === "vitest";
+}
+function assertSandboxSafeTestRunnerCommand(command) {
+  const normalized = normalizeCommandForValidation(command);
+  const segments = splitNormalizedCommandSegments(normalized);
+  const hasUnsafeDirectRunnerSegment = segments.some((segment) => !commandUsesSandboxRunner(segment) && segmentInvokesUnsafeDirectTestRunner(segment) && !segmentHasExplicitSandboxEnv(segment));
+  if (!hasUnsafeDirectRunnerSegment) {
+    return;
+  }
+  throw new PmCliError('Linked test runner commands must be sandbox-safe: use "node scripts/run-tests.mjs <test|coverage>", use a package-manager script such as "pnpm test", or include PM_PATH=... PM_GLOBAL_PATH=... INLINE in the command string (exporting them in your shell environment is not checked). Example: "PM_PATH=/tmp/pm-x PM_GLOBAL_PATH=/tmp/pm-x-g vitest run".', EXIT_CODE.USAGE);
+}
+function getRuntimeSafetySkipReason(command) {
+  if (!invokesRecursiveTestAllCommand(command))
+    return void 0;
+  return 'Linked test command skipped: Linked test commands must not invoke "pm test-all"; this creates recursive orchestration.';
+}
+function parseAddEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.map(parseAddEntry);
+}
+function parseAddEntry(entry) {
+  const trimmed = entry.trim();
+  const kv = looksLikeStructuredLinkedTestEntry(trimmed) ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add") : { command: trimmed };
+  const command = trimLinkedTestEntryField(kv.command);
+  if (!command) {
+    throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+  }
+  assertNoRecursiveTestAllCommand(command);
+  assertSandboxSafeTestRunnerCommand(command);
+  return {
+    command,
+    path: trimLinkedTestEntryField(kv.path),
+    scope: ensureScope(kv.scope),
+    timeout_seconds: parseLinkedTestTimeoutSeconds(trimLinkedTestEntryField(kv.timeout_seconds), trimLinkedTestEntryField(kv.timeout)),
+    pm_context_mode: parseLinkedTestContextMode(trimLinkedTestEntryField(kv.pm_context_mode), "--add"),
+    env_set: parseLinkedTestEnvSet(trimLinkedTestEntryField(kv.env_set), "--add"),
+    env_clear: parseLinkedTestEnvClear(trimLinkedTestEntryField(kv.env_clear), "--add"),
+    shared_host_safe: parseLinkedTestBoolean(trimLinkedTestEntryField(kv.shared_host_safe), "--add", "shared_host_safe"),
+    assert_stdout_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stdout_contains)),
+    assert_stdout_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stdout_regex), "--add", "assert_stdout_regex"),
+    assert_stderr_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stderr_contains)),
+    assert_stderr_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stderr_regex), "--add", "assert_stderr_regex"),
+    assert_stdout_min_lines: parseLinkedTestMinLines(trimLinkedTestEntryField(kv.assert_stdout_min_lines), "--add"),
+    assert_json_field_equals: parseLinkedTestAssertionEqualsMap(trimLinkedTestEntryField(kv.assert_json_field_equals), "--add"),
+    assert_json_field_gte: parseLinkedTestAssertionGteMap(trimLinkedTestEntryField(kv.assert_json_field_gte), "--add"),
+    note: trimLinkedTestEntryField(kv.note)
+  };
+}
+function trimLinkedTestEntryField(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function parseLinkedTestTimeoutSeconds(timeoutSecondsRaw, timeoutAliasRaw) {
+  if (timeoutSecondsRaw && timeoutAliasRaw && 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"));
+}
+function parseAddJsonEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.flatMap((entry) => {
+    const parsed = parseLinkedTestJsonEntries(entry, "--add-json");
+    for (const linkedTest of parsed) {
+      const command = linkedTest.command;
+      if (!command) {
+        throw new PmCliError("--add-json requires a non-empty command string", EXIT_CODE.USAGE);
+      }
+      assertNoRecursiveTestAllCommand(command);
+      assertSandboxSafeTestRunnerCommand(command);
+    }
+    return parsed;
+  });
+}
+function parseRemoveEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.map((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      throw new PmCliError("--remove requires command or path value", EXIT_CODE.USAGE);
+    }
+    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:path|command)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+      const kv = parseCsvKv(trimmed, "--remove");
+      const value = kv.path ?? kv.command;
+      if (!value?.trim()) {
+        throw new PmCliError("--remove requires command=<value> and/or path=<value>", EXIT_CODE.USAGE);
+      }
+      return value.trim();
+    }
+    return trimmed;
+  });
+}
+function closeLinkedTestStdin(child) {
+  try {
+    child.stdin?.end();
+  } catch {
+  }
+}
+function summarizeLinkedTestCommand(command) {
+  const normalized = command.trim().replaceAll(/\s+/g, " ");
+  if (normalized.length <= MAX_LINKED_TEST_COMMAND_LABEL_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_LINKED_TEST_COMMAND_LABEL_LENGTH - 3)}...`;
+}
+function shouldEmitLinkedTestProgress(mode) {
+  if (mode === "off") {
+    return false;
+  }
+  if (mode === "always") {
+    return true;
+  }
+  return process.stderr.isTTY === true;
+}
+function emitLinkedTestProgress(message) {
+  try {
+    process.stderr.write(`${message}
+`);
+  } catch {
+  }
+}
+function beginLinkedTestProgress(context, mode) {
+  if (!shouldEmitLinkedTestProgress(mode)) {
+    return null;
+  }
+  const commandLabel = summarizeLinkedTestCommand(context.command);
+  const startAt = Date.now();
+  emitLinkedTestProgress(`[pm test] linked-test ${context.index}/${context.total} start timeout_ms=${context.timeoutMs} command="${commandLabel}"`);
+  const heartbeat = setInterval(() => {
+    const elapsedMs = Date.now() - startAt;
+    emitLinkedTestProgress(`[pm test] linked-test ${context.index}/${context.total} running elapsed_ms=${elapsedMs} command="${commandLabel}"`);
+  }, linkedTestHeartbeatIntervalMs());
+  heartbeat.unref?.();
+  return heartbeat;
+}
+function endLinkedTestProgress(context, executionResult, startedAt, mode) {
+  if (!shouldEmitLinkedTestProgress(mode)) {
+    return;
+  }
+  const commandLabel = summarizeLinkedTestCommand(context.command);
+  const elapsedMs = Date.now() - startedAt;
+  const failed = executionResult.timedOut || executionResult.maxBufferExceeded || executionResult.exitCode !== 0;
+  const statusLabel = failed ? "failed" : "passed";
+  const reasonTokens = [];
+  if (executionResult.timedOut) {
+    reasonTokens.push("reason=timeout");
+  }
+  if (executionResult.maxBufferExceeded) {
+    reasonTokens.push("reason=max_buffer");
+  }
+  if (executionResult.signal) {
+    reasonTokens.push(`signal=${executionResult.signal}`);
+  }
+  const exitLabel = executionResult.exitCode === null ? "null" : String(executionResult.exitCode);
+  const reasonSuffix = reasonTokens.length > 0 ? ` ${reasonTokens.join(" ")}` : "";
+  emitLinkedTestProgress(`[pm test] linked-test ${context.index}/${context.total} end status=${statusLabel} exit_code=${exitLabel} elapsed_ms=${elapsedMs}${reasonSuffix} command="${commandLabel}"`);
+}
+async function killProcessTree(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return;
+  }
+  if (process.platform === "win32") {
+    await new Promise((resolve) => {
+      const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.on("error", () => resolve());
+      killer.on("close", () => resolve());
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+    return;
+  } catch {
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function runLinkedTestCommand(command, timeoutMs, env, progressContext, progressMode) {
+  const startedAt = Date.now();
+  const heartbeat = beginLinkedTestProgress(progressContext, progressMode);
+  const child = spawn(command, {
+    cwd: process.cwd(),
+    env,
+    shell: true,
+    windowsHide: true,
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  closeLinkedTestStdin(child);
+  let stdout = "";
+  let stderr = "";
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  let timedOut = false;
+  let maxBufferExceeded = false;
+  let spawnError;
+  let forceKillTimer = null;
+  let timedOutTimer = null;
+  let terminationRequested = false;
+  const clearTimers = () => {
+    if (heartbeat) {
+      clearInterval(heartbeat);
+    }
+    if (timedOutTimer) {
+      clearTimeout(timedOutTimer);
+      timedOutTimer = null;
+    }
+    if (forceKillTimer) {
+      clearTimeout(forceKillTimer);
+      forceKillTimer = null;
+    }
+  };
+  const requestTermination = async () => {
+    if (terminationRequested) {
+      return;
+    }
+    terminationRequested = true;
+    const pid = child.pid;
+    if (!pid || pid <= 0) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      return;
+    }
+    if (process.platform === "win32") {
+      await killProcessTree(pid);
+      return;
+    }
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    forceKillTimer = setTimeout(() => {
+      void killProcessTree(pid);
+    }, linkedTestTimeoutForceKillDelayMs());
+    forceKillTimer.unref?.();
+  };
+  const appendChunk = (chunk, target) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    const bytes = Buffer.byteLength(text);
+    if (target === "stdout") {
+      stdoutBytes += bytes;
+      if (stdoutBytes <= TEST_OUTPUT_MAX_BUFFER_BYTES) {
+        stdout += text;
+      }
+    } else {
+      stderrBytes += bytes;
+      if (stderrBytes <= TEST_OUTPUT_MAX_BUFFER_BYTES) {
+        stderr += text;
+      }
+    }
+    if (!maxBufferExceeded && (stdoutBytes > TEST_OUTPUT_MAX_BUFFER_BYTES || stderrBytes > TEST_OUTPUT_MAX_BUFFER_BYTES)) {
+      maxBufferExceeded = true;
+      void requestTermination();
+    }
+  };
+  child.stdout?.on("data", (chunk) => appendChunk(chunk, "stdout"));
+  child.stderr?.on("data", (chunk) => appendChunk(chunk, "stderr"));
+  child.on("error", (error) => {
+    spawnError = error.message;
+  });
+  timedOutTimer = setTimeout(() => {
+    timedOut = true;
+    void requestTermination();
+  }, timeoutMs);
+  timedOutTimer.unref?.();
+  const { code, signal } = await new Promise((resolve) => {
+    let settled = false;
+    let pipeCloseGraceTimer = null;
+    const settle = (value, destroyPipes = false) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (pipeCloseGraceTimer) {
+        clearTimeout(pipeCloseGraceTimer);
+        pipeCloseGraceTimer = null;
+      }
+      if (destroyPipes) {
+        child.stdin?.destroy();
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+      }
+      resolve(value);
+    };
+    child.on("exit", (exitCode, exitSignal) => {
+      if (settled) {
+        return;
+      }
+      pipeCloseGraceTimer = setTimeout(() => {
+        settle({
+          code: exitCode,
+          signal: exitSignal
+        }, true);
+      }, linkedTestPipeCloseGraceMs());
+      pipeCloseGraceTimer.unref?.();
+    });
+    child.on("close", (closeCode, closeSignal) => {
+      settle({
+        code: closeCode,
+        signal: closeSignal
+      });
+    });
+  });
+  clearTimers();
+  const executionResult = {
+    stdout,
+    stderr,
+    exitCode: code,
+    signal,
+    timedOut,
+    maxBufferExceeded,
+    spawnError
+  };
+  endLinkedTestProgress(progressContext, executionResult, startedAt, progressMode);
+  return executionResult;
+}
+function formatLinkedTestExecutionError(result, timeoutMs) {
+  const details = [];
+  if (result.maxBufferExceeded) {
+    details.push(`Linked test output exceeded maxBuffer=${TEST_OUTPUT_MAX_BUFFER_BYTES} bytes. Reduce output volume or split the command.`);
+  }
+  if (result.timedOut && timeoutMs > 0) {
+    details.push(`Linked test timed out after ${timeoutMs}ms.`);
+  }
+  const signalMessage = result.signal ? `Linked test command terminated by signal ${result.signal}.` : void 0;
+  const baseMessage = result.spawnError?.trim() || signalMessage || "Linked test command failed.";
+  if (details.length === 0) {
+    return baseMessage;
+  }
+  return `${baseMessage} ${details.join(" ")}`;
+}
+function hasInfraCollisionSignal(result) {
+  const combined = [result.spawnError ?? "", result.stderr, result.stdout].join("\n");
+  return LINKED_TEST_INFRA_COLLISION_PATTERNS.some((pattern) => pattern.test(combined));
+}
+function classifyLinkedTestFailure(result) {
+  if (hasInfraCollisionSignal(result)) {
+    return "infra_collision";
+  }
+  if (result.timedOut) {
+    return "timeout";
+  }
+  if (result.maxBufferExceeded) {
+    return "max_buffer";
+  }
+  if (result.spawnError) {
+    return "spawn_error";
+  }
+  if (result.signal) {
+    return "signal";
+  }
+  return "assertion_failure";
+}
+function createEmptyFailureCategoryCounts() {
+  return {
+    infra_collision: 0,
+    assertion_failure: 0,
+    empty_run: 0,
+    timeout: 0,
+    max_buffer: 0,
+    spawn_error: 0,
+    signal: 0
+  };
+}
+function countFailureCategories(runResults) {
+  const counts = createEmptyFailureCategoryCounts();
+  for (const result of runResults) {
+    if (result.status !== "failed" || !result.failure_category) {
+      continue;
+    }
+    counts[result.failure_category] += 1;
+  }
+  return counts;
+}
+function applyEnvDirectiveStage(env, directives) {
+  for (const [key, value] of Object.entries(directives.env_set)) {
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      continue;
+    }
+    env[key] = value;
+  }
+  for (const key of directives.env_clear) {
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      continue;
+    }
+    delete env[key];
+  }
+}
+function applySharedHostSafeDefaults(env) {
+  if (env.PORT === void 0) {
+    env.PORT = "0";
+  }
+  if (env.HOST === void 0) {
+    env.HOST = "127.0.0.1";
+  }
+  if (env.PM_SHARED_HOST_SAFE === void 0) {
+    env.PM_SHARED_HOST_SAFE = "1";
+  }
+  if (env.PLAYWRIGHT_HTML_OPEN === void 0) {
+    env.PLAYWRIGHT_HTML_OPEN = "never";
+  }
+  if (env.PW_TEST_HTML_REPORT_OPEN === void 0) {
+    env.PW_TEST_HTML_REPORT_OPEN = "never";
+  }
+}
+function resolveEffectiveLinkedTestDirectives(runtimeDirectives, linkedTest) {
+  const envSet = { ...runtimeDirectives.env_set, ...linkedTest.env_set };
+  const envClear = [.../* @__PURE__ */ new Set([...runtimeDirectives.env_clear, ...linkedTest.env_clear ?? []])];
+  const sharedHostSafe = linkedTest.shared_host_safe ?? runtimeDirectives.shared_host_safe;
+  return {
+    env_set: envSet,
+    env_clear: envClear,
+    shared_host_safe: sharedHostSafe
+  };
+}
+function resolveRuntimeDirectives(envSetEntries, envClearEntries, sharedHostSafe) {
+  return {
+    env_set: mergeEnvSetDirectives(envSetEntries, "--env-set"),
+    env_clear: mergeEnvClearDirectives(envClearEntries, "--env-clear"),
+    shared_host_safe: sharedHostSafe === true
+  };
+}
+async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = false) {
+  if (!await pathExists(sourcePath)) {
+    return;
+  }
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  try {
+    if (recursive) {
+      await cp(sourcePath, targetPath, { recursive: true, force: true });
+      return;
+    }
+    await cp(sourcePath, targetPath, { force: true });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function seedLinkedTestSandbox(sandboxPmPath, sandboxGlobalPath, sourceRoots) {
+  await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.projectPmRoot), getSettingsPath(sandboxPmPath));
+  await copyIntoSandboxIfPresent(path.join(sourceRoots.projectPmRoot, "extensions"), path.join(sandboxPmPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.globalPmRoot), getSettingsPath(sandboxGlobalPath));
+  await copyIntoSandboxIfPresent(path.join(sourceRoots.globalPmRoot, "extensions"), path.join(sandboxGlobalPath, "extensions"), true);
+}
+async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
+  if (!await pathExists(sourceRoot)) {
+    return;
+  }
+  const entries = await readdir(sourceRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (LINKED_TEST_TRACKER_DIRS_TO_SKIP.has(entry.name)) {
+      continue;
+    }
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const targetPath = path.join(sandboxRoot, entry.name);
+    if (entry.isDirectory()) {
+      await copyIntoSandboxIfPresent(sourcePath, targetPath, true);
+      continue;
+    }
+    if (entry.isFile()) {
+      await copyIntoSandboxIfPresent(sourcePath, targetPath);
+    }
+  }
+}
+async function countLinkedTestItemFiles(pmRoot) {
+  if (!await pathExists(pmRoot)) {
+    return 0;
+  }
+  let total = 0;
+  const entries = await readdir(pmRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || LINKED_TEST_ITEM_COUNT_DIRS_TO_SKIP.has(entry.name)) {
+      continue;
+    }
+    const folderPath = path.join(pmRoot, entry.name);
+    let files;
+    try {
+      files = await readdir(folderPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.isFile()) {
+        continue;
+      }
+      if (ITEM_FILE_EXTENSIONS.some((extension) => file.name.toLowerCase().endsWith(extension))) {
+        total += 1;
+      }
+    }
+  }
+  return total;
+}
+function resolveLinkedTestFailureExitCode(execution) {
+  const rawExitCode = typeof execution.exitCode === "number" ? execution.exitCode : 1;
+  if ((execution.timedOut || execution.maxBufferExceeded) && rawExitCode === 0) {
+    return 1;
+  }
+  return rawExitCode;
+}
+function splitJsonPathSegments(fieldPath) {
+  const segments = [];
+  const tokens = fieldPath.match(/[^.[\]]+|\[\d+\]/g) ?? [];
+  for (const token of tokens) {
+    if (token.startsWith("[") && token.endsWith("]")) {
+      const parsedIndex = Number.parseInt(token.slice(1, -1), 10);
+      if (!Number.isInteger(parsedIndex) || parsedIndex < 0) {
+        return [];
+      }
+      segments.push(parsedIndex);
+      continue;
+    }
+    segments.push(token);
+  }
+  return segments;
+}
+function readJsonPathValue(root, fieldPath) {
+  const normalizedPath = fieldPath.trim();
+  if (normalizedPath.length === 0) {
+    return { found: false, value: void 0 };
+  }
+  const segments = splitJsonPathSegments(normalizedPath);
+  if (segments.length === 0) {
+    return { found: false, value: void 0 };
+  }
+  let current = root;
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      if (!Array.isArray(current) || segment >= current.length) {
+        return { found: false, value: void 0 };
+      }
+      current = current[segment];
+      continue;
+    }
+    if (typeof current !== "object" || current === null || !(segment in current)) {
+      return { found: false, value: void 0 };
+    }
+    current = current[segment];
+  }
+  return { found: true, value: current };
+}
+function parseAssertionLiteral(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  if (trimmed === "null") {
+    return null;
+  }
+  const numeric = Number(trimmed);
+  if (trimmed.length > 0 && Number.isFinite(numeric)) {
+    return numeric;
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function compareAssertionValues(actual, expected) {
+  if (typeof actual === "object" && actual !== null && typeof expected === "object" && expected !== null) {
+    return stableValueEquals(actual, expected);
+  }
+  return Object.is(actual, expected);
+}
+function evaluateLinkedTestAssertions(linkedTest, stdout, stderr) {
+  const failures = [];
+  failures.push(...evaluateContainsAssertions("stdout", stdout, linkedTest.assert_stdout_contains));
+  failures.push(...evaluateRegexAssertions("stdout", stdout, linkedTest.assert_stdout_regex));
+  failures.push(...evaluateContainsAssertions("stderr", stderr, linkedTest.assert_stderr_contains));
+  failures.push(...evaluateRegexAssertions("stderr", stderr, linkedTest.assert_stderr_regex));
+  failures.push(...evaluateStdoutLineCountAssertion(stdout, linkedTest.assert_stdout_min_lines));
+  const jsonEqualsAssertions = linkedTest.assert_json_field_equals ?? {};
+  const jsonGteAssertions = linkedTest.assert_json_field_gte ?? {};
+  const needsJsonAssertions = Object.keys(jsonEqualsAssertions).length > 0 || Object.keys(jsonGteAssertions).length > 0;
+  if (!needsJsonAssertions) {
+    return failures;
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(stdout);
+  } catch (error) {
+    failures.push(`stdout is not valid JSON for assert_json_field_* checks: ${error instanceof Error ? error.message : String(error)}`);
+    return failures;
+  }
+  for (const [fieldPath, expectedRaw] of Object.entries(jsonEqualsAssertions)) {
+    const resolved = readJsonPathValue(parsedJson, fieldPath);
+    if (!resolved.found) {
+      failures.push(`assert_json_field_equals missing path "${fieldPath}"`);
+      continue;
+    }
+    const expected = parseAssertionLiteral(expectedRaw);
+    if (!compareAssertionValues(resolved.value, expected)) {
+      failures.push(`assert_json_field_equals mismatch at "${fieldPath}" (expected=${JSON.stringify(expected)} actual=${JSON.stringify(resolved.value)})`);
+    }
+  }
+  for (const [fieldPath, expectedMinimum] of Object.entries(jsonGteAssertions)) {
+    const resolved = readJsonPathValue(parsedJson, fieldPath);
+    if (!resolved.found) {
+      failures.push(`assert_json_field_gte missing path "${fieldPath}"`);
+      continue;
+    }
+    if (typeof resolved.value !== "number" || !Number.isFinite(resolved.value)) {
+      failures.push(`assert_json_field_gte path "${fieldPath}" resolved to non-numeric value`);
+      continue;
+    }
+    if (resolved.value < expectedMinimum) {
+      failures.push(`assert_json_field_gte failed at "${fieldPath}" (expected >= ${expectedMinimum}, actual ${resolved.value})`);
+    }
+  }
+  return failures;
+}
+function evaluateContainsAssertions(streamName, output, expectedValues) {
+  const failures = [];
+  for (const expected of expectedValues ?? []) {
+    if (!output.includes(expected)) {
+      failures.push(`${streamName} missing required text: "${expected}"`);
+    }
+  }
+  return failures;
+}
+function evaluateRegexAssertions(streamName, output, patterns) {
+  const failures = [];
+  for (const pattern of patterns ?? []) {
+    try {
+      const regex = new RegExp(pattern, "m");
+      if (!regex.test(output)) {
+        failures.push(`${streamName} failed regex assertion: /${pattern}/m`);
+      }
+    } catch (error) {
+      failures.push(`${streamName} regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+  return failures;
+}
+function evaluateStdoutLineCountAssertion(stdout, minimum) {
+  if (typeof minimum !== "number") {
+    return [];
+  }
+  const lineCount = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).length;
+  return lineCount < minimum ? [`stdout line count ${lineCount} is below required minimum ${minimum}`] : [];
+}
+var EMPTY_LINKED_TEST_RUN_PATTERNS = [
+  { code: "no_projects_matched_filters", regex: /\bNo projects matched the filters\b/i },
+  { code: "no_test_files_found", regex: /\bNo test files found\b/i },
+  { code: "no_tests_found", regex: /\bNo tests found\b/i },
+  { code: "no_matching_tests", regex: /\bNo matching tests?\b/i },
+  { code: "collected_zero_items", regex: /\bcollected 0 items?\b/i }
+];
+function detectEmptyLinkedTestRun(stdout, stderr) {
+  const combined = `${stdout}
+${stderr}`;
+  for (const pattern of EMPTY_LINKED_TEST_RUN_PATTERNS) {
+    if (pattern.regex.test(combined)) {
+      return pattern.code;
+    }
+  }
+  return null;
+}
+function createLinkedTestSandboxLayout(sandboxRoot) {
+  return {
+    root: sandboxRoot,
+    schemaProjectPmPath: path.join(sandboxRoot, "schema", "project", ".agents", "pm"),
+    schemaGlobalPmPath: path.join(sandboxRoot, "schema", "global"),
+    trackerProjectPmPath: path.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
+    trackerGlobalPmPath: path.join(sandboxRoot, "tracker", "global")
+  };
+}
+async function initializeLinkedTestSandboxes(layout) {
+  await runInit(void 0, { path: layout.schemaProjectPmPath });
+  await runInit(void 0, { path: layout.schemaGlobalPmPath });
+  await runInit(void 0, { path: layout.trackerProjectPmPath });
+  await runInit(void 0, { path: layout.trackerGlobalPmPath });
+}
+async function seedLinkedTestSandboxesFromSource(layout, sourceRoots) {
+  if (!sourceRoots) {
+    return;
+  }
+  await seedLinkedTestSandbox(layout.schemaProjectPmPath, layout.schemaGlobalPmPath, sourceRoots);
+  await seedLinkedTestSandbox(layout.trackerProjectPmPath, layout.trackerGlobalPmPath, sourceRoots);
+  await seedLinkedTestTrackerData(sourceRoots.projectPmRoot, layout.trackerProjectPmPath);
+  await seedLinkedTestTrackerData(sourceRoots.globalPmRoot, layout.trackerGlobalPmPath);
+}
+async function countLinkedTestSandboxItems(layout, sourceRoots) {
+  return {
+    sourceProjectItemCount: sourceRoots ? await countLinkedTestItemFiles(sourceRoots.projectPmRoot) : 0,
+    sourceGlobalItemCount: sourceRoots ? await countLinkedTestItemFiles(sourceRoots.globalPmRoot) : 0,
+    schemaProjectItemCount: await countLinkedTestItemFiles(layout.schemaProjectPmPath),
+    schemaGlobalItemCount: await countLinkedTestItemFiles(layout.schemaGlobalPmPath),
+    trackerProjectItemCount: await countLinkedTestItemFiles(layout.trackerProjectPmPath),
+    trackerGlobalItemCount: await countLinkedTestItemFiles(layout.trackerGlobalPmPath)
+  };
+}
+function buildLinkedTestExecutionContext(params) {
+  const trackerMode = params.effectivePmContextMode === "tracker";
+  const selectedSandboxProjectPmPath = trackerMode ? params.layout.trackerProjectPmPath : params.layout.schemaProjectPmPath;
+  const selectedSandboxGlobalPmPath = trackerMode ? params.layout.trackerGlobalPmPath : params.layout.schemaGlobalPmPath;
+  const selectedSandboxProjectItemCount = trackerMode ? params.counts.trackerProjectItemCount : params.counts.schemaProjectItemCount;
+  const selectedSandboxGlobalItemCount = trackerMode ? params.counts.trackerGlobalItemCount : params.counts.schemaGlobalItemCount;
+  return {
+    requested_pm_context_mode: params.requestedPmContextMode,
+    pm_context_mode: params.effectivePmContextMode,
+    auto_pm_context_applied: params.autoPmContextApplied,
+    is_pm_command: params.isPmCommand,
+    is_pm_tracker_read_command: params.isPmTrackerReadCommand,
+    source_project_pm_path: params.sourceRoots?.projectPmRoot ?? "",
+    sandbox_project_pm_path: selectedSandboxProjectPmPath,
+    source_global_pm_path: params.sourceRoots?.globalPmRoot ?? "",
+    sandbox_global_pm_path: selectedSandboxGlobalPmPath,
+    source_project_item_count: params.counts.sourceProjectItemCount,
+    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,
+    project_extensions_seeded: Boolean(params.sourceRoots),
+    global_extensions_seeded: Boolean(params.sourceRoots)
+  };
+}
+function resolveLinkedTestCommandContext(params) {
+  const linkedOverridePmContextMode = typeof params.linkedTest.pm_context_mode === "string" && params.linkedTest.pm_context_mode.trim().length > 0 ? parsePmContextMode(params.linkedTest.pm_context_mode) : void 0;
+  const command = typeof params.linkedTest.command === "string" && params.linkedTest.command.length > 0 ? params.linkedTest.command : void 0;
+  const isPmCommand = command ? commandInvokesPmCli(command) : false;
+  const isPmTrackerReadCommand = isPmCommand && command ? commandInvokesPmTrackerReadCommand(command) : false;
+  const autoPmContextApplied = params.options?.autoPmContext === true && isPmTrackerReadCommand;
+  const requestedPmContextMode = autoPmContextApplied ? "auto" : resolveLinkedTestRequestedContextMode(params.linkedTest, params.runLevelPmContextMode, params.options?.overrideLinkedPmContext === true);
+  const effectivePmContextMode = resolveLinkedTestEffectiveContextMode(requestedPmContextMode, isPmTrackerReadCommand);
+  return {
+    linkedOverridePmContextMode,
+    executionContext: buildLinkedTestExecutionContext({
+      layout: params.layout,
+      counts: params.counts,
+      sourceRoots: params.sourceRoots,
+      isPmCommand,
+      isPmTrackerReadCommand,
+      requestedPmContextMode,
+      effectivePmContextMode,
+      autoPmContextApplied
+    })
+  };
+}
+function buildLinkedTestSkippedResult(linkedTest, executionContext, error) {
+  return {
+    command: linkedTest.command,
+    path: linkedTest.path,
+    status: "skipped",
+    execution_context: executionContext,
+    error
+  };
+}
+function buildLinkedTestAssertionFailureResult(linkedTest, executionContext, error, output) {
+  return {
+    command: linkedTest.command,
+    path: linkedTest.path,
+    status: "failed",
+    exit_code: 1,
+    failure_category: "assertion_failure",
+    execution_context: executionContext,
+    ...output ? { stdout: output.stdout, stderr: output.stderr } : {},
+    error
+  };
+}
+function resolveLinkedTestPreflightResult(params) {
+  if (!params.linkedTest.command) {
+    return buildLinkedTestSkippedResult(params.linkedTest, params.executionContext, "No command configured for this linked test.");
+  }
+  const runtimeSafetySkipReason = getRuntimeSafetySkipReason(params.linkedTest.command);
+  if (runtimeSafetySkipReason) {
+    return buildLinkedTestSkippedResult(params.linkedTest, params.executionContext, runtimeSafetySkipReason);
+  }
+  const failOnMismatchByDefault = params.executionContext.pm_context_mode === "schema" && params.executionContext.is_pm_tracker_read_command && params.executionContext.mismatch_detected;
+  const failOnMismatchByFlag = params.options?.failOnContextMismatch === true && params.executionContext.is_pm_command && params.executionContext.mismatch_detected;
+  if (failOnMismatchByDefault || failOnMismatchByFlag) {
+    const mismatchHint = buildPmContextMismatchHint({
+      executionContext: params.executionContext,
+      runLevelPmContextMode: params.runLevelPmContextMode,
+      linkedOverridePmContextMode: params.linkedOverridePmContextMode
+    });
+    const mismatchPrefix = params.options?.checkContext === true ? "Linked test preflight PM context mismatch detected" : "Linked test PM context mismatch detected";
+    return buildLinkedTestAssertionFailureResult(params.linkedTest, params.executionContext, `${mismatchPrefix} (source_project_items=${params.executionContext.source_project_item_count}, sandbox_project_items=${params.executionContext.sandbox_project_item_count}).${mismatchHint}`);
+  }
+  if (params.options?.requireAssertionsForPm === true && params.executionContext.is_pm_command && !hasLinkedTestAssertions(params.linkedTest)) {
+    return buildLinkedTestAssertionFailureResult(params.linkedTest, params.executionContext, "Linked PM command requires assertions when --require-assertions-for-pm is enabled.");
+  }
+  return null;
+}
+function buildLinkedTestExecutionEnv(params) {
+  const effectiveDirectives = resolveEffectiveLinkedTestDirectives(params.runtimeDirectives, params.linkedTest);
+  const executionEnv = { ...process.env };
+  applyEnvDirectiveStage(executionEnv, params.runtimeDirectives);
+  applyEnvDirectiveStage(executionEnv, {
+    env_set: params.linkedTest.env_set ?? {},
+    env_clear: params.linkedTest.env_clear ?? []
+  });
+  if (effectiveDirectives.shared_host_safe) {
+    applySharedHostSafeDefaults(executionEnv);
+  }
+  executionEnv.FORCE_COLOR = "0";
+  executionEnv.PM_PATH = params.executionContext.sandbox_project_pm_path;
+  executionEnv.PM_GLOBAL_PATH = params.executionContext.sandbox_global_pm_path;
+  return executionEnv;
+}
+function buildLinkedTestPassedResult(linkedTest, executionContext, execution) {
+  return {
+    command: linkedTest.command,
+    path: linkedTest.path,
+    status: "passed",
+    exit_code: 0,
+    execution_context: executionContext,
+    stdout: execution.stdout,
+    stderr: execution.stderr
+  };
+}
+function buildLinkedTestEmptyRunResult(params) {
+  return {
+    command: params.linkedTest.command,
+    path: params.linkedTest.path,
+    status: "failed",
+    exit_code: 1,
+    failure_category: "empty_run",
+    execution_context: params.executionContext,
+    stdout: params.execution.stdout,
+    stderr: params.execution.stderr,
+    error: `Linked test reported an empty test run (${params.emptyRunSignal}) while --fail-on-empty-test-run is enabled. Update test selection or disable --fail-on-empty-test-run for this run.`
+  };
+}
+function buildLinkedTestCommandFailureResult(params) {
+  return {
+    command: params.linkedTest.command,
+    path: params.linkedTest.path,
+    status: "failed",
+    exit_code: resolveLinkedTestFailureExitCode(params.execution),
+    failure_category: classifyLinkedTestFailure(params.execution),
+    execution_context: params.executionContext,
+    stdout: params.execution.stdout,
+    stderr: params.execution.stderr,
+    error: formatLinkedTestExecutionError(params.execution, params.timeoutMs)
+  };
+}
+function buildLinkedTestPassedExecutionResult(params) {
+  if (params.options?.failOnEmptyTestRun === true) {
+    const emptyRunSignal = detectEmptyLinkedTestRun(params.execution.stdout, params.execution.stderr);
+    if (emptyRunSignal) {
+      return buildLinkedTestEmptyRunResult({ ...params, emptyRunSignal });
+    }
+  }
+  const assertionFailures = evaluateLinkedTestAssertions(params.linkedTest, params.execution.stdout, params.execution.stderr);
+  if (assertionFailures.length > 0) {
+    return buildLinkedTestAssertionFailureResult(params.linkedTest, params.executionContext, `Linked test assertion(s) failed: ${assertionFailures.join("; ")}`, params.execution);
+  }
+  return buildLinkedTestPassedResult(params.linkedTest, params.executionContext, params.execution);
+}
+async function runSingleLinkedTest(params) {
+  const command = params.linkedTest.command ?? "";
+  const timeoutMs = (params.linkedTest.timeout_seconds ?? params.defaultTimeoutSeconds ?? 120) * 1e3;
+  const execution = await runLinkedTestCommand(command, timeoutMs, buildLinkedTestExecutionEnv(params), {
+    index: params.index + 1,
+    total: params.total,
+    timeoutMs,
+    command
+  }, params.progressMode);
+  const passed = execution.exitCode === 0 && !execution.timedOut && !execution.maxBufferExceeded;
+  return passed ? buildLinkedTestPassedExecutionResult({ ...params, execution }) : buildLinkedTestCommandFailureResult({ ...params, execution, timeoutMs });
+}
+async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
+  const results = [];
+  const sandboxRoot = await mkdtemp(path.join(tmpdir(), "pm-linked-test-"));
+  const layout = createLinkedTestSandboxLayout(sandboxRoot);
+  const runLevelPmContextMode = parsePmContextMode(options?.pmContext);
+  const progressMode = options?.progress === true ? "always" : "auto";
+  const runtimeDirectives = resolveRuntimeDirectives(options?.envSet, options?.envClear, options?.sharedHostSafe);
+  const sourceRoots = options?.sourceRoots;
+  try {
+    await initializeLinkedTestSandboxes(layout);
+    await seedLinkedTestSandboxesFromSource(layout, sourceRoots);
+    const counts = await countLinkedTestSandboxItems(layout, sourceRoots);
+    for (let index = 0; index < tests.length; index += 1) {
+      const linkedTest = tests[index];
+      const commandContext = resolveLinkedTestCommandContext({
+        linkedTest,
+        layout,
+        counts,
+        sourceRoots,
+        runLevelPmContextMode,
+        options
+      });
+      const preflightResult = resolveLinkedTestPreflightResult({
+        linkedTest,
+        executionContext: commandContext.executionContext,
+        runLevelPmContextMode,
+        linkedOverridePmContextMode: commandContext.linkedOverridePmContextMode,
+        options
+      });
+      if (preflightResult) {
+        results.push(preflightResult);
+        continue;
+      }
+      results.push(await runSingleLinkedTest({
+        linkedTest,
+        index,
+        total: tests.length,
+        defaultTimeoutSeconds,
+        runtimeDirectives,
+        progressMode,
+        executionContext: commandContext.executionContext,
+        options
+      }));
+    }
+  } finally {
+    await rm(layout.root, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+  return results;
+}
+function hasTestRuntimeDirectiveFlags(options) {
+  return (options.envSet?.length ?? 0) > 0 || (options.envClear?.length ?? 0) > 0 || options.sharedHostSafe === true || options.pmContext !== void 0 || options.overrideLinkedPmContext === true || options.failOnContextMismatch === true || options.failOnSkipped === true || options.failOnEmptyTestRun === true || options.requireAssertionsForPm === true || options.checkContext === true || options.autoPmContext === true;
+}
+function assertTestRunFlagUsage(options) {
+  if (hasTestRuntimeDirectiveFlags(options) && options.run !== true) {
+    throw new PmCliError("--env-set, --env-clear, --shared-host-safe, --pm-context, --override-linked-pm-context, --fail-on-context-mismatch, --fail-on-skipped, --fail-on-empty-test-run, --require-assertions-for-pm, --check-context, and --auto-pm-context require --run", EXIT_CODE.USAGE);
+  }
+  const hasSelectorFlags = options.match !== void 0 || options.onlyIndex !== void 0 || options.onlyLast === true;
+  if (hasSelectorFlags && options.run !== true) {
+    throw new PmCliError("--match, --only-index, and --only-last require --run", EXIT_CODE.USAGE);
+  }
+}
+async function resolveLinkedTestItem(params) {
+  const { id, options, pmRoot, settings, typeToFolder, adds, removes } = params;
+  if (adds.length === 0 && removes.length === 0) {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
+    if (!located) {
+      throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+    }
+    const loaded = await readLocatedItem(located, { schema: settings.schema });
+    return { itemId: located.id, tests: loaded.document.metadata.tests ?? [], changed: false };
+  }
+  const result = await mutateItem({
+    pmRoot,
+    settings,
+    id,
+    op: "tests_add",
+    author: resolveAuthor(options.author, settings.author_default),
+    message: options.message,
+    force: options.force,
+    skipNoop: true,
+    mutate(document) {
+      const previous = document.metadata.tests ?? [];
+      const next = [...previous];
+      for (const add of adds) {
+        const exists = next.some((entry) => entry.command === add.command && entry.path === add.path && entry.scope === add.scope && entry.pm_context_mode === add.pm_context_mode);
+        if (!exists) {
+          next.push(add);
+        }
+      }
+      if (removes.length > 0) {
+        for (let i = next.length - 1; i >= 0; i -= 1) {
+          const entry = next[i];
+          if (removes.includes(entry.path ?? "") || removes.includes(entry.command ?? "")) {
+            next.splice(i, 1);
+          }
+        }
+      }
+      document.metadata.tests = next;
+      return { changedFields: stableValueEquals(previous, next) ? [] : ["tests"] };
+    }
+  });
+  return {
+    itemId: result.item.id,
+    tests: result.item.tests ?? [],
+    changed: result.changedFields.length > 0
+  };
+}
+function resolveTestRunOptions(options, tests) {
+  assertTestRunFlagUsage(options);
+  const selectorInput = {
+    match: options.match,
+    onlyIndex: options.onlyIndex === void 0 ? void 0 : parseOnlyIndexValue(options.onlyIndex),
+    onlyLast: options.onlyLast
+  };
+  const runSelection = options.run === true ? resolveLinkedTestRunSelection(tests, selectorInput) : void 0;
+  return {
+    defaultTimeoutSeconds: options.timeout === void 0 ? void 0 : parseOptionalNumber(options.timeout, "timeout"),
+    pmContextMode: parsePmContextMode(options.pmContext),
+    runSelection,
+    testsToRun: runSelection?.selected ?? tests
+  };
+}
+async function executeSelectedLinkedTests(params) {
+  const { options, runOptions, pmRoot } = params;
+  if (options.run !== true) {
+    return [];
+  }
+  return await runLinkedTests(runOptions.testsToRun, runOptions.defaultTimeoutSeconds, {
+    progress: options.progress,
+    envSet: options.envSet,
+    envClear: options.envClear,
+    sharedHostSafe: options.sharedHostSafe,
+    pmContext: runOptions.pmContextMode,
+    overrideLinkedPmContext: options.overrideLinkedPmContext,
+    failOnContextMismatch: options.failOnContextMismatch,
+    failOnEmptyTestRun: options.failOnEmptyTestRun,
+    requireAssertionsForPm: options.requireAssertionsForPm,
+    checkContext: options.checkContext,
+    autoPmContext: options.autoPmContext,
+    sourceRoots: {
+      projectPmRoot: pmRoot,
+      globalPmRoot: resolveGlobalPmRoot(process.cwd())
+    }
+  });
+}
+function buildTestWarnings(options, runSelection, runResults) {
+  const warnings = [];
+  if (runSelection && runSelection.selector !== null) {
+    warnings.push(`linked_test_selection:${runSelection.selector}=${runSelection.requested};selected=${runSelection.selected_count};skipped=${runSelection.skipped_count};indexes=${runSelection.selected_indexes.join(",")}`);
+  }
+  if (options.run === true && options.checkContext === true) {
+    const preflight = summarizeContextPreflight(runResults);
+    warnings.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}`);
+  }
+  return warnings;
+}
+async function recordTestRunSummary(params) {
+  const { options, pmRoot, settings, itemId, runStartedAt, runResults, failOnSkippedTriggered, warnings } = params;
+  if (options.run !== true || !runStartedAt || settings.testing.record_results_to_items !== true) {
+    return;
+  }
+  const summary = summarizeRunResultStatuses(runResults);
+  const trackedRunId = resolveTrackedRunId("test");
+  const attemptRaw = process.env.PM_BACKGROUND_TEST_RUN_ATTEMPT?.trim();
+  const parsedAttempt = attemptRaw ? Number.parseInt(attemptRaw, 10) : Number.NaN;
+  const resumedFrom = process.env.PM_BACKGROUND_TEST_RUN_RESUMED_FROM?.trim();
+  try {
+    await appendTrackedTestRunSummary({
+      pmRoot,
+      settings,
+      itemId,
+      author: resolveAuthor(options.author, settings.author_default),
+      message: `Track test run summary (${trackedRunId})`,
+      entry: {
+        run_id: trackedRunId,
+        kind: "test",
+        status: summary.failed > 0 || failOnSkippedTriggered === true ? "failed" : "passed",
+        started_at: runStartedAt,
+        finished_at: nowIso(),
+        recorded_at: nowIso(),
+        attempt: Number.isFinite(parsedAttempt) && parsedAttempt >= 1 ? parsedAttempt : void 0,
+        resumed_from: resumedFrom && resumedFrom.length > 0 ? resumedFrom : void 0,
+        passed: summary.passed,
+        failed: summary.failed,
+        skipped: summary.skipped,
+        fail_on_skipped_triggered: failOnSkippedTriggered ? true : void 0
+      }
+    });
+  } catch (error) {
+    warnings.push(`test_result_tracking_failed:${itemId}:${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function runTest(id, options, global2) {
+  const stdinResolver = createStdinTokenResolver();
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const resolvedAdds = await stdinResolver.resolveList(options.add, "--add");
+  const resolvedAddJsons = await stdinResolver.resolveList(options.addJson, "--add-json");
+  const resolvedRemoves = await stdinResolver.resolveList(options.remove, "--remove");
+  const adds = [...parseAddEntries(resolvedAdds), ...parseAddJsonEntries(resolvedAddJsons)];
+  const removes = parseRemoveEntries(resolvedRemoves);
+  const item = await resolveLinkedTestItem({
+    id,
+    options,
+    pmRoot,
+    settings,
+    typeToFolder: typeRegistry.type_to_folder,
+    adds,
+    removes
+  });
+  const runOptions = resolveTestRunOptions(options, item.tests);
+  const runStartedAt = options.run === true ? nowIso() : void 0;
+  const runResults = await executeSelectedLinkedTests({ options, runOptions, pmRoot });
+  const failureCategories = countFailureCategories(runResults);
+  const failOnSkippedTriggered = options.run === true && options.failOnSkipped === true && runResults.some((entry) => entry.status === "skipped");
+  const warnings = buildTestWarnings(options, runOptions.runSelection, runResults);
+  await recordTestRunSummary({ options, pmRoot, settings, itemId: item.itemId, runStartedAt, runResults, failOnSkippedTriggered, warnings });
+  return {
+    ok: runResults.every((entry) => entry.status !== "failed") && failOnSkippedTriggered !== true,
+    id: item.itemId,
+    tests: item.tests,
+    run_results: runResults,
+    failure_categories: failureCategories,
+    selection: runOptions.runSelection ? {
+      selector: runOptions.runSelection.selector,
+      requested: runOptions.runSelection.requested,
+      selected_indexes: runOptions.runSelection.selected_indexes,
+      selected_count: runOptions.runSelection.selected_count,
+      skipped_count: runOptions.runSelection.skipped_count
+    } : void 0,
+    fail_on_skipped_triggered: failOnSkippedTriggered ? true : void 0,
+    warnings: warnings.length > 0 ? warnings : void 0,
+    changed: item.changed,
+    count: item.tests.length
+  };
+}
+var _testOnlyTestCommand = {
+  buildPmContextMismatchHint,
+  commandInvokesPmCli,
+  commandInvokesPmTrackerReadCommand,
+  copyIntoSandboxIfPresent,
+  countLinkedTestItemFiles,
+  ensureScope,
+  evaluateLinkedTestAssertions,
+  extractPmInvocationArgsFromSegment,
+  firstDirectTestRunnerSubcommand,
+  hasLinkedTestAssertions,
+  parseAddJsonEntries,
+  parsePmContextMode,
+  readJsonPathValue,
+  resolveAuthor,
+  resolveDirectRunnerSubcommand,
+  resolveLinkedTestEffectiveContextMode,
+  resolveLinkedTestFailureExitCode,
+  resolveLinkedTestRequestedContextMode,
+  resolveTrackedRunId,
+  runLinkedTestCommand,
+  seedLinkedTestSandbox,
+  seedLinkedTestTrackerData,
+  splitJsonPathSegments,
+  summarizeRunResultStatuses
+};
+
+export {
+  appendTrackedTestRunSummary,
+  summarizeContextPreflight,
+  extractReferencedPmItemIdsFromCommand,
+  classifyLinkedTestFailure,
+  countFailureCategories,
+  resolveLinkedTestFailureExitCode,
+  runLinkedTests,
+  runTest,
+  _testOnlyTestCommand
+};
+//# sourceMappingURL=chunk-C5JBZRPU.js.map