@unbrained/pm-cli 2026.5.31 → 2026.6.5

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

@@ -0,0 +1,1664 @@
+
+!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]="fb2ef78d-78c8-5583-8c98-89541410a9ff")}catch(e){}}();
+import {
+  LINKED_TEST_PM_CONTEXT_MODE_VALUES,
+  LINKED_TEST_PROTECTED_ENV_KEYS,
+  looksLikeStructuredLinkedTestEntry,
+  normalizeStructuredLinkedTestEntry,
+  parseLinkedTestAssertionEqualsMap,
+  parseLinkedTestAssertionGteMap,
+  parseLinkedTestBoolean,
+  parseLinkedTestContextMode,
+  parseLinkedTestEnvClear,
+  parseLinkedTestEnvSet,
+  parseLinkedTestMinLines,
+  parseLinkedTestRegexList,
+  parseLinkedTestStringList
+} from "./chunk-KCMIYKTA.js";
+import {
+  createStdinTokenResolver,
+  parseCsvKv,
+  parseOptionalNumber
+} from "./chunk-O5IBJE6S.js";
+import {
+  runInit
+} from "./chunk-ORTLYVA4.js";
+import {
+  locateItem,
+  mutateItem,
+  readLocatedItem
+} from "./chunk-CWT53EYT.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-SZQCER6S.js";
+import {
+  compareTimestampStrings,
+  nowIso
+} from "./chunk-NQP3ECKF.js";
+import {
+  EXIT_CODE,
+  ITEM_FILE_EXTENSIONS,
+  PmCliError,
+  SCOPE_VALUES,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  pathExists,
+  readSettings,
+  resolveGlobalPmRoot,
+  resolvePmRoot,
+  stableValueEquals
+} from "./chunk-4LTBNUYT.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/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 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 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);
+  }
+  if (executable === "npx") {
+    const parsed = parseNpxCommand(args);
+    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
+      return parsed.args;
+    }
+  }
+  if (executable === "pnpm") {
+    const parsed = parsePnpmDlxCommand(args);
+    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
+      return parsed.args;
+    }
+  }
+  if (executable === "npm") {
+    const parsed = parseNpmExecCommand(args);
+    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
+      return parsed.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") {
+    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") {
+    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 commandInvokesDirectTestRunner(normalizedCommand) {
+  const rawTokens = normalizedCommand.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 args[0] === "--test" || Boolean(args[0]?.endsWith("/vitest") || args[0]?.endsWith("/vitest.mjs"));
+  }
+  const subcommand = firstDirectTestRunnerSubcommand(executable, args);
+  return isDirectTestRunnerSubcommand(subcommand);
+}
+function assertSandboxSafeTestRunnerCommand(command) {
+  const normalized = normalizeCommandForValidation(command);
+  const segments = splitNormalizedCommandSegments(normalized);
+  const hasUnsafeDirectRunnerSegment = segments.some((segment) => !commandUsesSandboxRunner(segment) && commandInvokesDirectTestRunner(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>" 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((entry) => {
+    const trimmed = entry.trim();
+    const kv = looksLikeStructuredLinkedTestEntry(trimmed) ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add") : { command: trimmed };
+    const command = kv.command?.trim() || void 0;
+    const filePath = kv.path?.trim() || void 0;
+    if (!command) {
+      throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+    }
+    if (command) {
+      assertNoRecursiveTestAllCommand(command);
+      assertSandboxSafeTestRunnerCommand(command);
+    }
+    const timeoutSecondsRaw = kv.timeout_seconds?.trim();
+    const timeoutAliasRaw = kv.timeout?.trim();
+    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;
+    const timeoutSeconds = timeoutRaw === void 0 ? void 0 : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
+    const envSet = parseLinkedTestEnvSet(kv.env_set?.trim(), "--add");
+    const envClear = parseLinkedTestEnvClear(kv.env_clear?.trim(), "--add");
+    const pmContextMode = parseLinkedTestContextMode(kv.pm_context_mode?.trim(), "--add");
+    const sharedHostSafe = parseLinkedTestBoolean(kv.shared_host_safe?.trim(), "--add", "shared_host_safe");
+    return {
+      command,
+      path: filePath,
+      scope: ensureScope(kv.scope),
+      timeout_seconds: timeoutSeconds,
+      pm_context_mode: pmContextMode,
+      env_set: envSet,
+      env_clear: envClear,
+      shared_host_safe: sharedHostSafe,
+      assert_stdout_contains: parseLinkedTestStringList(kv.assert_stdout_contains?.trim()),
+      assert_stdout_regex: parseLinkedTestRegexList(kv.assert_stdout_regex?.trim(), "--add", "assert_stdout_regex"),
+      assert_stderr_contains: parseLinkedTestStringList(kv.assert_stderr_contains?.trim()),
+      assert_stderr_regex: parseLinkedTestRegexList(kv.assert_stderr_regex?.trim(), "--add", "assert_stderr_regex"),
+      assert_stdout_min_lines: parseLinkedTestMinLines(kv.assert_stdout_min_lines?.trim(), "--add"),
+      assert_json_field_equals: parseLinkedTestAssertionEqualsMap(kv.assert_json_field_equals?.trim(), "--add"),
+      assert_json_field_gte: parseLinkedTestAssertionGteMap(kv.assert_json_field_gte?.trim(), "--add"),
+      note: kv.note?.trim() || void 0
+    };
+  });
+}
+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) => {
+    child.on("close", (closeCode, closeSignal) => {
+      resolve({
+        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 = [];
+  for (const expected of linkedTest.assert_stdout_contains ?? []) {
+    if (!stdout.includes(expected)) {
+      failures.push(`stdout missing required text: "${expected}"`);
+    }
+  }
+  for (const pattern of linkedTest.assert_stdout_regex ?? []) {
+    try {
+      const regex = new RegExp(pattern, "m");
+      if (!regex.test(stdout)) {
+        failures.push(`stdout failed regex assertion: /${pattern}/m`);
+      }
+    } catch (error) {
+      failures.push(`stdout regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+  for (const expected of linkedTest.assert_stderr_contains ?? []) {
+    if (!stderr.includes(expected)) {
+      failures.push(`stderr missing required text: "${expected}"`);
+    }
+  }
+  for (const pattern of linkedTest.assert_stderr_regex ?? []) {
+    try {
+      const regex = new RegExp(pattern, "m");
+      if (!regex.test(stderr)) {
+        failures.push(`stderr failed regex assertion: /${pattern}/m`);
+      }
+    } catch (error) {
+      failures.push(`stderr regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+  if (typeof linkedTest.assert_stdout_min_lines === "number") {
+    const lineCount = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).length;
+    if (lineCount < linkedTest.assert_stdout_min_lines) {
+      failures.push(`stdout line count ${lineCount} is below required minimum ${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;
+}
+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;
+}
+async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
+  const results = [];
+  const sandboxRoot = await mkdtemp(path.join(tmpdir(), "pm-linked-test-"));
+  const schemaSandboxPmPath = path.join(sandboxRoot, "schema", "project", ".agents", "pm");
+  const schemaSandboxGlobalPath = path.join(sandboxRoot, "schema", "global");
+  const trackerSandboxPmPath = path.join(sandboxRoot, "tracker", "project", ".agents", "pm");
+  const trackerSandboxGlobalPath = path.join(sandboxRoot, "tracker", "global");
+  const runLevelPmContextMode = parsePmContextMode(options?.pmContext);
+  const progressMode = options?.progress === true ? "always" : "auto";
+  const runtimeDirectives = resolveRuntimeDirectives(options?.envSet, options?.envClear, options?.sharedHostSafe);
+  let sourceProjectItemCount = 0;
+  let sourceGlobalItemCount = 0;
+  let schemaSandboxProjectItemCount = 0;
+  let schemaSandboxGlobalItemCount = 0;
+  let trackerSandboxProjectItemCount = 0;
+  let trackerSandboxGlobalItemCount = 0;
+  const sourceRoots = options?.sourceRoots;
+  const projectExtensionsSeeded = Boolean(sourceRoots);
+  const globalExtensionsSeeded = Boolean(sourceRoots);
+  try {
+    await runInit(void 0, { path: schemaSandboxPmPath });
+    await runInit(void 0, { path: schemaSandboxGlobalPath });
+    await runInit(void 0, { path: trackerSandboxPmPath });
+    await runInit(void 0, { path: trackerSandboxGlobalPath });
+    if (sourceRoots) {
+      await seedLinkedTestSandbox(schemaSandboxPmPath, schemaSandboxGlobalPath, sourceRoots);
+      await seedLinkedTestSandbox(trackerSandboxPmPath, trackerSandboxGlobalPath, sourceRoots);
+      await seedLinkedTestTrackerData(sourceRoots.projectPmRoot, trackerSandboxPmPath);
+      await seedLinkedTestTrackerData(sourceRoots.globalPmRoot, trackerSandboxGlobalPath);
+      sourceProjectItemCount = await countLinkedTestItemFiles(sourceRoots.projectPmRoot);
+      sourceGlobalItemCount = await countLinkedTestItemFiles(sourceRoots.globalPmRoot);
+    }
+    schemaSandboxProjectItemCount = await countLinkedTestItemFiles(schemaSandboxPmPath);
+    schemaSandboxGlobalItemCount = await countLinkedTestItemFiles(schemaSandboxGlobalPath);
+    trackerSandboxProjectItemCount = await countLinkedTestItemFiles(trackerSandboxPmPath);
+    trackerSandboxGlobalItemCount = await countLinkedTestItemFiles(trackerSandboxGlobalPath);
+    const buildExecutionContext = (isPmCommand, isPmTrackerReadCommand, requestedPmContextMode, effectivePmContextMode, autoPmContextApplied) => {
+      const selectedSandboxProjectPmPath = effectivePmContextMode === "tracker" ? trackerSandboxPmPath : schemaSandboxPmPath;
+      const selectedSandboxGlobalPmPath = effectivePmContextMode === "tracker" ? trackerSandboxGlobalPath : schemaSandboxGlobalPath;
+      const selectedSandboxProjectItemCount = effectivePmContextMode === "tracker" ? trackerSandboxProjectItemCount : schemaSandboxProjectItemCount;
+      const selectedSandboxGlobalItemCount = effectivePmContextMode === "tracker" ? trackerSandboxGlobalItemCount : schemaSandboxGlobalItemCount;
+      const mismatchDetected = isPmCommand && sourceProjectItemCount !== selectedSandboxProjectItemCount;
+      return {
+        requested_pm_context_mode: requestedPmContextMode,
+        pm_context_mode: effectivePmContextMode,
+        auto_pm_context_applied: autoPmContextApplied,
+        is_pm_command: isPmCommand,
+        is_pm_tracker_read_command: isPmTrackerReadCommand,
+        source_project_pm_path: sourceRoots?.projectPmRoot ?? "",
+        sandbox_project_pm_path: selectedSandboxProjectPmPath,
+        source_global_pm_path: sourceRoots?.globalPmRoot ?? "",
+        sandbox_global_pm_path: selectedSandboxGlobalPmPath,
+        source_project_item_count: sourceProjectItemCount,
+        sandbox_project_item_count: selectedSandboxProjectItemCount,
+        source_global_item_count: sourceGlobalItemCount,
+        sandbox_global_item_count: selectedSandboxGlobalItemCount,
+        mismatch_detected: mismatchDetected,
+        project_extensions_seeded: projectExtensionsSeeded,
+        global_extensions_seeded: globalExtensionsSeeded
+      };
+    };
+    for (let index = 0; index < tests.length; index += 1) {
+      const linkedTest = tests[index];
+      const linkedOverridePmContextMode = typeof linkedTest.pm_context_mode === "string" && linkedTest.pm_context_mode.trim().length > 0 ? parsePmContextMode(linkedTest.pm_context_mode) : void 0;
+      const isPmCommand = typeof linkedTest.command === "string" && linkedTest.command.length > 0 ? commandInvokesPmCli(linkedTest.command) : false;
+      const isPmTrackerReadCommand = isPmCommand && typeof linkedTest.command === "string" && linkedTest.command.length > 0 ? commandInvokesPmTrackerReadCommand(linkedTest.command) : false;
+      const autoPmContextApplied = options?.autoPmContext === true && isPmTrackerReadCommand;
+      const requestedPmContextMode = autoPmContextApplied ? "auto" : resolveLinkedTestRequestedContextMode(linkedTest, runLevelPmContextMode, options?.overrideLinkedPmContext === true);
+      const effectivePmContextMode = resolveLinkedTestEffectiveContextMode(requestedPmContextMode, isPmTrackerReadCommand);
+      const executionContext = buildExecutionContext(isPmCommand, isPmTrackerReadCommand, requestedPmContextMode, effectivePmContextMode, autoPmContextApplied);
+      if (!linkedTest.command) {
+        results.push({
+          command: linkedTest.command,
+          path: linkedTest.path,
+          status: "skipped",
+          execution_context: executionContext,
+          error: "No command configured for this linked test."
+        });
+        continue;
+      }
+      const runtimeSafetySkipReason = getRuntimeSafetySkipReason(linkedTest.command);
+      if (runtimeSafetySkipReason) {
+        results.push({
+          command: linkedTest.command,
+          path: linkedTest.path,
+          status: "skipped",
+          execution_context: executionContext,
+          error: runtimeSafetySkipReason
+        });
+        continue;
+      }
+      const failOnMismatchByDefault = executionContext.pm_context_mode === "schema" && executionContext.is_pm_tracker_read_command && executionContext.mismatch_detected;
+      const failOnMismatchByFlag = options?.failOnContextMismatch === true && executionContext.is_pm_command && executionContext.mismatch_detected;
+      if (failOnMismatchByDefault || failOnMismatchByFlag) {
+        const mismatchHint = buildPmContextMismatchHint({
+          executionContext,
+          runLevelPmContextMode,
+          linkedOverridePmContextMode
+        });
+        const mismatchPrefix = options?.checkContext === true ? "Linked test preflight PM context mismatch detected" : "Linked test PM context mismatch detected";
+        results.push({
+          command: linkedTest.command,
+          path: linkedTest.path,
+          status: "failed",
+          exit_code: 1,
+          failure_category: "assertion_failure",
+          execution_context: executionContext,
+          error: `${mismatchPrefix} (source_project_items=${executionContext.source_project_item_count}, sandbox_project_items=${executionContext.sandbox_project_item_count}).${mismatchHint}`
+        });
+        continue;
+      }
+      if (options?.requireAssertionsForPm === true && executionContext.is_pm_command && !hasLinkedTestAssertions(linkedTest)) {
+        results.push({
+          command: linkedTest.command,
+          path: linkedTest.path,
+          status: "failed",
+          exit_code: 1,
+          failure_category: "assertion_failure",
+          execution_context: executionContext,
+          error: "Linked PM command requires assertions when --require-assertions-for-pm is enabled."
+        });
+        continue;
+      }
+      const timeoutMs = (linkedTest.timeout_seconds ?? defaultTimeoutSeconds ?? 120) * 1e3;
+      const effectiveDirectives = resolveEffectiveLinkedTestDirectives(runtimeDirectives, linkedTest);
+      const executionEnv = { ...process.env };
+      applyEnvDirectiveStage(executionEnv, runtimeDirectives);
+      applyEnvDirectiveStage(executionEnv, {
+        env_set: linkedTest.env_set ?? {},
+        env_clear: linkedTest.env_clear ?? []
+      });
+      if (effectiveDirectives.shared_host_safe) {
+        applySharedHostSafeDefaults(executionEnv);
+      }
+      executionEnv.FORCE_COLOR = "0";
+      executionEnv.PM_PATH = executionContext.sandbox_project_pm_path;
+      executionEnv.PM_GLOBAL_PATH = executionContext.sandbox_global_pm_path;
+      const execution = await runLinkedTestCommand(linkedTest.command, timeoutMs, executionEnv, {
+        index: index + 1,
+        total: tests.length,
+        timeoutMs,
+        command: linkedTest.command
+      }, progressMode);
+      const passed = execution.exitCode === 0 && !execution.timedOut && !execution.maxBufferExceeded;
+      if (passed) {
+        if (options?.failOnEmptyTestRun === true) {
+          const emptyRunSignal = detectEmptyLinkedTestRun(execution.stdout, execution.stderr);
+          if (emptyRunSignal) {
+            results.push({
+              command: linkedTest.command,
+              path: linkedTest.path,
+              status: "failed",
+              exit_code: 1,
+              failure_category: "empty_run",
+              execution_context: executionContext,
+              stdout: execution.stdout,
+              stderr: execution.stderr,
+              error: `Linked test reported an empty test run (${emptyRunSignal}) while --fail-on-empty-test-run is enabled. Update test selection or disable --fail-on-empty-test-run for this run.`
+            });
+            continue;
+          }
+        }
+        const assertionFailures = evaluateLinkedTestAssertions(linkedTest, execution.stdout, execution.stderr);
+        if (assertionFailures.length > 0) {
+          results.push({
+            command: linkedTest.command,
+            path: linkedTest.path,
+            status: "failed",
+            exit_code: 1,
+            failure_category: "assertion_failure",
+            execution_context: executionContext,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            error: `Linked test assertion(s) failed: ${assertionFailures.join("; ")}`
+          });
+          continue;
+        }
+        results.push({
+          command: linkedTest.command,
+          path: linkedTest.path,
+          status: "passed",
+          exit_code: 0,
+          execution_context: executionContext,
+          stdout: execution.stdout,
+          stderr: execution.stderr
+        });
+        continue;
+      }
+      const failureCategory = classifyLinkedTestFailure(execution);
+      results.push({
+        command: linkedTest.command,
+        path: linkedTest.path,
+        status: "failed",
+        exit_code: resolveLinkedTestFailureExitCode(execution),
+        failure_category: failureCategory,
+        execution_context: executionContext,
+        stdout: execution.stdout,
+        stderr: execution.stderr,
+        error: formatLinkedTestExecutionError(execution, timeoutMs)
+      });
+    }
+  } finally {
+    await rm(sandboxRoot, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+  return results;
+}
+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 resolvedRemoves = await stdinResolver.resolveList(options.remove, "--remove");
+  const adds = parseAddEntries(resolvedAdds);
+  const removes = parseRemoveEntries(resolvedRemoves);
+  const shouldMutate = adds.length > 0 || removes.length > 0;
+  let tests = [];
+  let itemId;
+  if (shouldMutate) {
+    const author = resolveAuthor(options.author, settings.author_default);
+    const result = await mutateItem({
+      pmRoot,
+      settings,
+      id,
+      op: "tests_add",
+      author,
+      message: options.message,
+      force: options.force,
+      mutate(document) {
+        const next = [...document.metadata.tests ?? []];
+        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: ["tests"] };
+      }
+    });
+    tests = result.item.tests ?? [];
+    itemId = result.item.id;
+  } else {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    if (!located) {
+      throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+    }
+    itemId = located.id;
+    const loaded = await readLocatedItem(located, { schema: settings.schema });
+    tests = loaded.document.metadata.tests ?? [];
+  }
+  let defaultTimeoutSeconds;
+  if (options.timeout !== void 0) {
+    defaultTimeoutSeconds = parseOptionalNumber(options.timeout, "timeout");
+  }
+  const pmContextMode = parsePmContextMode(options.pmContext);
+  const hasRuntimeDirectiveFlags = (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;
+  if (hasRuntimeDirectiveFlags && 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 runStartedAt = options.run === true ? nowIso() : void 0;
+  const runResults = options.run === true ? await runLinkedTests(tests, defaultTimeoutSeconds, {
+    progress: options.progress,
+    envSet: options.envSet,
+    envClear: options.envClear,
+    sharedHostSafe: options.sharedHostSafe,
+    pmContext: 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())
+    }
+  }) : [];
+  const failureCategories = countFailureCategories(runResults);
+  const failOnSkippedTriggered = options.run === true && options.failOnSkipped === true && runResults.some((entry) => entry.status === "skipped");
+  const warnings = [];
+  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}`);
+  }
+  if (options.run === true && runStartedAt && settings.testing.record_results_to_items === true) {
+    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)}`);
+    }
+  }
+  return {
+    ok: runResults.every((entry) => entry.status !== "failed") && failOnSkippedTriggered !== true,
+    id: itemId,
+    tests,
+    run_results: runResults,
+    failure_categories: failureCategories,
+    fail_on_skipped_triggered: failOnSkippedTriggered ? true : void 0,
+    warnings: warnings.length > 0 ? warnings : void 0,
+    changed: shouldMutate,
+    count: tests.length
+  };
+}
+
+export {
+  appendTrackedTestRunSummary,
+  summarizeContextPreflight,
+  extractReferencedPmItemIdsFromCommand,
+  classifyLinkedTestFailure,
+  countFailureCategories,
+  resolveLinkedTestFailureExitCode,
+  runLinkedTests,
+  runTest
+};
+//# sourceMappingURL=chunk-UOVLWB47.js.map
+
+//# debugId=fb2ef78d-78c8-5583-8c98-89541410a9ff