@unbrained/pm-cli 2026.7.1 → 2026.7.2

package/dist/cli-bundle/chunks/{chunk-3XZCOZ5J.js → chunk-Q6NXOHS6.js}

@@ -1,5 +1,5 @@
 
-!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]="a2588018-8995-5c3e-b957-a7afc236729b")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4f00aa88-9fd7-5416-a1a3-4df09dba7e93")}catch(e){}}();
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -15,24 +15,24 @@ import {
   parseLinkedTestMinLines,
   parseLinkedTestRegexList,
   parseLinkedTestStringList
-} from "./chunk-EJUDVUYZ.js";
+} from "./chunk-KCO2EAN5.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-ZRP4VG5U.js";
+} from "./chunk-KLXF7NCC.js";
 import {
   runInit
-} from "./chunk-V3NOKJF2.js";
+} from "./chunk-6YCYF2AI.js";
 import {
   locateItem,
   mutateItem,
   readLocatedItem
-} from "./chunk-JSU5P7VS.js";
+} from "./chunk-NRZS637N.js";
 import {
   compareTimestampStrings,
   nowIso
-} from "./chunk-AXIDKKAT.js";
+} from "./chunk-K2VYLVX4.js";
 import {
   EXIT_CODE,
   ITEM_FILE_EXTENSIONS,
@@ -46,7 +46,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   stableValueEquals
-} from "./chunk-7R4QEMZZ.js";
+} from "./chunk-I66WE2HE.js";
 
 // dist/cli/commands/test.js
 import { spawn } from "node:child_process";
@@ -1472,300 +1472,343 @@ ${stderr}`;
   }
   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 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 layout = createLinkedTestSandboxLayout(sandboxRoot);
   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
-      };
-    };
+    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 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 ?? []
+      const commandContext = resolveLinkedTestCommandContext({
+        linkedTest,
+        layout,
+        counts,
+        sourceRoots,
+        runLevelPmContextMode,
+        options
       });
-      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
-        });
+      const preflightResult = resolveLinkedTestPreflightResult({
+        linkedTest,
+        executionContext: commandContext.executionContext,
+        runLevelPmContextMode,
+        linkedOverridePmContextMode: commandContext.linkedOverridePmContextMode,
+        options
+      });
+      if (preflightResult) {
+        results.push(preflightResult);
         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)
-      });
+      results.push(await runSingleLinkedTest({
+        linkedTest,
+        index,
+        total: tests.length,
+        defaultTimeoutSeconds,
+        runtimeDirectives,
+        progressMode,
+        executionContext: commandContext.executionContext,
+        options
+      }));
     }
   } finally {
-    await rm(sandboxRoot, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    await rm(layout.root, { 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 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 shouldMutate = adds.length > 0 || removes.length > 0;
-  let tests = [];
-  let itemId;
-  let changed = false;
-  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,
-      skipNoop: true,
-      mutate(document) {
-        const previous = document.metadata.tests ?? [];
-        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: stableValueEquals(previous, next) ? [] : ["tests"] };
-      }
-    });
-    tests = result.item.tests ?? [];
-    itemId = result.item.id;
-    changed = result.changedFields.length > 0;
-  } 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) {
+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;
-  const testsToRun = runSelection?.selected ?? tests;
-  const runStartedAt = options.run === true ? nowIso() : void 0;
-  const runResults = options.run === true ? await runLinkedTests(testsToRun, defaultTimeoutSeconds, {
+  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: pmContextMode,
+    pmContext: runOptions.pmContextMode,
     overrideLinkedPmContext: options.overrideLinkedPmContext,
     failOnContextMismatch: options.failOnContextMismatch,
     failOnEmptyTestRun: options.failOnEmptyTestRun,
@@ -1776,9 +1819,9 @@ async function runTest(id, options, global) {
       projectPmRoot: pmRoot,
       globalPmRoot: resolveGlobalPmRoot(process.cwd())
     }
-  }) : [];
-  const failureCategories = countFailureCategories(runResults);
-  const failOnSkippedTriggered = options.run === true && options.failOnSkipped === true && runResults.some((entry) => entry.status === "skipped");
+  });
+}
+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(",")}`);
@@ -1787,55 +1830,90 @@ async function runTest(id, options, global) {
     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 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: itemId,
-    tests,
+    id: item.itemId,
+    tests: item.tests,
     run_results: runResults,
     failure_categories: failureCategories,
-    selection: runSelection ? {
-      selector: runSelection.selector,
-      requested: runSelection.requested,
-      selected_indexes: runSelection.selected_indexes,
-      selected_count: runSelection.selected_count,
-      skipped_count: runSelection.skipped_count
+    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,
-    count: tests.length
+    changed: item.changed,
+    count: item.tests.length
   };
 }
 var _testOnlyTestCommand = {
@@ -1876,6 +1954,6 @@ export {
   runTest,
   _testOnlyTestCommand
 };
-//# sourceMappingURL=chunk-3XZCOZ5J.js.map
+//# sourceMappingURL=chunk-Q6NXOHS6.js.map
 
-//# debugId=a2588018-8995-5c3e-b957-a7afc236729b
+//# debugId=4f00aa88-9fd7-5416-a1a3-4df09dba7e93