@wrongstack/tools 0.313.0 → 0.316.1

package/dist/ps-slash.js

@@ -1,1442 +1,15 @@
-// src/ps-slash.ts
-import * as os3 from "node:os";
-
-// src/process-registry-persistent.ts
-import * as fs from "node:fs/promises";
-import * as os2 from "node:os";
-import { wstackGlobalRoot } from "@wrongstack/core/utils";
-import * as path from "node:path";
-
-// src/process-registry.ts
-import { spawn } from "node:child_process";
-import * as os from "node:os";
-
-// src/circuit-breaker.ts
-var DEFAULT_MAX_CONSECUTIVE_FAILURES = 5;
-var DEFAULT_SLOW_CALL_THRESHOLD_MS = 18e4;
-var DEFAULT_MAX_SLOW_CALLS = 3;
-var DEFAULT_WINDOW_MS = 6e4;
-var DEFAULT_MAX_CALLS_PER_WINDOW = 30;
-var DEFAULT_COOLDOWN_MS = 3e4;
-var CircuitBreaker = class {
-  maxConsecutiveFailures;
-  slowCallThresholdMs;
-  maxSlowCalls;
-  windowMs;
-  maxCallsPerWindow;
-  cooldownMs;
-  state = "closed";
-  consecutiveFailures = 0;
-  window = [];
-  lastFailureAt = null;
-  lastSlowAt = null;
-  /** Timestamp when the breaker was opened (for cooldown calculation). */
-  openedAt = null;
-  /**
-   * Master enable flag. When false the breaker is bypassed: `beforeCall`
-   * always returns true and `afterCall` records nothing. The class itself
-   * defaults to enabled (so the standalone unit tests exercise tripping); the
-   * ProcessRegistry flips this off until the user opts in via `/settings`.
-   */
-  enabled = true;
-  /**
-   * Fired (best-effort) when the breaker transitions into the `open` state.
-   * The registry uses this to arm its auto kill/reset countdown.
-   */
-  onTrip;
-  /**
-   * Fired (best-effort) when the breaker returns to `closed` after having been
-   * open/half-open. The registry uses this to cancel a pending kill/reset.
-   */
-  onReset;
-  constructor(config = {}) {
-    this.maxConsecutiveFailures = config.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES;
-    this.slowCallThresholdMs = config.slowCallThresholdMs ?? DEFAULT_SLOW_CALL_THRESHOLD_MS;
-    this.maxSlowCalls = config.maxSlowCalls ?? DEFAULT_MAX_SLOW_CALLS;
-    this.windowMs = config.windowMs ?? DEFAULT_WINDOW_MS;
-    this.maxCallsPerWindow = config.maxCallsPerWindow ?? DEFAULT_MAX_CALLS_PER_WINDOW;
-    this.cooldownMs = config.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-  }
-  /** Toggle the master enable. Disabling resets to a clean `closed` state. */
-  setEnabled(enabled) {
-    if (this.enabled === enabled) return;
-    this.enabled = enabled;
-    if (!enabled) this._reset();
-  }
-  get isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Returns true if the circuit allows a new call to proceed.
-   * When false, callers should abort the tool call and return a
-   * circuit-breaker error instead of spawning a process.
-   */
-  get canProceed() {
-    if (!this.enabled) return true;
-    this._checkStateTransition();
-    return this.state !== "open";
-  }
-  /**
-   * Snapshot of the current breaker state for observability (`/kill`).
-   */
-  snapshot() {
-    this._checkStateTransition();
-    const now2 = Date.now();
-    let cooldownRemaining = null;
-    if (this.openedAt !== null && this.state === "open") {
-      const elapsed = now2 - this.openedAt;
-      cooldownRemaining = Math.max(0, this.cooldownMs - elapsed);
-    }
-    return {
-      state: this.state,
-      consecutiveFailures: this.consecutiveFailures,
-      slowCallsInWindow: this.window.filter((c) => c.slow).length,
-      callsInWindow: this.window.length,
-      windowMs: this.windowMs,
-      cooldownRemainingMs: cooldownRemaining,
-      lastFailureAt: this.lastFailureAt,
-      lastSlowAt: this.lastSlowAt
-    };
-  }
-  /**
-   * Call this BEFORE spawning a bash/exec process.
-   * Returns true if the call is allowed; false if the breaker is open.
-   * When false, callers MUST NOT spawn a process.
-   *
-   * @param bypass - If true, skip the circuit breaker check entirely.
-   *                  Use for background/fire-and-forget processes that should
-   *                  not affect breaker state.
-   */
-  beforeCall(bypass = false) {
-    if (bypass || !this.enabled) return true;
-    this._checkStateTransition();
-    if (this.state === "open") return false;
-    return true;
-  }
-  /**
-   * Call this AFTER a bash/exec process finishes (success or failure).
-   * `durationMs` is the wall-clock time the process ran.
-   * `failed` is true when the process returned a non-zero exit code or
-   * threw an exception before spawning.
-   *
-   * @param bypass - If true, do not update breaker state.
-   *                  Use for background/fire-and-forget processes.
-   */
-  afterCall(durationMs, failed, bypass = false) {
-    if (bypass || !this.enabled) return;
-    const now2 = Date.now();
-    if (this.state === "half-open") {
-      if (failed) {
-        this._trip();
-        return;
-      }
-      this._reset();
-      return;
-    }
-    this._pruneWindow(now2);
-    const slow = durationMs >= this.slowCallThresholdMs;
-    this.window.push({ at: now2, failed, slow });
-    if (failed) {
-      this.consecutiveFailures++;
-      this.lastFailureAt = now2;
-      if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
-        this._trip();
-      }
-      return;
-    }
-    this.consecutiveFailures = 0;
-    if (slow) {
-      this.lastSlowAt = now2;
-      const slowCount = this.window.filter((c) => c.slow).length;
-      if (slowCount >= this.maxSlowCalls) {
-        this._trip();
-      }
-    }
-    const callCount = this.window.length;
-    if (callCount >= this.maxCallsPerWindow) {
-      this._trip();
-    }
-  }
-  /** Force the breaker open. Used by /kill force and Ctrl+C. */
-  forceOpen() {
-    this._trip();
-  }
-  /** Force a reset to closed. Used by tests and /kill reset. */
-  forceReset() {
-    this._reset();
-  }
-  _trip() {
-    if (this.state === "open") return;
-    this.state = "open";
-    this.openedAt = Date.now();
-    this.window = [];
-    try {
-      this.onTrip?.();
-    } catch {
-    }
-  }
-  _reset() {
-    const wasRecovering = this.state !== "closed";
-    this.state = "closed";
-    this.consecutiveFailures = 0;
-    this.window = [];
-    this.openedAt = null;
-    if (wasRecovering) {
-      try {
-        this.onReset?.();
-      } catch {
-      }
-    }
-  }
-  /** Transition from open → half-open when cooldown elapses. */
-  _checkStateTransition() {
-    if (this.state !== "open" || this.openedAt === null) return;
-    const elapsed = Date.now() - this.openedAt;
-    if (elapsed >= this.cooldownMs) {
-      this.state = "half-open";
-      this.openedAt = null;
-    }
-  }
-  _pruneWindow(now2) {
-    const cutoff = now2 - this.windowMs;
-    this.window = this.window.filter((c) => c.at >= cutoff);
-  }
-};
-
-// src/process-registry.ts
-var DEFAULT_GRACE_MS = 2e3;
-var WIN32_TASKKILL_TIMEOUT_MS = 5e3;
-function killWin32Tree(pid, opts = {}) {
-  try {
-    const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    let settled = false;
-    let timeout;
-    const settle = () => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      try {
-        opts.onSettled?.();
-      } catch {
-      }
-    };
-    child.on("error", settle);
-    child.on("close", settle);
-    timeout = setTimeout(
-      () => {
-        try {
-          child.kill();
-        } catch {
-        }
-        settle();
-      },
-      Math.max(1, opts.timeoutMs ?? WIN32_TASKKILL_TIMEOUT_MS)
-    );
-    timeout.unref?.();
-    child.unref();
-    return true;
-  } catch {
-    return false;
-  }
-}
-var ProcessRegistryImpl = class {
-  processes = /* @__PURE__ */ new Map();
-  breaker;
-  /**
-   * Auto kill/reset config. When the breaker trips and `autoKillResetMs > 0`,
-   * a countdown is armed; on expiry all tracked processes are killed and the
-   * breaker is reset to closed (forced recovery). Zero means manual recovery
-   * only (`/kill reset`).
-   */
-  autoKillResetMs = 0;
-  autoKillTimer = null;
-  autoKillArmedAt = null;
-  breakerCountdownListeners = [];
-  constructor(breakerConfig) {
-    this.breaker = new CircuitBreaker(breakerConfig);
-    this.breaker.onTrip = () => this._armAutoKillReset();
-    this.breaker.onReset = () => this._cancelAutoKillReset();
-    this.breaker.setEnabled(false);
-  }
-  register(info) {
-    this.processes.set(info.pid, {
-      ...info,
-      killed: false,
-      protected: info.protected ?? false,
-      background: info.background ?? false
-    });
-  }
-  _isSafeSignalPid(pid) {
-    return Number.isInteger(pid) && pid > 1 && pid !== process.pid && pid !== process.ppid;
-  }
-  _canSignalProcessGroup(p) {
-    return os.platform() !== "win32" && p.processGroupLeader === true && this._isSafeSignalPid(p.pid) && p.child !== null && typeof p.child.pid === "number" && p.child.pid === p.pid;
-  }
-  _killChildDirect(p, signal) {
-    try {
-      if (p.child) {
-        p.child.kill(signal);
-        return;
-      }
-      if (this._isSafeSignalPid(p.pid)) process.kill(p.pid, signal);
-    } catch {
-    }
-  }
-  _killPosix(p, signal) {
-    if (this._canSignalProcessGroup(p)) {
-      try {
-        process.kill(-p.pid, signal);
-        return;
-      } catch {
-      }
-    }
-    this._killChildDirect(p, signal);
-  }
-  /** Unregister a process by PID. Called on 'close' / 'exit' events. */
-  unregister(pid) {
-    this.processes.delete(pid);
-  }
-  /** Get a single process by PID. */
-  get(pid) {
-    this._pruneStale(pid);
-    return this.processes.get(pid);
-  }
-  /** Get all tracked processes. */
-  list() {
-    this._pruneAllStale();
-    return Array.from(this.processes.values());
-  }
-  /** Get processes filtered by name (e.g. 'bash', 'exec'). */
-  byName(name) {
-    return this.list().filter((p) => p.name === name);
-  }
-  /** Get processes filtered by session. */
-  bySession(sessionId) {
-    return this.list().filter((p) => p.sessionId === sessionId);
-  }
-  /** Count of active (non-killed) processes. */
-  get activeCount() {
-    let n = 0;
-    for (const p of this.processes.values()) {
-      if (!p.killed) n++;
-    }
-    return n;
-  }
-  /** Count of active jobs explicitly launched in background mode. */
-  get activeBackgroundCount() {
-    let n = 0;
-    for (const p of this.processes.values()) {
-      if (p.background && !p.killed) n++;
-    }
-    return n;
-  }
-  /**
-   * Combined stats for observability — used by /ps and the TUI status bar.
-   */
-  stats() {
-    this._pruneAllStale();
-    return {
-      activeCount: this.activeCount,
-      backgroundCount: this.activeBackgroundCount,
-      totalCount: this.processes.size,
-      breaker: this.breaker.snapshot()
-    };
-  }
-  /**
-   * Returns true if the circuit allows a new bash/exec call to proceed.
-   * When false, callers MUST NOT spawn a process.
-   */
-  get canProceed() {
-    return this.breaker.canProceed;
-  }
-  /**
-   * Called before spawning a process. Returns true if allowed; false if
-   * the circuit breaker is open.
-   *
-   * @param bypass - If true, skip circuit breaker check (for background processes).
-   */
-  beforeCall(bypass = false) {
-    return this.breaker.beforeCall(bypass);
-  }
-  /**
-   * Called after a process finishes. `durationMs` is wall-clock time;
-   * `failed` is true for non-zero exit codes.
-   *
-   * @param bypass - If true, do not update circuit breaker state (for background processes).
-   */
-  afterCall(durationMs, failed, bypass = false) {
-    this.breaker.afterCall(durationMs, failed, bypass);
-  }
-  /** Force-open the circuit breaker (Ctrl+C, /kill force). */
-  forceBreakerOpen() {
-    this.breaker.forceOpen();
-  }
-  /** Force-reset the circuit breaker to closed (/kill reset). */
-  forceBreakerReset() {
-    this.breaker.forceReset();
-  }
-  /**
-   * Configure circuit-breaker protection at runtime. Called from `/settings`
-   * (instant, all modes) and on TUI mount (applies persisted config).
-   *
-   * - `enabled` toggles whether the breaker gates `bash`/`exec`.
-   * - `autoKillResetMs` arms the auto kill/reset countdown when the breaker
-   *   trips (0 = manual recovery only).
-   *
-   * Re-applies cleanly on every call: cancels a pending countdown when the
-   * timeout is cleared or protection disabled, and re-arms if the breaker is
-   * currently open under the new settings.
-   */
-  setBreakerConfig(cfg) {
-    if (cfg.enabled !== void 0) this.breaker.setEnabled(cfg.enabled);
-    if (cfg.autoKillResetMs !== void 0) this.autoKillResetMs = Math.max(0, cfg.autoKillResetMs);
-    if (this.autoKillResetMs <= 0) {
-      this._cancelAutoKillReset();
-      return;
-    }
-    if (this.breaker.isEnabled && this.breaker.snapshot().state === "open") {
-      this._armAutoKillReset();
-    }
-  }
-  /**
-   * Live countdown to the next auto kill/reset, or null when nothing is armed.
-   * The TUI polls this on a 1s tick while armed so the statusline decrements.
-   */
-  getBreakerCountdown() {
-    if (this.autoKillArmedAt === null || this.autoKillResetMs <= 0) return null;
-    const elapsed = Date.now() - this.autoKillArmedAt;
-    return {
-      remainingMs: Math.max(0, this.autoKillResetMs - elapsed),
-      totalMs: this.autoKillResetMs
-    };
-  }
-  /**
-   * Subscribe to countdown arm/cancel events. Returns an unsubscribe function.
-   * Use {@link getBreakerCountdown} for the live ticking value between events.
-   */
-  onBreakerCountdownChange(listener) {
-    this.breakerCountdownListeners.push(listener);
-    return () => {
-      this.breakerCountdownListeners = this.breakerCountdownListeners.filter((l) => l !== listener);
-    };
-  }
-  _emitBreakerCountdown() {
-    const snap = this.getBreakerCountdown();
-    for (const l of this.breakerCountdownListeners) {
-      try {
-        l(snap);
-      } catch {
-      }
-    }
-  }
-  /**
-   * Arm the auto kill/reset countdown. Idempotent: re-arming resets the window
-   * (a fresh trip after a failed half-open probe restarts the clock). No-op
-   * when protection is off or no timeout is configured.
-   */
-  _armAutoKillReset() {
-    if (this.autoKillResetMs <= 0 || !this.breaker.isEnabled) return;
-    this._clearAutoKillTimer();
-    this.autoKillArmedAt = Date.now();
-    this.autoKillTimer = setTimeout(() => {
-      this.autoKillTimer = null;
-      this.autoKillArmedAt = null;
-      this.killAll({ force: false, preserveBackground: true });
-      this.breaker.forceReset();
-      this._emitBreakerCountdown();
-    }, this.autoKillResetMs);
-    this.autoKillTimer.unref?.();
-    this._emitBreakerCountdown();
-  }
-  _cancelAutoKillReset() {
-    const wasArmed = this.autoKillArmedAt !== null;
-    this._clearAutoKillTimer();
-    if (wasArmed) {
-      this.autoKillArmedAt = null;
-      this._emitBreakerCountdown();
-    }
-  }
-  _clearAutoKillTimer() {
-    if (this.autoKillTimer !== null) {
-      clearTimeout(this.autoKillTimer);
-      this.autoKillTimer = null;
-    }
-  }
-  /** Kill a single process by PID.
-   *
-   *  On POSIX: sends SIGTERM to the *process group* (-pid) so that
-   *  runaway grandchild processes (`sleep 9999 & disown`) are also killed.
-   *  After `graceMs` a SIGKILL is sent if the process hasn't exited.
-   *
-   *  On Windows: `child.kill()` maps to TerminateProcess — process groups
-   *  are not meaningfully supported. A second `force=true` call sends
-   *  SIGKILL (which maps to TerminateProcess again — the distinction is
-   *  in the exit code, not the signal).
-   *
-   *  Returns true if the process was found and kill was attempted.
-   */
-  kill(pid, opts = {}) {
-    this._pruneStale(pid);
-    const p = this.processes.get(pid);
-    if (!p) return false;
-    if (p.killed && opts.force !== true) return true;
-    if (p.protected && opts.includeProtected !== true) return false;
-    if (opts.preserveBackground && p.background) return false;
-    const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-    const isWin = os.platform() === "win32";
-    if (isWin) {
-      const liveRealChild = p.child === null || p.child.exitCode === null && typeof p.child.pid === "number";
-      const directFallback = () => {
-        if (p.child && p.child.exitCode === null) {
-          try {
-            p.child.kill("SIGKILL");
-          } catch {
-          }
-        }
-      };
-      if (liveRealChild && killWin32Tree(pid, {
-        timeoutMs: Math.max(graceMs, WIN32_TASKKILL_TIMEOUT_MS),
-        onSettled: directFallback
-      })) {
-      } else {
-        this._killChildDirect(p, force ? "SIGKILL" : "SIGTERM");
-      }
-      p.killed = true;
-      return true;
-    }
-    try {
-      if (force) {
-        this._killPosix(p, "SIGKILL");
-      } else {
-        this._killPosix(p, "SIGTERM");
-        const timer = setTimeout(() => {
-          if (this.processes.has(pid) && !p.child?.killed) {
-            this._killPosix(p, "SIGKILL");
-          }
-        }, graceMs);
-        timer.unref?.();
-      }
-    } catch {
-    }
-    p.killed = true;
-    return true;
-  }
-  /**
-   * Kill all tracked processes.
-   * Returns the PIDs that were kill()ed.
-   */
-  killAll(opts = {}) {
-    const pids = Array.from(this.processes.keys());
-    const killed = [];
-    const includeProtected = opts.includeProtected === true;
-    for (const pid of pids) {
-      const p = this.processes.get(pid);
-      if (!p) continue;
-      if (p.protected && !includeProtected) continue;
-      if (opts.preserveBackground && p.background) continue;
-      if (this.kill(pid, opts)) killed.push(pid);
-    }
-    return killed;
-  }
-  /**
-   * Kill all processes for a specific session.
-   * Returns the PIDs that were kill()ed.
-   */
-  killSession(sessionId, opts = {}) {
-    const pids = this.bySession(sessionId).map((p) => p.pid);
-    const killed = [];
-    for (const pid of pids) {
-      if (this.kill(pid, opts)) killed.push(pid);
-    }
-    return killed;
-  }
-  /**
-   * Check whether a tracked process entry is stale — the child has exited
-   * (exitCode !== null) AND it's been in the registry long enough that the
-   * OS may have reused the PID for a new, unrelated process.
-   *
-   * P3 #24 (before-release.md): on POSIX, PIDs are reused after process
-   * exit. If a tracked process exits but its 'close' event hasn't fired yet
-   * (or was missed), the registry still holds the entry. A new process
-   * gets the same PID, and PID-based lookups (get, kill, shouldBlockKill)
-   * may incorrectly protect or target the wrong process.
-   *
-   * The 60s threshold is conservative — the OS typically waits much longer
-   * before reusing a PID, but we want to clean up before that becomes a risk.
-   */
-  _isStaleEntry(entry) {
-    if (entry.child === null) {
-      if (Date.now() - entry.startedAt <= 6e4) return false;
-      if (os.platform() === "win32") return false;
-      try {
-        process.kill(entry.pid, 0);
-        return false;
-      } catch (err) {
-        return err.code !== "EPERM";
-      }
-    }
-    return entry.child.exitCode !== null && Date.now() - entry.startedAt > 6e4;
-  }
-  /**
-   * Remove a stale entry for a specific PID before any PID-based lookup.
-   * This prevents PID reuse from causing the registry to act on a dead
-   * process that has been replaced by a new one with the same PID.
-   */
-  _pruneStale(pid) {
-    const entry = this.processes.get(pid);
-    if (entry && this._isStaleEntry(entry)) {
-      this.processes.delete(pid);
-    }
-  }
-  /**
-   * Remove every stale entry, not just one PID. `list()`/`stats()` — the
-   * surfaces the TUI status bar and `/ps` poll — must prune too: a child
-   * whose 'close' event never fires (e.g. Windows grandchildren holding stdio
-   * open) would otherwise linger in the registry until someone looks up its
-   * exact PID, and PID reuse meanwhile makes `get()`/`kill()` target the
-   * wrong process. RAM-leak audit 2026-07-31, MEDIUM.
-   */
-  _pruneAllStale() {
-    for (const [pid, entry] of this.processes) {
-      if (this._isStaleEntry(entry)) this.processes.delete(pid);
-    }
-  }
-};
-var _registry;
-function getProcessRegistry() {
-  if (!_registry) {
-    _registry = new ProcessRegistryImpl();
-  }
-  return _registry;
-}
-
-// src/process-registry-persistent.ts
-var REGISTRY_FILE = "process-registry.json";
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function emitStructuredLog(level, event, message, error) {
-  const payload = {
-    level,
-    event,
-    message,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (error !== void 0) {
-    payload.error = toErrorMessage(error);
-  }
-  console.log(JSON.stringify(payload));
-}
-var HEARTBEAT_INTERVAL_MS = 5e3;
-var STALE_THRESHOLD_MS = 3e4;
-var LOCK_STALE_MS = 3e4;
-var LOCKFILE = ".process-registry.lock";
-function generateInstanceId() {
-  const hostname3 = os2.hostname();
-  const pid = process.pid;
-  const random = Math.random().toString(36).slice(2, 8);
-  return `${hostname3}:${pid}:${random}`;
-}
-function isNodeError(err) {
-  return typeof err === "object" && err !== null && "code" in err;
-}
-async function acquireLock(lockfilePath, timeoutMs = 5e3) {
-  const start = Date.now();
-  const pidStr = String(process.pid);
-  const hostStr = os2.hostname();
-  try {
-    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
-  } catch {
-  }
-  while (Date.now() - start < timeoutMs) {
-    try {
-      await fs.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });
-      return async () => {
-        try {
-          await fs.unlink(lockfilePath);
-        } catch {
-        }
-      };
-    } catch (err) {
-      if (isNodeError(err) && err.code === "EEXIST") {
-        try {
-          const content = await fs.readFile(lockfilePath, "utf-8");
-          const parts = content.split(":");
-          const lockPid = parseInt(parts[0] ?? "0", 10);
-          const lockTs = Number(parts[parts.length - 1]);
-          const staleByAge = Number.isFinite(lockTs) && Date.now() - lockTs > LOCK_STALE_MS;
-          let holderDead = false;
-          if (process.platform !== "win32" && Number.isFinite(lockPid) && lockPid > 0) {
-            try {
-              process.kill(lockPid, 0);
-            } catch {
-              holderDead = true;
-            }
-          }
-          if (holderDead || staleByAge) {
-            await fs.unlink(lockfilePath).catch(() => {
-            });
-            continue;
-          }
-        } catch {
-          await fs.unlink(lockfilePath).catch(() => {
-          });
-          continue;
-        }
-        await new Promise((r) => setTimeout(r, 100));
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
-}
-function freshRegistryData() {
-  return {
-    version: 1,
-    instances: /* @__PURE__ */ new Map(),
-    protectedPatterns: ["wrongstack", "node"],
-    lastCleanup: Date.now()
-  };
-}
-async function readRegistryFile(filePath) {
-  let content;
-  try {
-    content = await fs.readFile(filePath, "utf-8");
-  } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") return freshRegistryData();
-    throw err;
-  }
-  try {
-    const parsed = JSON.parse(content);
-    if (!parsed || typeof parsed !== "object") return freshRegistryData();
-    const base = freshRegistryData();
-    return {
-      version: 1,
-      instances: Array.isArray(parsed.instances) ? new Map(parsed.instances) : base.instances,
-      protectedPatterns: Array.isArray(parsed.protectedPatterns) ? parsed.protectedPatterns : base.protectedPatterns,
-      lastCleanup: typeof parsed.lastCleanup === "number" ? parsed.lastCleanup : base.lastCleanup
-    };
-  } catch {
-    return freshRegistryData();
-  }
-}
-async function writeRegistryFile(filePath, data) {
-  const tmpPath = `${filePath}.tmp.${process.pid}`;
-  const content = JSON.stringify(
-    data,
-    (_k, v) => {
-      if (v instanceof Map) {
-        return Array.from(v.entries());
-      }
-      return v;
-    },
-    2
-  );
-  await fs.writeFile(tmpPath, content, "utf-8");
-  await fs.rename(tmpPath, filePath);
-}
-var PersistentProcessRegistry = class {
-  instanceId;
-  registryPath;
-  lockPath;
-  baseRegistry;
-  heartbeatInterval = null;
-  cleanupInterval = null;
-  heartbeatRunning = false;
-  cleanupRunning = false;
-  isShuttingDown = false;
-  onProcessExit = () => {
-    this.runInBackground(
-      this.syncToPersistent(),
-      "process_registry.exit_sync_failed",
-      "PersistentProcessRegistry: exit sync failed"
-    );
-  };
-  constructor(baseRegistry) {
-    this.instanceId = generateInstanceId();
-    const globalRoot = wstackGlobalRoot();
-    this.registryPath = path.join(globalRoot, REGISTRY_FILE);
-    this.lockPath = path.join(globalRoot, LOCKFILE);
-    this.baseRegistry = baseRegistry ?? getProcessRegistry();
-    this.ensureDirectory().catch((err) => {
-      emitStructuredLog(
-        "warn",
-        "process_registry.dir_create_failed",
-        "PersistentProcessRegistry: failed to create .wrongstack directory",
-        err
-      );
-    });
-  }
-  async ensureDirectory() {
-    const dir = path.dirname(this.registryPath);
-    try {
-      await fs.mkdir(dir, { recursive: true });
-    } catch (err) {
-      if (!isNodeError(err) || err.code !== "EEXIST") throw err;
-    }
-  }
-  runInBackground(operation, event, message) {
-    void operation.catch((err) => {
-      emitStructuredLog("warn", event, message, err);
-    });
-  }
-  /**
-   * Start the heartbeat and periodic cleanup tasks.
-   */
-  start() {
-    if (this.heartbeatInterval) return;
-    this.isShuttingDown = false;
-    this.heartbeat();
-    this.heartbeatInterval = setInterval(() => {
-      this.heartbeat();
-    }, HEARTBEAT_INTERVAL_MS);
-    this.heartbeatInterval.unref?.();
-    this.cleanupInterval = setInterval(() => {
-      this.cleanup();
-    }, STALE_THRESHOLD_MS);
-    this.cleanupInterval.unref?.();
-    this.registerMainProcess();
-    process.on("exit", this.onProcessExit);
-  }
-  /**
-   * Stop the heartbeat and clean up.
-   */
-  stop() {
-    this.isShuttingDown = true;
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    process.off("exit", this.onProcessExit);
-    this.runInBackground(
-      this.syncToPersistent(),
-      "process_registry.stop_sync_failed",
-      "PersistentProcessRegistry: stop sync failed"
-    );
-  }
-  /**
-   * Register the main WrongStack process as protected.
-   */
-  registerMainProcess() {
-    const mainPid = process.pid;
-    this.runInBackground(
-      this.updatePersistentEntry({
-        pid: mainPid,
-        name: "wrongstack-main",
-        command: process.argv.slice(0, 3).join(" "),
-        startedAt: Date.now(),
-        lastHeartbeat: Date.now(),
-        instanceId: this.instanceId,
-        hostname: os2.hostname(),
-        protected: true,
-        spawnMode: "main",
-        parentPid: process.ppid,
-        platform: process.platform
-      }),
-      "process_registry.main_register_failed",
-      "PersistentProcessRegistry: failed to register main process"
-    );
-  }
-  /**
-   * Register a spawned child process with the persistent registry.
-   */
-  registerChildProcess(pid, name, command, sessionId, spawnMode = "spawn") {
-    const entry = {
-      pid,
-      name,
-      command,
-      startedAt: Date.now(),
-      lastHeartbeat: Date.now(),
-      instanceId: this.instanceId,
-      hostname: os2.hostname(),
-      protected: true,
-      // All WrongStack child processes are protected by default
-      spawnMode,
-      parentPid: process.pid,
-      platform: process.platform
-    };
-    if (sessionId) {
-      entry.sessionId = sessionId;
-    }
-    this.runInBackground(
-      this.updatePersistentEntry(entry),
-      "process_registry.child_register_failed",
-      "PersistentProcessRegistry: failed to register child process"
-    );
-  }
-  /**
-   * Update or add an entry in the persistent registry.
-   */
-  async updatePersistentEntry(entry) {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      data.instances.set(String(entry.pid), entry);
-      this.baseRegistry.register({
-        pid: entry.pid,
-        name: entry.name,
-        command: entry.command,
-        startedAt: entry.startedAt,
-        sessionId: entry.sessionId,
-        protected: entry.protected,
-        child: null
-      });
-      await writeRegistryFile(this.registryPath, data);
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Unregister a process from the persistent registry.
-   */
-  async unregister(pid) {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      data.instances.delete(String(pid));
-      await writeRegistryFile(this.registryPath, data);
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Send heartbeat to mark all this instance's processes as alive.
-   */
-  heartbeat() {
-    if (this.isShuttingDown || this.heartbeatRunning) return;
-    this.heartbeatRunning = true;
-    void this.syncToPersistent().catch((err) => {
-      emitStructuredLog(
-        "warn",
-        "process_registry.heartbeat_failed",
-        "PersistentProcessRegistry: heartbeat failed",
-        err
-      );
-    }).finally(() => {
-      this.heartbeatRunning = false;
-    });
-  }
-  cleanup() {
-    if (this.isShuttingDown || this.cleanupRunning) return;
-    this.cleanupRunning = true;
-    void this.cleanupStaleEntries().catch((err) => {
-      emitStructuredLog(
-        "warn",
-        "process_registry.periodic_cleanup_failed",
-        "PersistentProcessRegistry: periodic cleanup failed",
-        err
-      );
-    }).finally(() => {
-      this.cleanupRunning = false;
-    });
-  }
-  /**
-   * Sync this instance's processes to the persistent registry.
-   */
-  async syncToPersistent() {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      const now2 = Date.now();
-      const updatedInstances = /* @__PURE__ */ new Map();
-      for (const [_pidStr, entry] of data.instances) {
-        if (entry.instanceId === this.instanceId) {
-          entry.lastHeartbeat = now2;
-        }
-        if (entry.instanceId === this.instanceId || now2 - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
-          updatedInstances.set(_pidStr, entry);
-        }
-      }
-      data.instances = updatedInstances;
-      data.lastCleanup = now2;
-      await writeRegistryFile(this.registryPath, data);
-    } catch (err) {
-      emitStructuredLog(
-        "warn",
-        "process_registry.sync_failed",
-        "PersistentProcessRegistry: sync failed",
-        err
-      );
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Remove entries for processes that are no longer running.
-   */
-  async cleanupStaleEntries() {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      const now2 = Date.now();
-      const stalePids = [];
-      for (const [_pidStr, entry] of data.instances) {
-        const age = now2 - entry.lastHeartbeat;
-        if (age > STALE_THRESHOLD_MS) {
-          try {
-            if (process.platform !== "win32") {
-              process.kill(entry.pid, 0);
-            } else {
-              emitStructuredLog(
-                "debug",
-                "process_registry.stale_pid_check",
-                `PersistentProcessRegistry: checking stale pid ${entry.pid} (${age}ms old)`
-              );
-            }
-          } catch {
-            stalePids.push(_pidStr);
-          }
-        }
-      }
-      if (stalePids.length > 0) {
-        for (const pidStr of stalePids) {
-          data.instances.delete(pidStr);
-        }
-        await writeRegistryFile(this.registryPath, data);
-      }
-    } catch (err) {
-      emitStructuredLog(
-        "warn",
-        "process_registry.cleanup_failed",
-        "PersistentProcessRegistry: cleanup failed",
-        err
-      );
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Check if a PID belongs to a WrongStack process and should be protected.
-   */
-  async isProtectedPid(pid) {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      const entry = data.instances.get(String(pid));
-      if (!entry) return false;
-      if (Date.now() - entry.lastHeartbeat > STALE_THRESHOLD_MS) {
-        return false;
-      }
-      return entry.protected;
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Get all protected PIDs from all WrongStack instances.
-   */
-  async getAllProtectedPids() {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      const now2 = Date.now();
-      const protectedPids = [];
-      for (const [_pidStr, entry] of data.instances) {
-        if (entry.protected && now2 - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
-          protectedPids.push(entry.pid);
-        }
-      }
-      return protectedPids;
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Get complete status of all tracked processes across all instances.
-   */
-  async getGlobalStatus() {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      const now2 = Date.now();
-      const instances = /* @__PURE__ */ new Map();
-      let protectedCount = 0;
-      let staleCount = 0;
-      for (const [_pidStr, entry] of data.instances) {
-        const instanceEntries = instances.get(entry.instanceId) ?? [];
-        instanceEntries.push(entry);
-        instances.set(entry.instanceId, instanceEntries);
-        if (entry.protected) protectedCount++;
-        if (now2 - entry.lastHeartbeat > STALE_THRESHOLD_MS) staleCount++;
-      }
-      return {
-        instances,
-        totalProcesses: data.instances.size,
-        protectedCount,
-        staleCount
-      };
-    } finally {
-      await release();
-    }
-  }
-  /**
-   * Get the instance ID for this process.
-   */
-  getInstanceId() {
-    return this.instanceId;
-  }
-  /**
-   * Check if a kill command should be blocked.
-   * Returns true if the kill should be blocked (target is a WrongStack process).
-   */
-  async shouldBlockKill(pid) {
-    const protectedPids = await this.getAllProtectedPids();
-    return protectedPids.includes(pid);
-  }
-  /**
-   * Add a pattern-based protection rule.
-   * Processes whose command matches any protected pattern are protected.
-   */
-  async addProtectedPattern(pattern) {
-    const release = await acquireLock(this.lockPath);
-    try {
-      const data = await readRegistryFile(this.registryPath);
-      if (!data.protectedPatterns.includes(pattern)) {
-        data.protectedPatterns.push(pattern);
-        await writeRegistryFile(this.registryPath, data);
-      }
-    } finally {
-      await release();
-    }
-  }
-};
-var _persistentRegistry;
-function getPersistentProcessRegistry() {
-  if (!_persistentRegistry) {
-    _persistentRegistry = new PersistentProcessRegistry();
-  }
-  return _persistentRegistry;
-}
-
-// src/ps-slash.ts
-var IDLE_THRESHOLD_MS = 2 * 6e4;
-var STALE_THRESHOLD_MS2 = 5 * 6e4;
-function now() {
-  return Date.now();
-}
-function formatAge(ms) {
-  if (ms < 1e3) return "0s";
-  const seconds = Math.floor(ms / 1e3);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours}h`;
-  const days = Math.floor(hours / 24);
-  return `${days}d`;
-}
-function formatUptime(ms) {
-  return formatAge(ms);
-}
-function matchGlob(pattern, value) {
-  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  try {
-    const regex = new RegExp(`^${regexPattern}$`, "i");
-    return regex.test(value);
-  } catch {
-    return false;
-  }
-}
-async function listInstances(options = {}) {
-  const { includeStale = false, hostname: hostname3, status } = options;
-  const timestamp = now();
-  const registry = getPersistentProcessRegistry();
-  const globalStatus = await registry.getGlobalStatus();
-  const instances = [];
-  const instanceMap = globalStatus.instances;
-  for (const [instanceId, processes] of instanceMap) {
-    if (processes.length === 0) continue;
-    const mainProc = processes.find((p) => p.spawnMode === "main");
-    const firstProc = processes.at(0);
-    const mainPid = mainProc?.pid ?? firstProc?.pid ?? 0;
-    const hostname_ = firstProc?.hostname ?? os3.hostname();
-    const startedAt = Math.min(...processes.map((p) => p.startedAt));
-    const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
-    const age = timestamp - lastActivity;
-    let instanceStatus = "stale";
-    if (age < IDLE_THRESHOLD_MS) instanceStatus = "active";
-    else if (age < STALE_THRESHOLD_MS2) instanceStatus = "idle";
-    const sessionIds = /* @__PURE__ */ new Set();
-    for (const proc of processes) {
-      if (proc.sessionId) {
-        sessionIds.add(proc.sessionId);
-      }
-    }
-    if (!includeStale && instanceStatus === "stale") continue;
-    if (hostname3 && !matchGlob(hostname3, hostname_)) continue;
-    if (status && status !== "all" && instanceStatus !== status) continue;
-    instances.push({
-      instanceId,
-      hostname: hostname_,
-      mainPid,
-      startedAt,
-      lastActivity,
-      status: instanceStatus,
-      processCount: processes.length,
-      processes,
-      sessionIds
-    });
-  }
-  instances.sort((a, b) => b.lastActivity - a.lastActivity);
-  return instances;
-}
-async function getInstanceCount() {
-  const instances = await listInstances({ includeStale: true });
-  const byHostname = /* @__PURE__ */ new Map();
-  let active = 0;
-  let idle = 0;
-  let stale = 0;
-  for (const inst of instances) {
-    const current = byHostname.get(inst.hostname) ?? 0;
-    byHostname.set(inst.hostname, current + 1);
-    switch (inst.status) {
-      case "active":
-        active++;
-        break;
-      case "idle":
-        idle++;
-        break;
-      case "stale":
-        stale++;
-        break;
-    }
-  }
-  return {
-    total: instances.length,
-    active,
-    idle,
-    stale,
-    byHostname
-  };
-}
-async function getGlobalProcessStatus() {
-  const timestamp = now();
-  const registry = getPersistentProcessRegistry();
-  const globalStatus = await registry.getGlobalStatus();
-  const instances = await listInstances({ includeStale: true });
-  const localInstanceId = registry.getInstanceId();
-  const localInstance = instances.find((i) => i.instanceId === localInstanceId);
-  let localProtectedCount = 0;
-  if (localInstance) {
-    localProtectedCount = localInstance.processes.filter((p) => p.protected).length;
-  }
-  let activeInstanceCount = 0;
-  for (const inst of instances) {
-    if (inst.status === "active") activeInstanceCount++;
-  }
-  return {
-    localInstance: localInstance ? {
-      instanceId: localInstance.instanceId,
-      mainPid: localInstance.mainPid,
-      protectedCount: localProtectedCount,
-      platform: process.platform,
-      hostname: localInstance.hostname,
-      uptime: timestamp - localInstance.startedAt
-    } : {
-      instanceId: localInstanceId,
-      mainPid: process.pid,
-      protectedCount: 0,
-      platform: process.platform,
-      hostname: os3.hostname(),
-      uptime: 0
-    },
-    allInstances: instances.map((inst) => ({
-      instanceId: inst.instanceId,
-      hostname: inst.hostname,
-      mainPid: inst.mainPid,
-      processes: inst.processes,
-      startedAt: inst.startedAt,
-      lastActivity: inst.lastActivity
-    })),
-    summary: {
-      totalProcesses: globalStatus.totalProcesses,
-      protectedCount: globalStatus.protectedCount,
-      staleCount: globalStatus.staleCount,
-      instanceCount: instances.length,
-      activeInstanceCount
-    },
-    timestamp
-  };
-}
-async function formatGlobalStatus() {
-  const status = await getGlobalProcessStatus();
-  const lines = [];
-  lines.push("=== WrongStack Global Process Status ===");
-  lines.push(`Updated: ${new Date(status.timestamp).toISOString()}`);
-  lines.push("");
-  lines.push("Summary:");
-  lines.push(`  Total processes: ${status.summary.totalProcesses}`);
-  lines.push(`  Protected: ${status.summary.protectedCount}`);
-  lines.push(`  Stale entries: ${status.summary.staleCount}`);
-  lines.push(
-    `  Instances: ${status.summary.instanceCount} (${status.summary.activeInstanceCount} active)`
-  );
-  lines.push("");
-  lines.push(`This instance (${status.localInstance.instanceId}):`);
-  lines.push(`  Main PID: ${status.localInstance.mainPid}`);
-  lines.push(`  Protected processes: ${status.localInstance.protectedCount}`);
-  lines.push(`  Platform: ${status.localInstance.platform} (${status.localInstance.hostname})`);
-  lines.push(`  Uptime: ${formatUptime(status.localInstance.uptime)}`);
-  lines.push("");
-  for (const instance of status.allInstances) {
-    if (instance.instanceId === status.localInstance.instanceId) continue;
-    const age = Math.round((status.timestamp - instance.lastActivity) / 1e3);
-    lines.push(`Instance ${instance.instanceId} (${instance.hostname}):`);
-    for (const proc of instance.processes) {
-      const procAge = formatAge(status.timestamp - proc.startedAt);
-      const heartbeatAge = formatAge(status.timestamp - proc.lastHeartbeat);
-      const protected_ = proc.protected ? "[P]" : "   ";
-      lines.push(
-        `  ${protected_} ${String(proc.pid).padStart(6)}  ${proc.name.padEnd(20)} started ${procAge.padStart(8)}  heartbeat ${heartbeatAge.padStart(6)}  ${proc.spawnMode}`
-      );
-    }
-    lines.push(`  Last activity: ${age}s ago`);
-    lines.push("");
-  }
-  lines.push("Legend:");
-  lines.push("  [P] = Protected (cannot be killed via bash)");
-  lines.push("  main = Main WrongStack process");
-  lines.push("  spawn = Spawned child process");
-  lines.push("  fork = Forked process (e.g., worker threads)");
-  return lines.join("\n");
-}
-async function formatInstanceList(options = {}) {
-  const instances = await listInstances(options);
-  const count = await getInstanceCount();
-  const lines = [];
-  lines.push("=== WrongStack Instances ===");
-  lines.push(
-    `Total: ${count.total} instances (${count.active} active, ${count.idle} idle, ${count.stale} stale)`
-  );
-  lines.push("");
-  if (count.byHostname.size > 1) {
-    lines.push("By hostname:");
-    for (const [host, num] of count.byHostname) {
-      lines.push(`  ${host}: ${num} instance${num !== 1 ? "s" : ""}`);
-    }
-    lines.push("");
-  }
-  if (instances.length === 0) {
-    lines.push("No instances found matching the filter.");
-    return lines.join("\n");
-  }
-  lines.push("INSTANCES:");
-  lines.push(
-    "  " + [
-      "STATUS".padEnd(7),
-      "HOSTNAME".padEnd(16),
-      "MAIN PID".padEnd(9),
-      "PROCS".padEnd(6),
-      "SESSIONS".padEnd(8),
-      "UPTIME".padEnd(8),
-      "LAST ACTIVITY"
-    ].join("  ")
-  );
-  lines.push("  " + "-".repeat(80));
-  for (const inst of instances) {
-    const uptime = formatAge(Date.now() - inst.startedAt);
-    const lastAct = formatAge(Date.now() - inst.lastActivity);
-    const statusIcon = inst.status === "active" ? "[*]" : inst.status === "idle" ? "[-]" : "[ ]";
-    lines.push(
-      "  " + [
-        `${statusIcon} ${inst.status}`.padEnd(7),
-        inst.hostname.padEnd(16),
-        String(inst.mainPid).padEnd(9),
-        String(inst.processCount).padEnd(6),
-        String(inst.sessionIds.size).padEnd(8),
-        uptime.padEnd(8),
-        `${lastAct} ago`
-      ].join("  ")
-    );
-  }
-  lines.push("");
-  lines.push("Use /ps full for detailed process listing per instance.");
-  return lines.join("\n");
-}
-async function formatInstanceSummary() {
-  const count = await getInstanceCount();
-  const instances = await listInstances({ includeStale: false });
-  if (instances.length === 0) {
-    return "No active WrongStack instances.";
-  }
-  const lines = [];
-  lines.push(`${count.total} instance${count.total !== 1 ? "s" : ""}`);
-  const byStatus = /* @__PURE__ */ new Map();
-  for (const inst of instances) {
-    byStatus.set(inst.status, (byStatus.get(inst.status) ?? 0) + 1);
-  }
-  const parts = [];
-  if (byStatus.get("active")) parts.push(`${byStatus.get("active")} active`);
-  if (byStatus.get("idle")) parts.push(`${byStatus.get("idle")} idle`);
-  if (byStatus.get("stale")) parts.push(`${byStatus.get("stale")} stale`);
-  lines.push(`(${parts.join(", ")})`);
-  const totalProcs = instances.reduce((sum, inst) => sum + inst.processCount, 0);
-  lines.push(`${totalProcs} total processes`);
-  return lines.join(" ");
-}
-function createGlobalPsSlashCommand() {
-  return {
-    name: "ps",
-    description: "List all WrongStack instances and their processes",
-    async handler(input) {
-      try {
-        const trimmed = input.trim();
-        const parts = trimmed.split(/\s+/);
-        const sub = parts[0]?.toLowerCase() ?? "";
-        if (sub === "list" || sub === "ls" || sub === "") {
-          const output = await formatInstanceList();
-          return { message: output };
-        }
-        if (sub === "summary" || sub === "sum") {
-          const output = await formatInstanceSummary();
-          return { message: output };
-        }
-        if (sub === "full" || sub === "detail") {
-          const output = await formatGlobalStatus();
-          return { message: output };
-        }
-        if (sub === "count" || sub === "num") {
-          const count = await getInstanceCount();
-          return {
-            message: `${count.total} instance${count.total !== 1 ? "s" : ""} (${count.active} active, ${count.idle} idle, ${count.stale} stale)`
-          };
-        }
-        if (sub === "hostname" || sub === "host") {
-          const pattern = parts.slice(1).join(" ");
-          if (!pattern) {
-            return { message: "Usage: /ps hostname <pattern> (e.g., /ps hostname workstation*)" };
-          }
-          const output = await formatInstanceList({ hostname: pattern });
-          return { message: output };
-        }
-        if (sub === "status" || sub === "state") {
-          const filterStatus = parts[1]?.toLowerCase();
-          if (!["active", "idle", "stale", "all"].includes(filterStatus ?? "")) {
-            return { message: "Usage: /ps status <active|idle|stale|all>" };
-          }
-          const output = await formatInstanceList({
-            status: filterStatus
-          });
-          return { message: output };
-        }
-        return {
-          message: "Usage: /ps [list|summary|count|full|hostname <pattern>|status <state>]"
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { message: `Error getting process status: ${message}` };
-      }
-    }
-  };
-}
+import {
+  createGlobalPsSlashCommand,
+  formatGlobalStatus,
+  formatInstanceList,
+  formatInstanceSummary,
+  getGlobalProcessStatus,
+  getInstanceCount,
+  listInstances
+} from "./chunk-42BHI7TN.js";
+import "./chunk-NKNOBUBU.js";
+import "./chunk-3PVYQFRQ.js";
+import "./chunk-HFXSNKCV.js";
 export {
   createGlobalPsSlashCommand,
   formatGlobalStatus,