@poetic-ai/poetic 1.42.0

package/dist/chunk-XPHKYHO4.js

@@ -0,0 +1,878 @@
+import {
+  logDebug
+} from "./chunk-V72RMBM4.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  getStateDir
+} from "./chunk-UUH2RVKS.js";
+
+// src/core/process-registry.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
+
+// src/core/process-command-matcher.ts
+var CLI_COMMANDS = /* @__PURE__ */ new Set([
+  "backlog",
+  "cleanup",
+  "codex",
+  "compete",
+  "config",
+  "flywheel",
+  "doctor",
+  "monitor",
+  "next",
+  "plan",
+  "processes",
+  "run",
+  "sprint",
+  "status",
+  "task",
+  "worktree"
+]);
+var GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set(["--config", "--cwd", "--profile"]);
+function tokenizeCommand(command) {
+  return (command.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((token) => token.replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function isEntryPointToken(token) {
+  const basename = token.split("/").at(-1);
+  return basename === "poetic" || token.endsWith("/dist/entry.js") || token.endsWith("/src/cli/entry.ts");
+}
+function findPoeticCommandToken(tokens, startIndex) {
+  for (let index = startIndex; index < Math.min(tokens.length, startIndex + 8); index++) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "--") continue;
+    if (GLOBAL_OPTIONS_WITH_VALUE.has(token)) {
+      index++;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function isPoeticCliInvocation(command) {
+  const tokens = tokenizeCommand(command);
+  for (let index = 0; index < Math.min(tokens.length, 8); index++) {
+    const token = tokens[index];
+    if (token?.includes("{")) break;
+    if (!token || !isEntryPointToken(token)) continue;
+    const commandToken = findPoeticCommandToken(tokens, index + 1);
+    if (commandToken && CLI_COMMANDS.has(commandToken)) return true;
+  }
+  return false;
+}
+function isVitestWorkerInvocation(command) {
+  return command.includes("vitest/dist/workers/forks.js");
+}
+
+// src/core/process-registry.ts
+var mkdir = promisify(fs.mkdir);
+var readFile = promisify(fs.readFile);
+var writeFile = promisify(fs.writeFile);
+var unlink = promisify(fs.unlink);
+var rename = promisify(fs.rename);
+function mergeScannerObservation(existing, observed) {
+  const scannerOwned = existing.source === "scanner" && existing.type === "detected";
+  return {
+    ...existing,
+    command: observed.command || existing.command,
+    parentPid: observed.parentPid ?? existing.parentPid,
+    lastSeenAt: scannerOwned ? observed.lastSeenAt : existing.lastSeenAt,
+    health: scannerOwned ? observed.health : existing.health
+  };
+}
+function isIntentionallyDetachedProcess(entry) {
+  return entry.category === "worker" && entry.metadata?.detached === true;
+}
+function secondsSince(timestamp, now) {
+  const observedAt = new Date(timestamp).getTime();
+  const age = (now - observedAt) / 1e3;
+  return Number.isFinite(age) ? age : void 0;
+}
+function isStaleByRegistryPolicy(entry, maxAge, now = Date.now()) {
+  const lastSeenAge = secondsSince(entry.lastSeenAt, now);
+  if (lastSeenAge === void 0) return false;
+  if (isIntentionallyDetachedProcess(entry)) {
+    return entry.ttl !== void 0 && lastSeenAge > entry.ttl;
+  }
+  if (lastSeenAge > maxAge) {
+    return true;
+  }
+  if (entry.ttl !== void 0) {
+    const runtime = secondsSince(entry.startedAt, now);
+    return runtime !== void 0 && runtime > entry.ttl;
+  }
+  return false;
+}
+function normalizeCommandForIdentity(command) {
+  return (command ?? "").replace(/\s+/g, " ").trim();
+}
+function tokenizeCommandForIdentity(command) {
+  const tokens = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const identityTokens = [];
+  let skippingAnnotation = false;
+  for (const rawToken of tokens) {
+    const token = rawToken.replace(/^['"]|['"]$/g, "");
+    if (token.startsWith("(")) {
+      skippingAnnotation = !token.endsWith(")");
+      continue;
+    }
+    if (skippingAnnotation) {
+      skippingAnnotation = !token.endsWith(")");
+      continue;
+    }
+    identityTokens.push(token);
+  }
+  return identityTokens;
+}
+function commandTokenMatches(liveToken, expectedToken) {
+  if (liveToken === expectedToken) return true;
+  const liveBase = path.basename(liveToken);
+  const expectedBase = path.basename(expectedToken);
+  return liveBase === expectedBase && liveBase.length > 0 && expectedBase.length > 0;
+}
+var BACKGROUND_WORKER_DISPLAY_LABEL = "poetic compete (background worker)";
+function isBackgroundWorkerDisplayLabel(command) {
+  return normalizeCommandForIdentity(command) === BACKGROUND_WORKER_DISPLAY_LABEL;
+}
+function isNodeWorkerJsCommand(command) {
+  const tokens = tokenizeCommandForIdentity(normalizeCommandForIdentity(command));
+  const hasNode = tokens.some((token) => {
+    const base = path.basename(token);
+    return base === "node" || base === "node.exe";
+  });
+  const hasWorkerJs = tokens.some((token) => path.basename(token) === "worker.js");
+  return hasNode && hasWorkerJs;
+}
+function hasOrderedCommandTokenMatch(liveTokens, expectedTokens) {
+  if (expectedTokens.length === 0 || expectedTokens.length > liveTokens.length) {
+    return false;
+  }
+  for (let start = 0; start <= liveTokens.length - expectedTokens.length; start++) {
+    const matches = expectedTokens.every(
+      (token, offset) => commandTokenMatches(liveTokens[start + offset], token)
+    );
+    if (matches) return true;
+  }
+  return false;
+}
+function commandMatchesRegistryEntry(liveCommand, expectedCommand) {
+  const live = normalizeCommandForIdentity(liveCommand);
+  const expected = normalizeCommandForIdentity(expectedCommand);
+  if (!expected || !live) return false;
+  if (live === expected) return true;
+  if (isBackgroundWorkerDisplayLabel(expected) && isNodeWorkerJsCommand(live) || isBackgroundWorkerDisplayLabel(live) && isNodeWorkerJsCommand(expected)) {
+    return true;
+  }
+  return hasOrderedCommandTokenMatch(
+    tokenizeCommandForIdentity(live),
+    tokenizeCommandForIdentity(expected)
+  );
+}
+var RegistryStateAccessError = class extends Error {
+  operation;
+  stateDir;
+  registryPath;
+  code;
+  remediation;
+  constructor(params) {
+    const causeMessage = params.cause instanceof Error ? params.cause.message : String(params.cause);
+    const remediation = params.remediation ?? buildRegistryStateRemediation(params.code, params.stateDir);
+    const message = [
+      `Cannot ${params.operation} process registry state at ${params.stateDir}`,
+      `(${params.code}: ${causeMessage}).`,
+      remediation.join(" ")
+    ].join(" ");
+    super(message);
+    this.name = "RegistryStateAccessError";
+    this.operation = params.operation;
+    this.stateDir = params.stateDir;
+    this.registryPath = params.registryPath;
+    this.code = params.code;
+    this.remediation = remediation;
+  }
+};
+function buildRegistryStateRemediation(code, stateDir) {
+  const lockPath = path.join(stateDir, "processes.json.lock");
+  switch (code) {
+    case "EPERM":
+    case "EACCES":
+      return [
+        "The registry directory is not writable from this process (permission denied or sandbox lock).",
+        `Verify ownership and mode: ls -la ${stateDir}`,
+        "If running inside a sandboxed agent shell, export XDG_STATE_HOME to a writable temp directory."
+      ];
+    case "LOCK_TIMEOUT":
+      return [
+        "Another poetic process may be updating the shared process registry.",
+        `If no other \`poetic\` command is running, remove a stale lock: rm ${lockPath}`
+      ];
+    default:
+      return [`Registry files live under ${stateDir}.`];
+  }
+}
+function asErrnoException(error) {
+  return typeof error === "object" && error !== null ? error : void 0;
+}
+function throwRegistryStateAccessError(operation, stateDir, registryPath, error) {
+  const err = asErrnoException(error);
+  throw new RegistryStateAccessError({
+    operation,
+    stateDir,
+    registryPath,
+    code: err?.code ?? "UNKNOWN",
+    cause: error
+  });
+}
+function throwLockAcquisitionFailed(stateDir, registryPath) {
+  throw new RegistryStateAccessError({
+    operation: "acquire registry lock",
+    stateDir,
+    registryPath,
+    code: "LOCK_TIMEOUT",
+    cause: new Error(`Timed out waiting for ${path.basename(registryPath)}.lock`),
+    remediation: buildRegistryStateRemediation("LOCK_TIMEOUT", stateDir)
+  });
+}
+function getProcessRegistryStateDirectory() {
+  return getStateDir();
+}
+var registryPathMutexTails = /* @__PURE__ */ new Map();
+function __testOnlyGetRegistryPathMutexCount() {
+  return registryPathMutexTails.size;
+}
+async function runExclusiveOnRegistryPath(key, fn) {
+  const previous = registryPathMutexTails.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  registryPathMutexTails.set(key, tail);
+  await previous;
+  try {
+    return await fn();
+  } finally {
+    release();
+    if (registryPathMutexTails.get(key) === tail) {
+      registryPathMutexTails.delete(key);
+    }
+  }
+}
+var FileLock = class {
+  lockPath;
+  lockAcquired = false;
+  maxRetries = 10;
+  retryDelay = 50;
+  // ms
+  constructor(filePath) {
+    this.lockPath = `${filePath}.lock`;
+  }
+  isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    if (pid === process.pid) return true;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      const err = error;
+      return err?.code === "EPERM";
+    }
+  }
+  async acquire() {
+    await mkdir(path.dirname(this.lockPath), { recursive: true, mode: 448 });
+    for (let i = 0; i < this.maxRetries; i++) {
+      try {
+        await writeFile(this.lockPath, `${process.pid}`, { flag: "wx" });
+        this.lockAcquired = true;
+        return true;
+      } catch (error) {
+        const err = error;
+        if (err.code !== "EEXIST") {
+          throw error;
+        }
+        try {
+          const stats = await fs.promises.stat(this.lockPath);
+          const age = Date.now() - stats.mtimeMs;
+          if (age > 1e3) {
+            const lockPid = await readFile(this.lockPath, "utf8").then((value) => Number.parseInt(value.trim(), 10)).catch(() => Number.NaN);
+            if (Number.isFinite(lockPid) && this.isPidAlive(lockPid)) {
+              await new Promise((resolve) => setTimeout(resolve, this.retryDelay));
+              continue;
+            }
+            const stalePath = `${this.lockPath}.stale.${Date.now()}.${process.pid}`;
+            try {
+              await fs.promises.rename(this.lockPath, stalePath);
+              await fs.promises.unlink(stalePath);
+              continue;
+            } catch (renameError) {
+              const renameErr = renameError;
+              if (renameErr.code === "ENOENT") {
+                continue;
+              }
+            }
+          }
+        } catch (statError) {
+          const statErr = statError;
+          if (statErr.code === "ENOENT") {
+            continue;
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, this.retryDelay));
+      }
+    }
+    return false;
+  }
+  async release() {
+    if (this.lockAcquired) {
+      await unlink(this.lockPath).catch(() => {
+      });
+      this.lockAcquired = false;
+    }
+  }
+};
+var ProcessRegistry = class {
+  verbose;
+  constructor(options = {}) {
+    this.verbose = options.verbose ?? false;
+  }
+  /**
+   * Resolved per access rather than captured in the constructor. The exported
+   * singleton below is constructed at module load, so a frozen path would ignore
+   * any state root resolved after import and write to a root nothing else reads.
+   * This is the same defect the machine-id resolver had before #2556.
+   */
+  get stateDir() {
+    return getProcessRegistryStateDirectory();
+  }
+  get registryPath() {
+    return path.join(this.stateDir, "processes.json");
+  }
+  /**
+   * Initialize registry (create directory if needed)
+   */
+  async init() {
+    try {
+      await mkdir(this.stateDir, { recursive: true, mode: 448 });
+    } catch (error) {
+      throwRegistryStateAccessError("initialize", this.stateDir, this.registryPath, error);
+    }
+  }
+  /**
+   * Register a process in the shared registry
+   */
+  async register(entry) {
+    await runExclusiveOnRegistryPath(this.registryPath, async () => {
+      const lock = new FileLock(this.registryPath);
+      try {
+        if (!await lock.acquire()) {
+          throwLockAcquisitionFailed(this.stateDir, this.registryPath);
+        }
+        const registry = await this.read();
+        const fullEntry = {
+          ...entry,
+          lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const index = registry.findIndex((e) => e.pid === entry.pid);
+        if (index >= 0) {
+          const existing = registry[index];
+          registry.splice(
+            index,
+            1,
+            entry.source === "scanner" ? mergeScannerObservation(existing, fullEntry) : fullEntry
+          );
+        } else {
+          registry.push(fullEntry);
+        }
+        await this.write(registry);
+        if (this.verbose) {
+          logDebug("Registry", `Registered PID ${entry.pid} (${entry.category})`);
+        }
+      } finally {
+        await lock.release();
+      }
+    });
+  }
+  /**
+   * Unregister a process
+   */
+  async unregister(pid, expectedStartedAt) {
+    await runExclusiveOnRegistryPath(this.registryPath, async () => {
+      const lock = new FileLock(this.registryPath);
+      try {
+        if (!await lock.acquire()) {
+          throwLockAcquisitionFailed(this.stateDir, this.registryPath);
+        }
+        const registry = await this.read();
+        const index = registry.findIndex((e) => e.pid === pid);
+        if (index >= 0) {
+          const existing = registry[index];
+          if (expectedStartedAt !== void 0 && existing.startedAt !== expectedStartedAt) {
+            if (this.verbose) {
+              logDebug("Registry", `Skipped unregister for PID ${pid}: start identity changed`);
+            }
+            return;
+          }
+          registry.splice(index, 1);
+          await this.write(registry);
+          if (this.verbose) {
+            logDebug("Registry", `Unregistered PID ${pid}`);
+          }
+        }
+      } finally {
+        await lock.release();
+      }
+    });
+  }
+  /**
+   * Get all registered processes
+   */
+  async getAll() {
+    return this.read();
+  }
+  /**
+   * Get processes by task ID
+   */
+  async getByTaskId(taskId) {
+    const registry = await this.read();
+    return registry.filter((e) => e.taskId === taskId);
+  }
+  /**
+   * Get orphaned processes (PPID=1 or parent doesn't exist)
+   */
+  async getOrphaned() {
+    const registry = await this.read();
+    return registry.filter(
+      (e) => !isIntentionallyDetachedProcess(e) && (e.health === "orphaned" || this.isOrphaned(e.pid))
+    );
+  }
+  /**
+   * Get stale processes (not updated for maxAge seconds)
+   */
+  async getStale(maxAge) {
+    const registry = await this.read();
+    const now = Date.now();
+    return registry.filter((e) => isStaleByRegistryPolicy(e, maxAge, now));
+  }
+  /**
+   * Scan registry and update health status for all entries
+   */
+  async scan() {
+    return runExclusiveOnRegistryPath(this.registryPath, async () => {
+      const lock = new FileLock(this.registryPath);
+      try {
+        if (!await lock.acquire()) {
+          throwLockAcquisitionFailed(this.stateDir, this.registryPath);
+        }
+        const registry = (await this.read()).filter(
+          (entry) => this.shouldKeepEntryDuringScan(entry)
+        );
+        const result = {
+          totalProcesses: registry.length,
+          healthyCount: 0,
+          orphanedCount: 0,
+          staleCount: 0,
+          zombieCount: 0,
+          orphanedPids: []
+        };
+        for (const entry of registry) {
+          entry.health = this.checkHealth(entry);
+          switch (entry.health) {
+            case "healthy":
+              result.healthyCount++;
+              break;
+            case "orphaned":
+              result.orphanedCount++;
+              result.orphanedPids.push(entry.pid);
+              break;
+            case "stale":
+              result.staleCount++;
+              break;
+            case "zombie":
+              result.zombieCount++;
+              break;
+          }
+        }
+        await this.write(registry);
+        return result;
+      } finally {
+        await lock.release();
+      }
+    });
+  }
+  /**
+   * Cleanup processes matching criteria
+   */
+  async cleanup(options = {}) {
+    const registry = await this.read();
+    const result = {
+      attempted: 0,
+      killed: 0,
+      failed: 0,
+      pids: [],
+      errors: []
+    };
+    let targets = registry;
+    const { category, health, olderThan, pids, type } = options;
+    if (health) {
+      targets = targets.filter((e) => health.includes(e.health));
+    }
+    if (pids) {
+      const targetPids = new Set(pids);
+      targets = targets.filter((e) => targetPids.has(e.pid));
+    }
+    if (type) {
+      targets = targets.filter((e) => type.includes(e.type));
+    }
+    if (category) {
+      targets = targets.filter((e) => category.includes(e.category));
+    }
+    if (olderThan) {
+      const cutoff = Date.now() - olderThan * 1e3;
+      targets = targets.filter((e) => {
+        const started = new Date(e.startedAt).getTime();
+        return started < cutoff;
+      });
+    }
+    result.attempted = targets.length;
+    if (options.dryRun) {
+      result.pids = targets.map((e) => e.pid);
+      return result;
+    }
+    const termSent = /* @__PURE__ */ new Set();
+    for (const entry of targets) {
+      try {
+        if (!this.processIdentityMatches(entry)) {
+          result.failed++;
+          result.errors.push({
+            pid: entry.pid,
+            error: "Live process identity no longer matches registry entry; skipping kill"
+          });
+          continue;
+        }
+        process.kill(entry.pid, "SIGTERM");
+        termSent.add(entry.pid);
+        result.killed++;
+        result.pids.push(entry.pid);
+        if (this.verbose) {
+          logDebug("Registry", `Killed PID ${entry.pid} (${entry.category})`);
+        }
+      } catch (error) {
+        result.failed++;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.errors.push({
+          pid: entry.pid,
+          error: errorMessage
+        });
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    for (const entry of targets) {
+      if (!termSent.has(entry.pid)) continue;
+      if (!this.isRunning(entry.pid)) continue;
+      if (!this.processIdentityMatches(entry)) continue;
+      try {
+        process.kill(entry.pid, "SIGKILL");
+        if (this.verbose) {
+          console.log(`[Registry] Force killed PID ${entry.pid}`);
+        }
+      } catch (_error) {
+      }
+    }
+    await this.prune();
+    return result;
+  }
+  /**
+   * Remove entries for processes that no longer exist
+   */
+  async prune() {
+    await runExclusiveOnRegistryPath(this.registryPath, async () => {
+      const lock = new FileLock(this.registryPath);
+      try {
+        if (!await lock.acquire()) {
+          throwLockAcquisitionFailed(this.stateDir, this.registryPath);
+        }
+        const registry = await this.read();
+        const alive = registry.filter((entry) => this.shouldRetainLiveEntry(entry));
+        if (alive.length !== registry.length) {
+          await this.write(alive);
+          if (this.verbose) {
+            logDebug("Registry", `Pruned ${registry.length - alive.length} dead processes`);
+          }
+        }
+      } finally {
+        await lock.release();
+      }
+    });
+  }
+  /**
+   * Check if process is still running
+   */
+  isRunning(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+      return false;
+    }
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getLiveCommand(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+      return void 0;
+    }
+    try {
+      if (process.platform === "win32") {
+        const commandLine = execFileSync(
+          "powershell",
+          [
+            "-NoProfile",
+            "-Command",
+            `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
+          ],
+          {
+            timeout: 3e4,
+            stdio: ["pipe", "pipe", "ignore"],
+            encoding: "utf-8"
+          }
+        ).trim();
+        return commandLine || void 0;
+      }
+      const command = execFileSync("ps", ["-o", "command=", "-p", String(pid)], {
+        timeout: 3e4,
+        stdio: ["pipe", "pipe", "ignore"],
+        encoding: "utf-8"
+      }).trim();
+      return command || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  processIdentityStatus(entry) {
+    const liveCommand = this.getLiveCommand(entry.pid);
+    if (liveCommand === void 0) {
+      return "unknown";
+    }
+    return commandMatchesRegistryEntry(liveCommand, entry.command) ? "match" : "mismatch";
+  }
+  processIdentityMatches(entry) {
+    return this.processIdentityStatus(entry) === "match";
+  }
+  shouldRetainLiveEntry(entry) {
+    return this.isRunning(entry.pid) && this.processIdentityStatus(entry) !== "mismatch";
+  }
+  getWindowsParentPid(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+      return null;
+    }
+    const ppidStr = execFileSync(
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").ParentProcessId`
+      ],
+      {
+        timeout: 3e4,
+        stdio: ["pipe", "pipe", "ignore"],
+        encoding: "utf-8"
+      }
+    ).trim();
+    if (!ppidStr) {
+      return null;
+    }
+    const parentPid = Number.parseInt(ppidStr, 10);
+    return Number.isFinite(parentPid) ? parentPid : null;
+  }
+  /**
+   * Check if process is orphaned (PPID=1)
+   * Uses platform-specific detection:
+   * - macOS/Linux: ps command to check PPID
+   * - Windows: PowerShell/CIM query for ParentProcessId
+   */
+  isOrphaned(pid) {
+    try {
+      if (!Number.isSafeInteger(pid) || pid <= 0) {
+        return false;
+      }
+      const platform = process.platform;
+      if (platform === "win32") {
+        const parentPid = this.getWindowsParentPid(pid);
+        if (!parentPid || parentPid <= 0) {
+          return false;
+        }
+        return !this.isRunning(parentPid);
+      }
+      const ppidStr = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+        timeout: 3e4,
+        stdio: ["pipe", "pipe", "ignore"],
+        // Suppress stderr
+        encoding: "utf-8"
+      }).trim();
+      const ppid = Number.parseInt(ppidStr, 10);
+      return ppid === 1;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Determine health status of a process
+   */
+  checkHealth(entry) {
+    if (!this.isRunning(entry.pid)) {
+      return "zombie";
+    }
+    if (this.processIdentityStatus(entry) === "mismatch") {
+      return "zombie";
+    }
+    if (isIntentionallyDetachedProcess(entry)) {
+      if (isStaleByRegistryPolicy(entry, 3600)) {
+        return "stale";
+      }
+      return "healthy";
+    }
+    if (isStaleByRegistryPolicy(entry, 3600)) {
+      return "stale";
+    }
+    if (this.isOrphaned(entry.pid)) {
+      return "orphaned";
+    }
+    return "healthy";
+  }
+  isStillDetectable(entry) {
+    if (entry.source !== "scanner" || entry.type !== "detected") {
+      return true;
+    }
+    if (entry.category === "cli") {
+      return isPoeticCliInvocation(entry.command);
+    }
+    if (entry.category === "test") {
+      return isVitestWorkerInvocation(entry.command);
+    }
+    return true;
+  }
+  shouldKeepEntryDuringScan(entry) {
+    if (!this.isStillDetectable(entry)) {
+      return false;
+    }
+    if (entry.source === "scanner" && entry.type === "detected") {
+      return this.shouldRetainLiveEntry(entry);
+    }
+    return true;
+  }
+  /**
+   * Read registry from disk
+   */
+  async read() {
+    try {
+      const data = await readFile(this.registryPath, "utf-8");
+      return parseJsonWithContext(data, "process registry from disk");
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (err.code === "EPERM" || err.code === "EACCES") {
+        throwRegistryStateAccessError("read", this.stateDir, this.registryPath, error);
+      }
+      if (error instanceof SyntaxError || errorMessage.includes("JSON") || errorMessage.includes("Unexpected token")) {
+        if (this.verbose) {
+          console.warn(`Process registry corrupted, resetting: ${errorMessage}`);
+        }
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Write registry to disk
+   */
+  async write(registry) {
+    try {
+      await mkdir(this.stateDir, { recursive: true, mode: 448 });
+    } catch (error) {
+      throwRegistryStateAccessError("write", this.stateDir, this.registryPath, error);
+    }
+    const data = JSON.stringify(registry, null, 2);
+    const tmpPath = `${this.registryPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    let tmpFileCreated = false;
+    try {
+      await writeFile(tmpPath, data, { mode: 384 });
+      tmpFileCreated = true;
+      try {
+        await rename(tmpPath, this.registryPath);
+        tmpFileCreated = false;
+      } catch (error) {
+        const err = error;
+        if (err?.code === "ENOENT") {
+          tmpFileCreated = false;
+          try {
+            const retryTmpPath = `${this.registryPath}.tmp.${process.pid}.${Date.now()}.retry`;
+            await writeFile(retryTmpPath, data, { mode: 384 });
+            try {
+              await rename(retryTmpPath, this.registryPath);
+            } finally {
+              await unlink(retryTmpPath).catch(() => {
+              });
+            }
+            return;
+          } catch (_retryError) {
+            throw error;
+          }
+        }
+        if (err?.code === "EPERM" || err?.code === "EACCES") {
+          if (process.platform === "win32") {
+            await unlink(this.registryPath).catch(() => {
+            });
+            try {
+              await rename(tmpPath, this.registryPath);
+              tmpFileCreated = false;
+              return;
+            } catch {
+              await writeFile(this.registryPath, data, { mode: 384 });
+              tmpFileCreated = false;
+              return;
+            }
+          }
+          throwRegistryStateAccessError("write", this.stateDir, this.registryPath, error);
+        }
+        throw error;
+      }
+    } catch (error) {
+      const err = asErrnoException(error);
+      if (err?.code === "EPERM" || err?.code === "EACCES") {
+        throwRegistryStateAccessError("write", this.stateDir, this.registryPath, error);
+      }
+      throw error;
+    } finally {
+      if (tmpFileCreated) {
+        await unlink(tmpPath).catch(() => {
+        });
+      }
+    }
+  }
+};
+var processRegistry = new ProcessRegistry({
+  verbose: process.env.POETIC_PROCESS_REGISTRY_VERBOSE === "1"
+});
+
+export {
+  isPoeticCliInvocation,
+  isVitestWorkerInvocation,
+  RegistryStateAccessError,
+  getProcessRegistryStateDirectory,
+  __testOnlyGetRegistryPathMutexCount,
+  ProcessRegistry,
+  processRegistry
+};
+//# sourceMappingURL=chunk-XPHKYHO4.js.map