@poetic-ai/poetic 1.42.0

package/dist/chunk-4BJ3O4RQ.js

@@ -0,0 +1,929 @@
+import {
+  processScanner
+} from "./chunk-U2S3YEX3.js";
+import {
+  RegistryStateAccessError,
+  processRegistry
+} from "./chunk-XPHKYHO4.js";
+import {
+  ExitCodeError,
+  isExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-4CUY7AFY.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+
+// src/cli/commands/processes.ts
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/core/process-manager.ts
+import { execFileSync } from "child_process";
+import AsyncLock from "async-lock";
+import chalk from "chalk";
+var ProcessManager = class _ProcessManager {
+  static instance = null;
+  static isCreating = false;
+  // Prevent race condition during creation
+  processes = /* @__PURE__ */ new Map();
+  processHandles = /* @__PURE__ */ new Map();
+  cleanupHandlersRegistered = false;
+  cleanupInProgress = false;
+  verbose = false;
+  cleanedUpPidTokens = /* @__PURE__ */ new Map();
+  // PID -> start timestamp token
+  lock = new AsyncLock();
+  // Mutex for protecting Map operations
+  LOCK_KEY = "processes-map";
+  // Lock key for async-lock
+  CLEANED_PID_TOKEN_TTL_MS = 500;
+  KILL_ALL_GRACE_MS = 250;
+  static getInstance() {
+    if (!_ProcessManager.instance) {
+      if (_ProcessManager.isCreating) {
+        throw new Error(
+          "ProcessManager singleton is being created by another context. This should not happen in Node.js single-threaded environment."
+        );
+      }
+      _ProcessManager.isCreating = true;
+      try {
+        if (!_ProcessManager.instance) {
+          _ProcessManager.instance = new _ProcessManager();
+        }
+      } finally {
+        _ProcessManager.isCreating = false;
+      }
+    }
+    return _ProcessManager.instance;
+  }
+  constructor() {
+    this.registerCleanupHandlers();
+    this.verbose = process.env.POETIC_PROCESS_MANAGER_VERBOSE === "1";
+  }
+  /**
+   * Register a spawned child process for tracking
+   * Synchronous to maintain backward compatibility with existing callers
+   */
+  register(child, info) {
+    if (!child.pid) {
+      if (this.verbose) {
+        console.log(chalk.yellow("Cannot register process: no PID"));
+      }
+      return;
+    }
+    const pid = child.pid;
+    if (child.exitCode !== null || child.signalCode !== null) {
+      if (this.verbose) {
+        console.log(chalk.yellow(`Cannot register already exited process ${child.pid}`));
+      }
+      return;
+    }
+    const startedAtMs = Date.now();
+    const processInfo = {
+      pid: child.pid,
+      startedAt: new Date(startedAtMs),
+      ...info
+    };
+    if (process.platform !== "win32") {
+      try {
+        const pgid = execFileSync("ps", ["-o", "pgid=", "-p", String(child.pid)], {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"]
+        }).trim();
+        if (pgid && parseInt(pgid, 10) === pid) {
+          processInfo.isProcessGroupLeader = true;
+          if (this.verbose) {
+            console.log(chalk.gray(`Process ${pid} detected as process group leader`));
+          }
+        }
+      } catch {
+        try {
+          process.kill(-pid, 0);
+          processInfo.isProcessGroupLeader = true;
+        } catch {
+        }
+      }
+    }
+    this.processes.set(pid, processInfo);
+    this.processHandles.set(pid, { child, startedAtMs });
+    processRegistry.register({
+      pid,
+      type: "spawned",
+      category: info.type === "variant" || info.type === "orchestrator" ? info.type : "worker",
+      taskId: info.taskId,
+      command: info.command,
+      startedAt: processInfo.startedAt.toISOString(),
+      source: "process-manager",
+      health: "healthy"
+    }).catch((error) => {
+      if (this.verbose) {
+        console.log(chalk.yellow(`Failed to register in registry: ${error.message}`));
+      }
+    });
+    if (this.verbose) {
+      console.log(
+        chalk.gray(`Registered process ${child.pid} for task ${info.taskId} (${info.type})`)
+      );
+    }
+    const subscribe = typeof child.once === "function" ? child.once.bind(child) : typeof child.on === "function" ? child.on.bind(child) : null;
+    if (!subscribe) {
+      if (this.verbose) {
+        console.log(
+          chalk.yellow(`Cannot subscribe to child ${child.pid} events (missing once/on)`)
+        );
+      }
+      return;
+    }
+    subscribe("exit", (code, signal) => {
+      if (this.verbose) {
+        console.log(
+          chalk.gray(`OK Process ${pid} exited (code: ${code}, signal: ${signal ?? "none"})`)
+        );
+      }
+      this.unregister(pid, startedAtMs).catch((error) => {
+        if (this.verbose) {
+          console.log(chalk.yellow(`Failed to unregister on exit: ${error.message}`));
+        }
+      });
+    });
+    subscribe("error", (error) => {
+      if (this.verbose) {
+        console.log(chalk.red(`Process ${pid} error: ${error.message}`));
+      }
+      const cleanupToken = this.cleanedUpPidTokens.get(pid);
+      if (cleanupToken === startedAtMs) return;
+      this.unregister(pid, startedAtMs).catch((err) => {
+        if (this.verbose) {
+          console.log(chalk.yellow(`Failed to unregister on error: ${err.message}`));
+        }
+      });
+    });
+  }
+  /**
+   * Unregister a process (called automatically on exit)
+   * CRITICAL: Now async with mutex protection to prevent race conditions
+   */
+  async unregister(pid, expectedStartedAtMs) {
+    const result = await this.lock.acquire(
+      this.LOCK_KEY,
+      async () => {
+        const existing = this.processes.get(pid);
+        if (!existing) {
+          return { status: "missing" };
+        }
+        const currentStartedAtMs = existing.startedAt.getTime();
+        if (typeof expectedStartedAtMs === "number" && Number.isFinite(expectedStartedAtMs) && currentStartedAtMs !== expectedStartedAtMs) {
+          return { status: "pid_reused", currentStartedAtMs };
+        }
+        this.processes.delete(pid);
+        const currentHandle = this.processHandles.get(pid);
+        if (currentHandle?.startedAtMs === currentStartedAtMs) {
+          this.processHandles.delete(pid);
+        }
+        return { status: "tracked", startedAtMs: currentStartedAtMs };
+      }
+    );
+    if (result.status === "tracked") {
+      this.cleanedUpPidTokens.set(pid, result.startedAtMs);
+      try {
+        await processRegistry.unregister(pid, new Date(result.startedAtMs).toISOString());
+      } catch (error) {
+        if (this.verbose) {
+          console.log(
+            chalk.yellow(`Failed to unregister from registry: ${error.message}`)
+          );
+        }
+      }
+      setTimeout(() => {
+        const token = this.cleanedUpPidTokens.get(pid);
+        if (token === result.startedAtMs) {
+          this.cleanedUpPidTokens.delete(pid);
+        }
+      }, this.CLEANED_PID_TOKEN_TTL_MS);
+    } else if (result.status === "pid_reused") {
+      if (this.verbose) {
+        console.log(
+          chalk.gray(
+            `Skipped unregister for stale PID ${pid} (expected start ${expectedStartedAtMs}, current ${result.currentStartedAtMs})`
+          )
+        );
+      }
+    } else if (this.verbose) {
+      console.log(chalk.yellow(`Attempted to unregister unknown PID ${pid}`));
+    }
+  }
+  /**
+   * Get all tracked processes
+   */
+  getAll() {
+    return Array.from(this.processes.values());
+  }
+  /**
+   * Get processes for a specific task
+   */
+  getByTaskId(taskId) {
+    return this.getAll().filter((p) => p.taskId === taskId);
+  }
+  isSameTrackedProcess(proc) {
+    const current = this.processes.get(proc.pid);
+    const expectedStartedAtMs = proc.startedAt.getTime();
+    if (current?.startedAt.getTime() !== expectedStartedAtMs) {
+      return false;
+    }
+    const handle = this.processHandles.get(proc.pid);
+    if (handle?.startedAtMs !== expectedStartedAtMs) {
+      return false;
+    }
+    return handle.child.exitCode === null && handle.child.signalCode === null;
+  }
+  async waitForKillGrace(abortSignal) {
+    if (!abortSignal) {
+      await new Promise((resolve) => setTimeout(resolve, this.KILL_ALL_GRACE_MS));
+      return true;
+    }
+    if (abortSignal.aborted) {
+      return false;
+    }
+    return await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        abortSignal.removeEventListener("abort", onAbort);
+        resolve(true);
+      }, this.KILL_ALL_GRACE_MS);
+      timeout.unref?.();
+      const onAbort = () => {
+        clearTimeout(timeout);
+        resolve(false);
+      };
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /**
+   * Kill all processes for a specific task
+   * Note: Processes are auto-unregistered by the 'exit' event handler
+   */
+  killByTaskId(taskId) {
+    const procs = this.getByTaskId(taskId);
+    let killed = 0;
+    const getTargetPid = (proc) => proc.isProcessGroupLeader && process.platform !== "win32" ? -proc.pid : proc.pid;
+    for (const proc of procs) {
+      if (!this.isSameTrackedProcess(proc)) {
+        continue;
+      }
+      try {
+        process.kill(getTargetPid(proc), "SIGTERM");
+        killed++;
+        if (this.verbose) {
+          const groupMsg = proc.isProcessGroupLeader ? " (process group)" : "";
+          console.log(
+            chalk.gray(`Sent SIGTERM to process ${proc.pid}${groupMsg} for task ${taskId}`)
+          );
+        }
+      } catch (error) {
+        if (this.verbose) {
+          console.log(
+            chalk.yellow(
+              `Failed to kill process ${proc.pid}: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
+    }
+    if (killed > 0) {
+      setTimeout(() => {
+        for (const proc of procs) {
+          if (!this.isSameTrackedProcess(proc)) continue;
+          if (!this.isRunning(proc.pid)) continue;
+          try {
+            process.kill(getTargetPid(proc), "SIGKILL");
+          } catch {
+          }
+        }
+      }, this.KILL_ALL_GRACE_MS).unref();
+    }
+    return killed;
+  }
+  /**
+   * Kill all tracked processes
+   * CRITICAL: Now async with mutex protection to prevent race conditions
+   */
+  async killAll(silent = false, abortSignal) {
+    let killed = 0;
+    const pidsToKill = await this.lock.acquire(this.LOCK_KEY, async () => {
+      return Array.from(this.processes.values());
+    });
+    const getTargetPid = (proc) => proc.isProcessGroupLeader && process.platform !== "win32" ? -proc.pid : proc.pid;
+    for (const proc of pidsToKill) {
+      if (!this.isSameTrackedProcess(proc)) {
+        continue;
+      }
+      try {
+        process.kill(getTargetPid(proc), "SIGTERM");
+        killed++;
+      } catch {
+      }
+    }
+    if (killed > 0) {
+      await this.waitForKillGrace(abortSignal);
+      for (const proc of pidsToKill) {
+        if (!this.isSameTrackedProcess(proc)) continue;
+        if (!this.isRunning(proc.pid)) continue;
+        try {
+          process.kill(getTargetPid(proc), "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    await this.lock.acquire(this.LOCK_KEY, async () => {
+      for (const proc of pidsToKill) {
+        if (!this.isRunning(proc.pid)) {
+          this.processes.delete(proc.pid);
+          const currentHandle = this.processHandles.get(proc.pid);
+          if (currentHandle?.startedAtMs === proc.startedAt.getTime()) {
+            this.processHandles.delete(proc.pid);
+          }
+        }
+      }
+    });
+    if (!silent && killed > 0) {
+      console.log(chalk.gray(`OK Cleaned up ${killed} Poetic process${killed === 1 ? "" : "es"}`));
+    }
+    return killed;
+  }
+  /**
+   * Check if a process is still running
+   */
+  isRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get count of active processes
+   */
+  getActiveCount() {
+    return this.processes.size;
+  }
+  /**
+   * Get all Poetic processes (cross-process view via registry)
+   * NEW: Query shared registry for complete picture
+   */
+  async getAllPoetic() {
+    try {
+      const entries = await processRegistry.getAll();
+      return entries.map((e) => ({
+        pid: e.pid,
+        taskId: e.taskId || "unknown",
+        command: e.command,
+        startedAt: new Date(e.startedAt),
+        type: this.mapCategoryToType(e.category)
+      }));
+    } catch (error) {
+      if (this.verbose) {
+        console.log(chalk.yellow(`Failed to query registry: ${error.message}`));
+      }
+      return this.getAll();
+    }
+  }
+  /**
+   * Get health report from registry
+   * NEW: Cross-process health monitoring
+   */
+  async getHealth() {
+    try {
+      return await processRegistry.scan();
+    } catch (error) {
+      if (this.verbose) {
+        console.log(chalk.yellow(`Failed to scan registry: ${error.message}`));
+      }
+      return {
+        totalProcesses: this.processes.size,
+        healthyCount: this.processes.size,
+        orphanedCount: 0,
+        staleCount: 0
+      };
+    }
+  }
+  mapCategoryToType(category) {
+    switch (category) {
+      case "variant":
+        return "variant";
+      case "orchestrator":
+        return "orchestrator";
+      case "monitor":
+        return "monitor";
+      default:
+        return "worker";
+    }
+  }
+  /**
+   * Register cleanup handlers (called automatically in constructor)
+   * CRITICAL: Now uses async cleanup to properly await mutex operations
+   */
+  registerCleanupHandlers() {
+    if (this.cleanupHandlersRegistered) return;
+    signalCoordinator.register("ProcessManager", async (context) => {
+      if (this.cleanupInProgress) {
+        return;
+      }
+      this.cleanupInProgress = true;
+      const count = this.processes.size;
+      try {
+        if (count > 0) {
+          console.log(chalk.gray(`Cleaning up ${count} Poetic processes...`));
+          await this.killAll(true, context?.abortSignal);
+        }
+      } finally {
+        this.cleanupInProgress = false;
+      }
+    });
+    this.cleanupHandlersRegistered = true;
+  }
+};
+var processManager = ProcessManager.getInstance();
+
+// src/cli/commands/processes.ts
+var validProcessCategories = [
+  "variant",
+  "orchestrator",
+  "monitor",
+  "worker",
+  "test",
+  "cli",
+  "daemon"
+];
+var validProcessTypes = ["spawned", "detected", "external"];
+var CLEANUP_HEALTH_STATUSES = ["orphaned", "stale", "zombie"];
+var isValidCategory = (value) => validProcessCategories.includes(value);
+var isValidType = (value) => validProcessTypes.includes(value);
+var isCleanupHealthStatus = (value) => CLEANUP_HEALTH_STATUSES.includes(value);
+function exitProcessesCommand(code = 1) {
+  throw new ExitCodeError(code);
+}
+function formatRegistryAccessErrorJson(error) {
+  return JSON.stringify(
+    {
+      error: true,
+      kind: "registry_state_access",
+      operation: error.operation,
+      stateDir: error.stateDir,
+      registryPath: error.registryPath,
+      code: error.code,
+      message: error.message,
+      remediation: error.remediation
+    },
+    null,
+    2
+  );
+}
+function shouldPreviewCleanup(options) {
+  return Boolean(options.dryRun || options.json && !options.force);
+}
+function emitCleanupJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+function validateProcessFilters(options) {
+  let category;
+  if (options.category) {
+    if (!isValidCategory(options.category)) {
+      console.error(
+        chalk2.red(
+          `Invalid category: ${options.category}. Valid values: ${validProcessCategories.join(", ")}`
+        )
+      );
+      exitProcessesCommand();
+    }
+    category = options.category;
+  }
+  let type;
+  if (options.type) {
+    if (!isValidType(options.type)) {
+      console.error(
+        chalk2.red(`Invalid type: ${options.type}. Valid values: ${validProcessTypes.join(", ")}`)
+      );
+      exitProcessesCommand();
+    }
+    type = options.type;
+  }
+  return { category, type };
+}
+function validateRequestedAction(actionArg, options) {
+  const actionFromArg = (() => {
+    if (!actionArg) return void 0;
+    const normalized = actionArg.trim().toLowerCase();
+    if (normalized === "list" || normalized === "cleanup" || normalized === "health" || normalized === "scan") {
+      return normalized;
+    }
+    throw new Error(`Unknown processes action: ${actionArg}`);
+  })();
+  const optionActions = [];
+  if (options.list) optionActions.push("list");
+  if (options.cleanup) optionActions.push("cleanup");
+  if (options.health) optionActions.push("health");
+  if (options.scan) optionActions.push("scan");
+  if (options.kill) optionActions.push("kill");
+  const requestedActions = [...actionFromArg ? [actionFromArg] : [], ...optionActions];
+  const uniqueActions = Array.from(new Set(requestedActions));
+  if (uniqueActions.length > 1) {
+    throw new Error(
+      `Conflicting processes actions: ${uniqueActions.join(", ")}. Choose exactly one action.`
+    );
+  }
+  return uniqueActions[0] ?? "list";
+}
+function filterProcessEntries(entries, filters) {
+  return entries.filter((entry) => {
+    if (filters.category && entry.category !== filters.category) return false;
+    if (filters.type && entry.type !== filters.type) return false;
+    return true;
+  });
+}
+function summarizeProcessEntries(entries) {
+  return {
+    totalProcesses: entries.length,
+    healthyCount: entries.filter((entry) => entry.health === "healthy").length,
+    orphanedCount: entries.filter((entry) => entry.health === "orphaned").length,
+    staleCount: entries.filter((entry) => entry.health === "stale").length,
+    zombieCount: entries.filter((entry) => entry.health === "zombie").length,
+    orphanedPids: entries.filter((entry) => entry.health === "orphaned").map((entry) => entry.pid)
+  };
+}
+var processesCommand = new Command("processes").description("Manage Poetic processes (list, cleanup, health)").argument("[action]", "Action to run: list, cleanup, health, or scan").option("-l, --list", "List all managed processes (default)", false).option("-c, --cleanup", "Clean up orphaned processes", false).option("--health", "Show health status", false).option("--scan", "Scan for all Poetic processes", false).option("--kill <taskId>", "Kill processes for specific task").option("--category <type>", "Filter by category (cli, test, variant, etc.)").option("--type <type>", "Filter by type (spawned, detected, external)").option("--json", "Output as JSON", false).option("--dry-run", "Preview cleanup candidates without killing processes", false).option(
+  "-f, --force",
+  "Skip confirmation prompts (required with --json to execute cleanup)",
+  false
+).action(async (actionArg, options) => {
+  try {
+    const action = validateRequestedAction(actionArg, options);
+    await processRegistry.init();
+    switch (action) {
+      case "list":
+        await listProcesses(options);
+        break;
+      case "cleanup":
+        await cleanupProcesses(options);
+        break;
+      case "health":
+        await showHealth(options);
+        break;
+      case "scan":
+        await scanProcesses(options);
+        break;
+      case "kill":
+        await killTask(options.kill, options);
+        break;
+    }
+  } catch (error) {
+    if (isExitCodeError(error)) {
+      throw error;
+    }
+    if (error instanceof RegistryStateAccessError) {
+      if (options.json) {
+        console.log(formatRegistryAccessErrorJson(error));
+      } else {
+        console.error(chalk2.red(`Error: ${error.message}`));
+      }
+      exitProcessesCommand();
+    }
+    console.error(chalk2.red(`Error: ${error.message}`));
+    exitProcessesCommand();
+  }
+});
+async function listProcesses(options) {
+  await processRegistry.scan();
+  let entries = await processRegistry.getAll();
+  const filters = validateProcessFilters(options);
+  entries = filterProcessEntries(entries, filters);
+  if (options.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log(chalk2.gray("No managed processes found."));
+    return;
+  }
+  console.log(chalk2.bold(`
+Managed Processes (${entries.length})
+`));
+  console.log(
+    chalk2.gray(
+      `${"PID".padEnd(8)}${"Category".padEnd(14)}${"Health".padEnd(12)}${"Age".padEnd(10)}${"Task ID".padEnd(20)}`
+    )
+  );
+  console.log(chalk2.gray("-".repeat(70)));
+  for (const entry of entries) {
+    const pid = entry.pid.toString().padEnd(8);
+    const category = entry.category.padEnd(14);
+    const health = formatHealth(entry.health).padEnd(12);
+    const age = formatAge(entry.startedAt);
+    const taskId = (entry.taskId || "-").substring(0, 18).padEnd(20);
+    console.log(`${pid}${category}${health}${age}${taskId}`);
+  }
+  console.log("");
+}
+async function cleanupProcesses(options) {
+  const preview = shouldPreviewCleanup(options);
+  if (!options.json) {
+    console.log(chalk2.gray("Scanning for processes..."));
+  }
+  await processScanner.scan({ includeAll: true });
+  await processRegistry.scan();
+  const orphaned = await processRegistry.getOrphaned();
+  const unhealthy = (await processRegistry.getAll()).filter(
+    (entry) => isCleanupHealthStatus(entry.health)
+  );
+  let candidates = [...orphaned, ...unhealthy];
+  if (options.category) {
+    candidates = candidates.filter((e) => e.category === options.category);
+  }
+  if (options.type) {
+    candidates = candidates.filter((e) => e.type === options.type);
+  }
+  const uniquePids = new Set(candidates.map((c) => c.pid));
+  candidates = Array.from(uniquePids).map((pid) => candidates.find((c) => c.pid === pid));
+  const filters = validateProcessFilters(options);
+  const tmuxSessionCandidates = await reapOrphanedTmuxSessions({
+    dryRun: true,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  if (candidates.length === 0 && tmuxSessionCandidates.length === 0) {
+    if (options.json) {
+      emitCleanupJson({
+        action: "cleanup",
+        dryRun: preview,
+        candidateCount: 0,
+        candidates: [],
+        tmuxSessions: [],
+        message: "No processes need cleanup"
+      });
+      return;
+    }
+    console.log(chalk2.green("OK: No processes need cleanup"));
+    return;
+  }
+  if (preview) {
+    if (options.json) {
+      emitCleanupJson({
+        action: "cleanup",
+        dryRun: true,
+        candidateCount: candidates.length + tmuxSessionCandidates.length,
+        candidates,
+        tmuxSessions: tmuxSessionCandidates,
+        hint: "Add --force to execute cleanup (or omit --json/--dry-run for interactive cleanup)"
+      });
+      return;
+    }
+    console.log(
+      chalk2.yellow(
+        `
+Dry run: Found ${candidates.length + tmuxSessionCandidates.length} process/session item(s) to clean up:
+`
+      )
+    );
+    for (const entry of candidates) {
+      const status = entry.health === "orphaned" ? chalk2.red("orphaned") : chalk2.yellow("stale");
+      console.log(
+        `  PID ${entry.pid} (${entry.category}) - ${status} - ${formatAge(entry.startedAt)}`
+      );
+    }
+    for (const session of tmuxSessionCandidates) {
+      console.log(`  tmux session ${session} - orphaned`);
+    }
+    console.log(chalk2.gray("\nRe-run without --dry-run to execute cleanup."));
+    return;
+  }
+  if (!options.json) {
+    console.log(
+      chalk2.yellow(
+        `
+Warning: Found ${candidates.length + tmuxSessionCandidates.length} process/session item(s) to clean up:
+`
+      )
+    );
+    for (const entry of candidates) {
+      const status = entry.health === "orphaned" ? chalk2.red("orphaned") : chalk2.yellow("stale");
+      console.log(
+        `  PID ${entry.pid} (${entry.category}) - ${status} - ${formatAge(entry.startedAt)}`
+      );
+    }
+    for (const session of tmuxSessionCandidates) {
+      console.log(`  tmux session ${session} - orphaned`);
+    }
+  }
+  if (!options.force) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk2.bold("\nKill these processes? [y/N] "), resolve);
+    });
+    rl.close();
+    if (!answer.match(/^[Yy]/)) {
+      if (options.json) {
+        emitCleanupJson({
+          action: "cleanup",
+          dryRun: true,
+          candidateCount: candidates.length + tmuxSessionCandidates.length,
+          candidates,
+          tmuxSessions: tmuxSessionCandidates,
+          message: "Aborted by user"
+        });
+      } else {
+        console.log(chalk2.gray("Aborted."));
+      }
+      return;
+    }
+  }
+  if (!options.json) {
+    console.log(chalk2.gray("\nCleaning up processes..."));
+  }
+  const result = await processRegistry.cleanup({
+    health: CLEANUP_HEALTH_STATUSES,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  const tmuxSessionsReaped = await reapOrphanedTmuxSessions({
+    dryRun: false,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  if (options.json) {
+    emitCleanupJson({
+      action: "cleanup",
+      dryRun: false,
+      candidateCount: candidates.length + tmuxSessionCandidates.length,
+      candidates,
+      tmuxSessions: tmuxSessionCandidates,
+      result: {
+        ...result,
+        tmuxSessionsReaped
+      }
+    });
+    return;
+  }
+  console.log(chalk2.green("\nOK: Cleanup complete:"));
+  console.log(`  Attempted: ${result.attempted}`);
+  console.log(`  Killed: ${result.killed}`);
+  if (tmuxSessionsReaped.length > 0) {
+    console.log(`  Tmux sessions: ${tmuxSessionsReaped.length}`);
+  }
+  if (result.failed > 0) {
+    console.log(chalk2.yellow(`  Failed: ${result.failed}`));
+  }
+  if (result.errors.length > 0) {
+    console.log(chalk2.red("\nErrors:"));
+    for (const error of result.errors) {
+      console.log(`  PID ${error.pid}: ${error.error}`);
+    }
+  }
+}
+async function showHealth(options) {
+  const filters = validateProcessFilters(options);
+  if (!options.json) {
+    console.log(chalk2.gray("Scanning processes..."));
+  }
+  await processScanner.scan({ includeAll: true });
+  const unfilteredHealth = await processRegistry.scan();
+  const health = filters.category || filters.type ? summarizeProcessEntries(filterProcessEntries(await processRegistry.getAll(), filters)) : unfilteredHealth;
+  const tmuxSessions = await reapOrphanedTmuxSessions({
+    dryRun: true,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  const tmuxOrphanedCount = tmuxSessions.length;
+  const unhealthyCount = health.orphanedCount + health.staleCount + health.zombieCount + tmuxOrphanedCount;
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...health,
+          tmuxOrphanedCount,
+          ...tmuxOrphanedCount > 0 ? { tmuxSessions } : {}
+        },
+        null,
+        2
+      )
+    );
+    if (unhealthyCount > 0) {
+      exitProcessesCommand(1);
+    }
+    return;
+  }
+  console.log(chalk2.bold("\nHealth Report\n"));
+  console.log(`Total processes: ${health.totalProcesses}`);
+  console.log(`  Healthy: ${health.healthyCount}`);
+  console.log(`  Orphaned: ${health.orphanedCount}`);
+  console.log(`  Stale: ${health.staleCount}`);
+  console.log(`  Zombie: ${health.zombieCount}`);
+  console.log(`  Orphaned tmux sessions: ${tmuxOrphanedCount}`);
+  if (unhealthyCount > 0) {
+    console.log(
+      chalk2.yellow(`
+Warning: Recommendation: Run ${chalk2.bold("poetic processes --cleanup")}`)
+    );
+    console.log("");
+    exitProcessesCommand(1);
+  } else {
+    console.log(chalk2.green("\nOK: All processes healthy"));
+  }
+  console.log("");
+}
+async function scanProcesses(options) {
+  if (!options.json) {
+    console.log(chalk2.gray("Scanning for all Poetic processes..."));
+  }
+  const detected = await processScanner.scan({ includeAll: true });
+  if (options.json) {
+    console.log(JSON.stringify(detected, null, 2));
+    return;
+  }
+  console.log(chalk2.bold(`
+Detected ${detected.length} process(es):
+`));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const proc of detected) {
+    const list = byCategory.get(proc.category) || [];
+    list.push(proc);
+    byCategory.set(proc.category, list);
+  }
+  for (const [category, procs] of byCategory) {
+    console.log(chalk2.bold(`${category.toUpperCase()} (${procs.length}):`));
+    for (const proc of procs) {
+      const orphan = proc.ppid === 1 ? chalk2.red(" [ORPHANED]") : "";
+      console.log(`  PID ${proc.pid}${orphan}`);
+      console.log(chalk2.gray(`    ${proc.command.substring(0, 80)}`));
+    }
+    console.log("");
+  }
+}
+async function killTask(taskId, options) {
+  const processes = await processRegistry.getByTaskId(taskId);
+  if (processes.length === 0) {
+    console.log(chalk2.yellow(`No processes found for task: ${taskId}`));
+    return;
+  }
+  console.log(chalk2.yellow(`Found ${processes.length} process(es) for task ${taskId}`));
+  if (!options.force) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk2.bold("Kill these processes? [y/N] "), resolve);
+    });
+    rl.close();
+    if (!answer.match(/^[Yy]/)) {
+      console.log(chalk2.gray("Aborted."));
+      return;
+    }
+  }
+  const managerKilled = processManager.killByTaskId(taskId);
+  const registryPids = processes.map((entry) => entry.pid).filter((pid) => typeof pid === "number" && Number.isFinite(pid));
+  const registryResult = registryPids.length > 0 ? await processRegistry.cleanup({ pids: registryPids }) : { killed: 0, failed: 0, errors: [] };
+  const killed = Math.min(processes.length, managerKilled + registryResult.killed);
+  if (registryResult.failed > 0) {
+    console.log(
+      chalk2.yellow(
+        `Warning: Failed to kill ${registryResult.failed} process(es) for task ${taskId}`
+      )
+    );
+  }
+  console.log(chalk2.green(`OK: Killed ${killed} process(es)`));
+}
+function formatHealth(health) {
+  switch (health) {
+    case "healthy":
+      return chalk2.green("healthy");
+    case "orphaned":
+      return chalk2.red("orphaned");
+    case "stale":
+      return chalk2.yellow("stale");
+    case "zombie":
+      return chalk2.gray("zombie");
+    default:
+      return health;
+  }
+}
+function formatAge(startedAt) {
+  const started = new Date(startedAt).getTime();
+  const age = (Date.now() - started) / 1e3;
+  if (age < 60) return `${Math.floor(age)}s`;
+  if (age < 3600) return `${Math.floor(age / 60)}m`;
+  if (age < 86400) return `${Math.floor(age / 3600)}h`;
+  return `${Math.floor(age / 86400)}d`;
+}
+
+export {
+  processManager,
+  processesCommand
+};
+//# sourceMappingURL=chunk-4BJ3O4RQ.js.map