@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,1031 +0,0 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="06f25e42-4a55-5490-b7f5-780bc79db731")}catch(e){}}();
-import {
-  parseLimit
-} from "./chunk-YFIE7YK6.js";
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  readSettings
-} from "./chunk-US3T3W5J.js";
-import {
-  EXIT_CODE,
-  ensureDir,
-  getSettingsPath,
-  getTestRunRecordPath,
-  getTestRunResultPath,
-  getTestRunStderrPath,
-  getTestRunStdoutPath,
-  getTestRunsPath,
-  getTestRunsRecordsPath,
-  getTestRunsResultsPath,
-  getTestRunsStderrPath,
-  getTestRunsStdoutPath,
-  pathExists,
-  readFileIfExists,
-  resolveGlobalPmRoot,
-  resolvePmRoot,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/cli/commands/test-runs.js
-import os from "node:os";
-
-// dist/core/test/background-runs.js
-import fs from "node:fs/promises";
-import { spawn } from "node:child_process";
-import { createHash, randomBytes } from "node:crypto";
-import path from "node:path";
-var BACKGROUND_RUN_ACTIVE_STATUSES = /* @__PURE__ */ new Set(["queued", "running"]);
-var BACKGROUND_RUN_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["passed", "failed", "stopped", "canceled"]);
-var DEFAULT_BACKGROUND_RUN_RESOURCE_SNAPSHOT_INTERVAL_MS = 3e3;
-var DEFAULT_BACKGROUND_RUN_FORCE_KILL_DELAY_MS = 3e3;
-var DEFAULT_BACKGROUND_RUN_HEARTBEAT_STALE_MS = 3e4;
-var DEFAULT_BACKGROUND_RUN_LOG_TAIL_LINES = 100;
-var PROC_STAT_TICKS_PER_SECOND = 100;
-function nowMs() {
-  return Date.now();
-}
-function normalizeCommandArgs(args) {
-  return args.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-}
-function summarizeCommandLabel(args) {
-  const joined = args.join(" ").replaceAll(/\s+/g, " ").trim();
-  if (joined.length <= 180) {
-    return joined;
-  }
-  return `${joined.slice(0, 177)}...`;
-}
-function buildRunId() {
-  const timePart = Date.now().toString(36);
-  const randomPart = randomBytes(3).toString("hex");
-  return `tr-${timePart}-${randomPart}`;
-}
-function buildBackgroundTestRunFingerprint(kind, commandArgs, pmRoot) {
-  const payload = {
-    kind,
-    command: normalizeCommandArgs(commandArgs),
-    pm_root: path.resolve(pmRoot)
-  };
-  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
-}
-function isPidRunning(pid) {
-  if (!Number.isInteger(pid) || !pid || pid <= 0) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-    return code === "EPERM";
-  }
-}
-async function ensureBackgroundRunStorage(pmRoot) {
-  await ensureDir(getTestRunsPath(pmRoot));
-  await ensureDir(getTestRunsRecordsPath(pmRoot));
-  await ensureDir(getTestRunsStdoutPath(pmRoot));
-  await ensureDir(getTestRunsStderrPath(pmRoot));
-  await ensureDir(getTestRunsResultsPath(pmRoot));
-}
-async function parseBackgroundRunRecord(raw, recordPath) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || typeof parsed.id !== "string") {
-      throw new Error("invalid run record payload");
-    }
-    return parsed;
-  } catch (error) {
-    throw new PmCliError(`Failed to parse background test run record at ${recordPath}: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-}
-async function writeBackgroundRunRecord(pmRoot, record) {
-  const next = {
-    ...record,
-    updated_at: nowIso()
-  };
-  await writeFileAtomic(getTestRunRecordPath(pmRoot, record.id), `${JSON.stringify(next, null, 2)}
-`);
-}
-async function readBackgroundTestRunRecord(pmRoot, runId) {
-  const recordPath = getTestRunRecordPath(pmRoot, runId);
-  const raw = await readFileIfExists(recordPath);
-  if (!raw) {
-    return null;
-  }
-  return parseBackgroundRunRecord(raw, recordPath);
-}
-async function listBackgroundRunRecordPaths(pmRoot) {
-  const recordsRoot = getTestRunsRecordsPath(pmRoot);
-  if (!await pathExists(recordsRoot)) {
-    return [];
-  }
-  const entries = await fs.readdir(recordsRoot, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
-}
-function parseLinuxRssStatus(raw) {
-  const match = raw.match(/^VmRSS:\s+(\d+)\s+kB$/m);
-  if (!match) {
-    return void 0;
-  }
-  return Number.parseInt(match[1], 10) * 1024;
-}
-async function readLinuxRssBytes(pid) {
-  if (process.platform !== "linux") {
-    return void 0;
-  }
-  try {
-    const raw = await fs.readFile(`/proc/${pid}/status`, "utf8");
-    return parseLinuxRssStatus(raw);
-  } catch {
-    return void 0;
-  }
-}
-function parseLinuxCpuStat(raw) {
-  const closeParenIndex = raw.lastIndexOf(")");
-  if (closeParenIndex < 0) {
-    return {};
-  }
-  const remainder = raw.slice(closeParenIndex + 2).trim();
-  const parts = remainder.split(/\s+/);
-  const utimeTicks = Number.parseInt(parts[11], 10);
-  const stimeTicks = Number.parseInt(parts[12], 10);
-  if (!Number.isFinite(utimeTicks) || !Number.isFinite(stimeTicks)) {
-    return {};
-  }
-  return {
-    cpu_user_seconds: utimeTicks / PROC_STAT_TICKS_PER_SECOND,
-    cpu_system_seconds: stimeTicks / PROC_STAT_TICKS_PER_SECOND
-  };
-}
-async function readLinuxCpuSeconds(pid) {
-  if (process.platform !== "linux") {
-    return {};
-  }
-  try {
-    const raw = await fs.readFile(`/proc/${pid}/stat`, "utf8");
-    return parseLinuxCpuStat(raw);
-  } catch {
-    return {};
-  }
-}
-async function buildResourceSnapshot(record) {
-  const pid = record.child_pid ?? record.worker_pid;
-  if (!isPidRunning(pid)) {
-    return void 0;
-  }
-  const rssBytes = await readLinuxRssBytes(pid);
-  const cpu = await readLinuxCpuSeconds(pid);
-  const startedAtMs = record.started_at ? Date.parse(record.started_at) : Number.NaN;
-  const uptimeSeconds = Number.isFinite(startedAtMs) ? Math.max(0, (nowMs() - startedAtMs) / 1e3) : void 0;
-  return {
-    recorded_at: nowIso(),
-    rss_bytes: rssBytes,
-    cpu_user_seconds: cpu.cpu_user_seconds,
-    cpu_system_seconds: cpu.cpu_system_seconds,
-    uptime_seconds: uptimeSeconds
-  };
-}
-function readCount(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function evaluateWorkerResult(kind, payload) {
-  if (!payload || typeof payload !== "object") {
-    return {
-      summary: {
-        passed: 0,
-        failed: 1,
-        skipped: 0
-      },
-      parsedResult: null
-    };
-  }
-  const record = payload;
-  if (kind === "test-all") {
-    const totals = record.totals ?? {};
-    return {
-      summary: {
-        items: typeof totals.items === "number" ? totals.items : void 0,
-        linked_tests: typeof totals.linked_tests === "number" ? totals.linked_tests : void 0,
-        passed: readCount(totals.passed),
-        failed: readCount(totals.failed),
-        skipped: readCount(totals.skipped),
-        fail_on_skipped_triggered: record.fail_on_skipped_triggered === true ? true : void 0
-      },
-      parsedResult: payload
-    };
-  }
-  const runResults = Array.isArray(record.run_results) ? record.run_results : [];
-  let passed = 0;
-  let failed = 0;
-  let skipped = 0;
-  for (const entry of runResults) {
-    if (!entry || typeof entry !== "object") {
-      continue;
-    }
-    const status = entry.status;
-    if (status === "passed") {
-      passed += 1;
-      continue;
-    }
-    if (status === "failed") {
-      failed += 1;
-      continue;
-    }
-    skipped += 1;
-  }
-  return {
-    summary: {
-      passed,
-      failed,
-      skipped,
-      fail_on_skipped_triggered: record.fail_on_skipped_triggered === true ? true : void 0
-    },
-    parsedResult: payload
-  };
-}
-function parseProgressLine(stderrLine) {
-  const line = stderrLine.trim();
-  if (line.length === 0) {
-    return null;
-  }
-  const testAllMatch = line.match(/\[pm test-all\]\s+item\s+(\d+)\/(\d+)\s+(start|end)\s+id=([^\s]+)/i);
-  if (testAllMatch) {
-    const itemIndex = Number.parseInt(testAllMatch[1], 10);
-    const itemTotal = Number.parseInt(testAllMatch[2], 10);
-    return {
-      item_index: itemIndex,
-      item_total: itemTotal,
-      item_id: testAllMatch[4],
-      linked_test_index: void 0,
-      linked_test_total: void 0,
-      current_command: void 0,
-      elapsed_ms: void 0,
-      heartbeat_at: nowIso(),
-      phase: testAllMatch[3]?.toLowerCase() === "end" ? "finished" : "running"
-    };
-  }
-  const linkedTestMatch = line.match(/\[pm test\]\s+linked-test\s+(\d+)\/(\d+)\s+(start|running|end)(?:.*elapsed_ms=(\d+))?/i);
-  if (!linkedTestMatch) {
-    return null;
-  }
-  const index = Number.parseInt(linkedTestMatch[1], 10);
-  const total = Number.parseInt(linkedTestMatch[2], 10);
-  const elapsed = linkedTestMatch[4] ? Number.parseInt(linkedTestMatch[4], 10) : void 0;
-  const commandMatch = line.match(/\scommand="((?:\\.|[^"\\])*)"/);
-  const currentCommand = commandMatch ? commandMatch[1].replaceAll('\\"', '"').replaceAll("\\\\", "\\") : void 0;
-  return {
-    linked_test_index: index,
-    linked_test_total: total,
-    current_command: currentCommand,
-    elapsed_ms: Number.isFinite(elapsed) ? elapsed : void 0,
-    heartbeat_at: nowIso(),
-    phase: linkedTestMatch[3]?.toLowerCase() === "end" ? "finished" : "running"
-  };
-}
-function splitLines(value) {
-  return value.split(/\r?\n/).map((entry) => entry.trimEnd()).filter((entry) => entry.length > 0);
-}
-function tailLines(value, limit) {
-  if (limit <= 0) {
-    return [];
-  }
-  const lines = splitLines(value);
-  if (lines.length <= limit) {
-    return lines;
-  }
-  return lines.slice(lines.length - limit);
-}
-async function resolveBackgroundCliEntry(cwd) {
-  const configured = process.env.PM_BACKGROUND_CLI_ENTRY?.trim();
-  if (configured && configured.length > 0) {
-    const resolvedConfigured = path.resolve(cwd, configured);
-    if (await pathExists(resolvedConfigured)) {
-      return resolvedConfigured;
-    }
-  }
-  const distEntry = path.resolve(cwd, "dist", "cli.js");
-  if (await pathExists(distEntry)) {
-    return distEntry;
-  }
-  const argvEntry = process.argv[1]?.trim();
-  if (argvEntry && argvEntry.length > 0) {
-    const resolvedArgvEntry = path.resolve(cwd, argvEntry);
-    if (await pathExists(resolvedArgvEntry)) {
-      return resolvedArgvEntry;
-    }
-  }
-  throw new PmCliError("Unable to resolve a CLI entrypoint for background test runs. Build the project or set PM_BACKGROUND_CLI_ENTRY.", EXIT_CODE.GENERIC_FAILURE);
-}
-async function refreshRunIfStale(pmRoot, record) {
-  if (!BACKGROUND_RUN_ACTIVE_STATUSES.has(record.status)) {
-    return record;
-  }
-  const workerAlive = isPidRunning(record.worker_pid);
-  if (workerAlive) {
-    return record;
-  }
-  if (record.finished_at) {
-    return record;
-  }
-  const next = {
-    ...record,
-    status: "failed",
-    finished_at: nowIso(),
-    error: record.error ?? "Background test run worker exited before writing terminal status."
-  };
-  await writeBackgroundRunRecord(pmRoot, next);
-  return next;
-}
-async function startBackgroundTestRun(options) {
-  await ensureBackgroundRunStorage(options.pmRoot);
-  const normalizedArgs = normalizeCommandArgs(options.commandArgs);
-  if (normalizedArgs.length === 0) {
-    throw new PmCliError("Background test run requires command arguments.", EXIT_CODE.USAGE);
-  }
-  const fingerprint = buildBackgroundTestRunFingerprint(options.kind, normalizedArgs, options.pmRoot);
-  const existingRuns = await listBackgroundTestRuns(options.pmRoot, {});
-  for (const existing of existingRuns) {
-    const refreshed = await refreshRunIfStale(options.pmRoot, existing);
-    if (refreshed.fingerprint !== fingerprint) {
-      continue;
-    }
-    if (!BACKGROUND_RUN_ACTIVE_STATUSES.has(refreshed.status) || !isPidRunning(refreshed.worker_pid)) {
-      continue;
-    }
-    return {
-      started: false,
-      run: {
-        ...refreshed,
-        duplicate_of: refreshed.id
-      },
-      duplicate_of: refreshed.id
-    };
-  }
-  const runId = buildRunId();
-  const createdAt = nowIso();
-  const stdoutPath = getTestRunStdoutPath(options.pmRoot, runId);
-  const stderrPath = getTestRunStderrPath(options.pmRoot, runId);
-  const resultPath = getTestRunResultPath(options.pmRoot, runId);
-  await fs.writeFile(stdoutPath, "", "utf8");
-  await fs.writeFile(stderrPath, "", "utf8");
-  const record = {
-    id: runId,
-    kind: options.kind,
-    status: "queued",
-    created_at: createdAt,
-    updated_at: createdAt,
-    requested_by: options.requestedBy,
-    fingerprint,
-    command_args: normalizedArgs,
-    command_label: summarizeCommandLabel(normalizedArgs),
-    pm_root: options.pmRoot,
-    global_pm_root: options.globalPmRoot,
-    target_id: options.targetId,
-    status_filter: options.statusFilter,
-    attempt: typeof options.attempt === "number" && Number.isFinite(options.attempt) && options.attempt >= 1 ? Math.floor(options.attempt) : 1,
-    resumed_from: options.resumedFrom,
-    resumed_by: options.resumedBy,
-    stdout_path: stdoutPath,
-    stderr_path: stderrPath,
-    result_path: resultPath,
-    progress: {
-      phase: "queued",
-      message: "Queued for background execution.",
-      heartbeat_at: createdAt
-    }
-  };
-  await writeBackgroundRunRecord(options.pmRoot, record);
-  return {
-    started: true,
-    run: record
-  };
-}
-async function spawnBackgroundTestRunWorker(options) {
-  const record = await readBackgroundTestRunRecord(options.pmRoot, options.runId);
-  if (!record) {
-    throw new PmCliError(`Background test run ${options.runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  if (BACKGROUND_RUN_TERMINAL_STATUSES.has(record.status)) {
-    throw new PmCliError(`Background test run ${record.id} is already terminal (${record.status}).`, EXIT_CODE.CONFLICT);
-  }
-  const cliEntry = await resolveBackgroundCliEntry(process.cwd());
-  const args = [];
-  if (options.noExtensions === true) {
-    args.push("--no-extensions");
-  }
-  args.push("--path", record.pm_root, "test-runs-worker", record.id);
-  const env = {
-    ...process.env,
-    PM_PATH: record.pm_root,
-    PM_GLOBAL_PATH: record.global_pm_root,
-    PM_BACKGROUND_TEST_RUN_ID: record.id,
-    PM_BACKGROUND_TEST_RUN_ATTEMPT: String(record.attempt),
-    PM_BACKGROUND_TEST_RUN_RESUMED_FROM: record.resumed_from ?? "",
-    FORCE_COLOR: "0"
-  };
-  const child = spawn(process.execPath, [cliEntry, ...args], {
-    cwd: process.cwd(),
-    env,
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true
-  });
-  child.unref();
-  const next = {
-    ...record,
-    status: "queued",
-    worker_pid: child.pid,
-    progress: {
-      phase: "queued",
-      message: "Worker process started.",
-      heartbeat_at: nowIso()
-    }
-  };
-  await writeBackgroundRunRecord(options.pmRoot, next);
-  return next;
-}
-async function appendFileOrdered(queue, filePath, text) {
-  await queue;
-  await fs.appendFile(filePath, text, "utf8");
-}
-function resolvePositiveEnvInteger(name, fallback) {
-  const parsed = Number.parseInt(process.env[name] ?? "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function buildBackgroundWorkerEnv(record) {
-  return {
-    ...process.env,
-    PM_PATH: record.pm_root,
-    PM_GLOBAL_PATH: record.global_pm_root,
-    FORCE_COLOR: "0"
-  };
-}
-function buildBackgroundWorkerChildArgs(record, noExtensions) {
-  return noExtensions ? ["--no-extensions", ...record.command_args] : [...record.command_args];
-}
-function createBackgroundRunRecordWriteScheduler(pmRoot, record) {
-  let writeQueue = Promise.resolve();
-  return {
-    schedule() {
-      writeQueue = writeQueue.then(async () => {
-        try {
-          await writeBackgroundRunRecord(pmRoot, record);
-        } catch {
-        }
-      });
-    },
-    async flush() {
-      await writeQueue;
-    }
-  };
-}
-function requestChildSignal(child, signal) {
-  try {
-    child.kill(signal);
-  } catch {
-  }
-}
-async function requestBackgroundWorkerStop(record, child, state, scheduleRecordWrite) {
-  if (state.stopRequested) {
-    return;
-  }
-  state.stopRequested = true;
-  record.stop_requested_at = nowIso();
-  record.progress = {
-    ...record.progress,
-    phase: "stopping",
-    message: "Stop requested for background run.",
-    heartbeat_at: nowIso()
-  };
-  scheduleRecordWrite();
-  requestChildSignal(child, "SIGTERM");
-  const forceTimer = setTimeout(() => requestChildSignal(child, "SIGKILL"), resolvePositiveEnvInteger("PM_BACKGROUND_RUN_FORCE_KILL_DELAY_MS", DEFAULT_BACKGROUND_RUN_FORCE_KILL_DELAY_MS));
-  forceTimer.unref?.();
-}
-function buildItemBackgroundProgress(line, progressPatch, phase) {
-  return {
-    phase,
-    message: line,
-    heartbeat_at: nowIso(),
-    item_index: progressPatch.item_index,
-    item_total: progressPatch.item_total,
-    item_id: progressPatch.item_id,
-    linked_test_index: void 0,
-    linked_test_total: void 0,
-    current_command: void 0,
-    elapsed_ms: void 0
-  };
-}
-function buildLinkedTestBackgroundProgress(line, record, progressPatch, phase) {
-  return {
-    phase,
-    message: line,
-    heartbeat_at: nowIso(),
-    item_index: progressPatch.item_index ?? record.progress?.item_index,
-    item_total: progressPatch.item_total ?? record.progress?.item_total,
-    item_id: progressPatch.item_id ?? record.progress?.item_id,
-    linked_test_index: progressPatch.linked_test_index,
-    linked_test_total: progressPatch.linked_test_total,
-    current_command: progressPatch.current_command,
-    elapsed_ms: progressPatch.elapsed_ms
-  };
-}
-function applyBackgroundWorkerProgressLine(record, line, stopRequested) {
-  const progressPatch = parseProgressLine(line);
-  if (!progressPatch) {
-    return false;
-  }
-  const phase = record.progress?.phase === "stopping" ? "stopping" : "running";
-  record.progress = progressPatch.item_id ? buildItemBackgroundProgress(line, progressPatch, phase) : buildLinkedTestBackgroundProgress(line, record, progressPatch, phase);
-  if (progressPatch.phase === "finished" && !stopRequested) {
-    record.progress.phase = "running";
-  }
-  return true;
-}
-function parseBackgroundWorkerStdout(stdoutBuffer) {
-  if (stdoutBuffer.trim().length === 0) {
-    return null;
-  }
-  try {
-    return JSON.parse(stdoutBuffer);
-  } catch {
-    return null;
-  }
-}
-function resolveBackgroundWorkerFinalStatus(record, stopRequested) {
-  if (stopRequested) {
-    return "stopped";
-  }
-  const passed = record.exit_code === 0 && (record.summary?.failed ?? 0) === 0 && record.summary?.fail_on_skipped_triggered !== true;
-  return passed ? "passed" : "failed";
-}
-function buildFinishedBackgroundProgress(record, stopRequested) {
-  return {
-    phase: "finished",
-    message: stopRequested ? "Background run stopped." : `Background run finished with status=${record.status}.`,
-    heartbeat_at: nowIso(),
-    item_index: record.progress?.item_index,
-    item_total: record.progress?.item_total,
-    item_id: record.progress?.item_id,
-    linked_test_index: record.progress?.linked_test_index,
-    linked_test_total: record.progress?.linked_test_total,
-    current_command: record.progress?.current_command,
-    elapsed_ms: record.progress?.elapsed_ms
-  };
-}
-async function writeBackgroundWorkerResult(record, parsedResult, stdoutBuffer) {
-  if (parsedResult !== null) {
-    await writeFileAtomic(record.result_path, `${JSON.stringify(parsedResult, null, 2)}
-`);
-    return;
-  }
-  await writeFileAtomic(record.result_path, `${JSON.stringify({
-    parse_error: "Background run output was not valid JSON.",
-    stdout_excerpt: tailLines(stdoutBuffer, DEFAULT_BACKGROUND_RUN_LOG_TAIL_LINES)
-  }, null, 2)}
-`);
-}
-async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = false) {
-  const loaded = await readBackgroundTestRunRecord(pmRoot, runId);
-  if (!loaded) {
-    throw new PmCliError(`Background test run ${runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const record = {
-    ...loaded,
-    status: "running",
-    started_at: loaded.started_at ?? nowIso(),
-    worker_pid: process.pid,
-    progress: {
-      phase: "running",
-      message: "Worker started.",
-      heartbeat_at: nowIso()
-    }
-  };
-  const cliEntry = await resolveBackgroundCliEntry(process.cwd());
-  const env = buildBackgroundWorkerEnv(record);
-  await writeBackgroundRunRecord(pmRoot, record);
-  const childArgs = buildBackgroundWorkerChildArgs(record, noExtensions);
-  const child = spawn(process.execPath, [cliEntry, ...childArgs], {
-    cwd: process.cwd(),
-    env,
-    detached: false,
-    stdio: ["ignore", "pipe", "pipe"],
-    windowsHide: true
-  });
-  record.child_pid = child.pid;
-  const recordWriteScheduler = createBackgroundRunRecordWriteScheduler(pmRoot, record);
-  const scheduleRecordWrite = recordWriteScheduler.schedule;
-  let stdoutWriteQueue = Promise.resolve();
-  let stderrWriteQueue = Promise.resolve();
-  let stdoutBuffer = "";
-  let stderrBuffer = "";
-  const stopState = { stopRequested: false };
-  const onSignal = () => {
-    void requestBackgroundWorkerStop(record, child, stopState, scheduleRecordWrite);
-  };
-  process.on("SIGTERM", onSignal);
-  process.on("SIGINT", onSignal);
-  const resourceTimer = setInterval(() => {
-    void (async () => {
-      record.resource = await buildResourceSnapshot(record);
-      record.progress.heartbeat_at = nowIso();
-      scheduleRecordWrite();
-    })();
-  }, resolvePositiveEnvInteger("PM_BACKGROUND_RUN_RESOURCE_INTERVAL_MS", DEFAULT_BACKGROUND_RUN_RESOURCE_SNAPSHOT_INTERVAL_MS));
-  resourceTimer.unref?.();
-  child.stdout?.on("data", (chunk) => {
-    const text = chunk.toString("utf8");
-    stdoutBuffer += text;
-    stdoutWriteQueue = appendFileOrdered(stdoutWriteQueue, record.stdout_path, text);
-  });
-  child.stderr?.on("data", (chunk) => {
-    const text = chunk.toString("utf8");
-    stderrWriteQueue = appendFileOrdered(stderrWriteQueue, record.stderr_path, text);
-    stderrBuffer += text;
-    const parts = stderrBuffer.split(/\r?\n/);
-    stderrBuffer = parts.pop();
-    let progressChanged = false;
-    for (const part of parts) {
-      const line = part.trimEnd();
-      if (line.length > 0 && applyBackgroundWorkerProgressLine(record, line, stopState.stopRequested)) {
-        progressChanged = true;
-      }
-    }
-    if (progressChanged) {
-      scheduleRecordWrite();
-    }
-  });
-  let exitCode = null;
-  let signal = null;
-  try {
-    ({ code: exitCode, signal } = await new Promise((resolve) => {
-      child.on("close", (code, closeSignal) => {
-        resolve({ code, signal: closeSignal });
-      });
-    }));
-  } finally {
-    clearInterval(resourceTimer);
-    process.off("SIGTERM", onSignal);
-    process.off("SIGINT", onSignal);
-  }
-  await stdoutWriteQueue;
-  await stderrWriteQueue;
-  const trailingStderrLine = stderrBuffer.trimEnd();
-  if (trailingStderrLine.length > 0 && applyBackgroundWorkerProgressLine(record, trailingStderrLine, stopState.stopRequested)) {
-    scheduleRecordWrite();
-  }
-  stderrBuffer = "";
-  const parsedResult = parseBackgroundWorkerStdout(stdoutBuffer);
-  const evaluated = evaluateWorkerResult(record.kind, parsedResult);
-  record.summary = evaluated.summary;
-  record.exit_code = typeof exitCode === "number" ? exitCode : void 0;
-  record.signal = signal ?? void 0;
-  record.finished_at = nowIso();
-  record.status = resolveBackgroundWorkerFinalStatus(record, stopState.stopRequested);
-  record.progress = buildFinishedBackgroundProgress(record, stopState.stopRequested);
-  record.resource = await buildResourceSnapshot(record);
-  await writeBackgroundWorkerResult(record, parsedResult, stdoutBuffer);
-  await writeBackgroundRunRecord(pmRoot, record);
-  await recordWriteScheduler.flush();
-  return record;
-}
-async function listBackgroundTestRuns(pmRoot, options) {
-  const recordPaths = await listBackgroundRunRecordPaths(pmRoot);
-  const runs = [];
-  for (const recordPath of recordPaths) {
-    const raw = await readFileIfExists(recordPath);
-    if (!raw) {
-      continue;
-    }
-    const parsed = await parseBackgroundRunRecord(raw, recordPath);
-    runs.push(parsed);
-  }
-  const refreshed = [];
-  for (const run of runs) {
-    refreshed.push(await refreshRunIfStale(pmRoot, run));
-  }
-  const filtered = options.status ? refreshed.filter((entry) => entry.status === options.status) : refreshed;
-  const sorted = filtered.sort((left, right) => {
-    const byUpdated = Date.parse(right.updated_at) - Date.parse(left.updated_at);
-    if (Number.isFinite(byUpdated) && byUpdated !== 0) {
-      return byUpdated;
-    }
-    return right.id.localeCompare(left.id);
-  });
-  const limit = typeof options.limit === "number" && options.limit >= 0 ? options.limit : void 0;
-  return limit === void 0 ? sorted : sorted.slice(0, limit);
-}
-async function getBackgroundTestRunStatus(pmRoot, runId) {
-  const loaded = await readBackgroundTestRunRecord(pmRoot, runId);
-  if (!loaded) {
-    throw new PmCliError(`Background test run ${runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const refreshed = await refreshRunIfStale(pmRoot, loaded);
-  const workerAlive = isPidRunning(refreshed.worker_pid);
-  const childAlive = isPidRunning(refreshed.child_pid);
-  if (refreshed.status === "running" && !childAlive && !refreshed.finished_at && !workerAlive) {
-    refreshed.status = "failed";
-    refreshed.finished_at = nowIso();
-    refreshed.error = refreshed.error ?? "Background run process exited unexpectedly.";
-    await writeBackgroundRunRecord(pmRoot, refreshed);
-  }
-  if (refreshed.status === "running") {
-    refreshed.resource = await buildResourceSnapshot(refreshed);
-    await writeBackgroundRunRecord(pmRoot, refreshed);
-  }
-  const heartbeatAt = refreshed.progress?.heartbeat_at;
-  const heartbeatAtMs = heartbeatAt ? Date.parse(heartbeatAt) : Number.NaN;
-  const lagMs = Number.isFinite(heartbeatAtMs) ? Math.max(0, nowMs() - heartbeatAtMs) : void 0;
-  const staleMs = Number.parseInt(process.env.PM_BACKGROUND_RUN_HEARTBEAT_STALE_MS ?? "", 10);
-  const staleThresholdMs = Number.isFinite(staleMs) && staleMs > 0 ? staleMs : DEFAULT_BACKGROUND_RUN_HEARTBEAT_STALE_MS;
-  const healthState = refreshed.status === "running" ? lagMs !== void 0 && lagMs > staleThresholdMs ? "stale" : "healthy" : "inactive";
-  return {
-    run: refreshed,
-    health: {
-      state: healthState,
-      last_heartbeat_at: heartbeatAt,
-      heartbeat_lag_ms: lagMs,
-      worker_alive: workerAlive,
-      child_alive: childAlive
-    }
-  };
-}
-function sendBackgroundRunStopSignal(record, force) {
-  const signal = force ? "SIGKILL" : "SIGTERM";
-  if (!isPidRunning(record.worker_pid) || !record.worker_pid) {
-    return "none";
-  }
-  try {
-    process.kill(record.worker_pid, signal);
-    return signal;
-  } catch {
-    return "none";
-  }
-}
-function buildStoppingBackgroundProgress(record, signalSent) {
-  return {
-    phase: "stopping",
-    message: signalSent === "none" ? "Run marked stopped." : `Stop requested via ${signalSent}.`,
-    heartbeat_at: nowIso(),
-    item_index: record.progress?.item_index,
-    item_total: record.progress?.item_total,
-    item_id: record.progress?.item_id,
-    linked_test_index: record.progress?.linked_test_index,
-    linked_test_total: record.progress?.linked_test_total,
-    current_command: record.progress?.current_command,
-    elapsed_ms: record.progress?.elapsed_ms
-  };
-}
-async function stopBackgroundTestRun(pmRoot, runId, force = false) {
-  const loaded = await readBackgroundTestRunRecord(pmRoot, runId);
-  if (!loaded) {
-    throw new PmCliError(`Background test run ${runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const refreshed = await refreshRunIfStale(pmRoot, loaded);
-  if (BACKGROUND_RUN_TERMINAL_STATUSES.has(refreshed.status)) {
-    return {
-      run: refreshed,
-      signal_sent: "none"
-    };
-  }
-  const signalSent = sendBackgroundRunStopSignal(refreshed, force);
-  if (signalSent === "none") {
-    refreshed.status = "stopped";
-    refreshed.finished_at = refreshed.finished_at ?? nowIso();
-  }
-  refreshed.stop_requested_at = nowIso();
-  refreshed.progress = buildStoppingBackgroundProgress(refreshed, signalSent);
-  await writeBackgroundRunRecord(pmRoot, refreshed);
-  return {
-    run: refreshed,
-    signal_sent: signalSent
-  };
-}
-async function resumeBackgroundTestRun(pmRoot, runId, requestedBy, noExtensions = false) {
-  const loaded = await readBackgroundTestRunRecord(pmRoot, runId);
-  if (!loaded) {
-    throw new PmCliError(`Background test run ${runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const refreshed = await refreshRunIfStale(pmRoot, loaded);
-  if (!BACKGROUND_RUN_TERMINAL_STATUSES.has(refreshed.status)) {
-    throw new PmCliError(`Background test run ${runId} is not terminal and cannot be resumed.`, EXIT_CODE.CONFLICT);
-  }
-  const started = await startBackgroundTestRun({
-    pmRoot: refreshed.pm_root,
-    globalPmRoot: refreshed.global_pm_root,
-    kind: refreshed.kind,
-    commandArgs: refreshed.command_args,
-    requestedBy,
-    targetId: refreshed.target_id,
-    statusFilter: refreshed.status_filter,
-    resumedFrom: refreshed.id,
-    resumedBy: requestedBy,
-    attempt: refreshed.attempt + 1
-  });
-  if (!started.started) {
-    return started.run;
-  }
-  const spawned = await spawnBackgroundTestRunWorker({
-    pmRoot,
-    runId: started.run.id,
-    noExtensions
-  });
-  const prior = {
-    ...refreshed,
-    resumed_by: spawned.id
-  };
-  await writeBackgroundRunRecord(pmRoot, prior);
-  return spawned;
-}
-async function readBackgroundTestRunLogs(pmRoot, runId, stream, tail) {
-  const loaded = await readBackgroundTestRunRecord(pmRoot, runId);
-  if (!loaded) {
-    throw new PmCliError(`Background test run ${runId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const resolvedTail = typeof tail === "number" && Number.isFinite(tail) && tail >= 0 ? Math.floor(tail) : DEFAULT_BACKGROUND_RUN_LOG_TAIL_LINES;
-  const stdoutRaw = stream === "stdout" || stream === "both" ? await readFileIfExists(loaded.stdout_path) ?? "" : "";
-  const stderrRaw = stream === "stderr" || stream === "both" ? await readFileIfExists(loaded.stderr_path) ?? "" : "";
-  return {
-    run: loaded,
-    stream,
-    tail: resolvedTail,
-    stdout: stream === "stdout" || stream === "both" ? tailLines(stdoutRaw, resolvedTail) : [],
-    stderr: stream === "stderr" || stream === "both" ? tailLines(stderrRaw, resolvedTail) : []
-  };
-}
-
-// dist/cli/commands/test-runs.js
-var BACKGROUND_STATUS_VALUES = ["queued", "running", "passed", "failed", "stopped", "canceled"];
-var BACKGROUND_STREAM_VALUES = ["stdout", "stderr", "both"];
-function normalizeStatus(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (BACKGROUND_STATUS_VALUES.includes(normalized)) {
-    return normalized;
-  }
-  throw new PmCliError(`Invalid --status value "${value}"`, EXIT_CODE.USAGE);
-}
-function normalizeStream(value) {
-  if (value === void 0 || value.trim().length === 0) {
-    return "stderr";
-  }
-  const normalized = value.trim().toLowerCase();
-  if (BACKGROUND_STREAM_VALUES.includes(normalized)) {
-    return normalized;
-  }
-  throw new PmCliError(`Invalid --stream value "${value}"`, EXIT_CODE.USAGE);
-}
-function resolveWhoamiFallback() {
-  try {
-    const username = os.userInfo().username.trim();
-    if (username.length > 0) {
-      return username;
-    }
-  } catch {
-  }
-  return void 0;
-}
-function resolveRequestedBy(author, fallback) {
-  const candidates = [
-    author,
-    process.env.PM_AUTHOR,
-    fallback,
-    process.env.USER,
-    process.env.LOGNAME,
-    process.env.USERNAME,
-    resolveWhoamiFallback()
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate !== "string") {
-      continue;
-    }
-    const trimmed = candidate.trim();
-    if (trimmed.length > 0) {
-      return trimmed;
-    }
-  }
-  return "unknown";
-}
-async function ensureInitialized(pmRoot) {
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-}
-async function runStartBackgroundRun(options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const requestedBy = resolveRequestedBy(options.author, settings.author_default);
-  const started = await startBackgroundTestRun({
-    pmRoot,
-    globalPmRoot,
-    kind: options.kind,
-    commandArgs: options.commandArgs,
-    requestedBy,
-    targetId: options.targetId,
-    statusFilter: options.statusFilter
-  });
-  if (!started.started) {
-    return {
-      started: false,
-      duplicate_of: started.duplicate_of,
-      run: started.run
-    };
-  }
-  const spawned = await spawnBackgroundTestRunWorker({
-    pmRoot,
-    runId: started.run.id,
-    noExtensions: options.noExtensions === true
-  });
-  return {
-    started: true,
-    run: spawned
-  };
-}
-async function runTestRunsList(options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const status = normalizeStatus(options.status);
-  const limit = parseLimit(options.limit, "limit");
-  const runs = await listBackgroundTestRuns(pmRoot, { status, limit });
-  return {
-    runs,
-    count: runs.length,
-    filters: {
-      status,
-      limit
-    }
-  };
-}
-async function runTestRunsStatus(runId, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const status = await getBackgroundTestRunStatus(pmRoot, runId);
-  return {
-    run: status.run,
-    health: status.health
-  };
-}
-async function runTestRunsLogs(runId, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const stream = normalizeStream(options.stream);
-  const tail = parseLimit(options.tail, "tail");
-  const logs = await readBackgroundTestRunLogs(pmRoot, runId, stream, tail);
-  return {
-    run: logs.run,
-    stream: logs.stream,
-    tail: logs.tail,
-    stdout: logs.stdout,
-    stderr: logs.stderr
-  };
-}
-async function runTestRunsStop(runId, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const stopped = await stopBackgroundTestRun(pmRoot, runId, options.force === true);
-  return {
-    run: stopped.run,
-    signal_sent: stopped.signal_sent
-  };
-}
-async function runTestRunsResume(runId, options, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const requestedBy = resolveRequestedBy(options.author, settings.author_default);
-  const resumed = await resumeBackgroundTestRun(pmRoot, runId, requestedBy, options.noExtensions === true);
-  return {
-    resumed_from: runId,
-    run: resumed
-  };
-}
-async function runTestRunsWorker(runId, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitialized(pmRoot);
-  const finished = await runBackgroundTestRunWorker(pmRoot, runId, global.noExtensions === true);
-  return {
-    id: finished.id,
-    status: finished.status,
-    exit_code: finished.exit_code
-  };
-}
-
-export {
-  runStartBackgroundRun,
-  runTestRunsList,
-  runTestRunsStatus,
-  runTestRunsLogs,
-  runTestRunsStop,
-  runTestRunsResume,
-  runTestRunsWorker
-};
-//# sourceMappingURL=chunk-PPAJG4GB.js.map
-
-//# debugId=06f25e42-4a55-5490-b7f5-780bc79db731