@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-3PL6LEKP.js

@@ -1,1961 +0,0 @@
-
-!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]="58f10529-0722-5f3d-bc54-ca618699dc49")}catch(e){}}();
-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-MZ7VNEVY.js";
-import {
-  createStdinTokenResolver,
-  parseCsvKv,
-  parseOptionalNumber
-} from "./chunk-7WYXBPYQ.js";
-import {
-  runInit
-} from "./chunk-5JZ7APJU.js";
-import {
-  locateItem,
-  mutateItem,
-  readLocatedItem
-} from "./chunk-57C2RLW5.js";
-import {
-  compareTimestampStrings,
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  stableValueEquals
-} from "./chunk-US3T3W5J.js";
-import {
-  EXIT_CODE,
-  ITEM_FILE_EXTENSIONS,
-  SCOPE_VALUES,
-  getSettingsPath,
-  pathExists,
-  resolveGlobalPmRoot,
-  resolveItemTypeRegistry,
-  resolvePmRoot
-} from "./chunk-YD5FML7K.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
-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/cli/commands/test/linked-command-detection.js
-var PM_GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--path"]);
-var NPX_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-p", "--package", "-c", "--call"]);
-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
-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, global) {
-  const stdinResolver = createStdinTokenResolver();
-  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 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-3PL6LEKP.js.map
-
-//# debugId=58f10529-0722-5f3d-bc54-ca618699dc49