@poetic-ai/poetic 1.42.0

package/dist/environment-YS45U5ZI.js

@@ -0,0 +1,81 @@
+import {
+  _resetClaudeFallbackConfigDir,
+  _resetRestrictedEnvCache,
+  applyClaudeReadOnlyChatEnv,
+  ensureClaudeConfigDir,
+  isRestrictedEnvironment
+} from "./chunk-LKRAR3IH.js";
+import "./chunk-CKNX3TTP.js";
+import "./chunk-FYOILAN5.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import "./chunk-YMX76IOS.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  _resetClaudeFallbackConfigDir,
+  _resetRestrictedEnvCache,
+  applyClaudeReadOnlyChatEnv,
+  ensureClaudeConfigDir,
+  isRestrictedEnvironment
+};
+//# sourceMappingURL=environment-YS45U5ZI.js.map

package/dist/error-parser-core-PPZ36A4S.js

@@ -0,0 +1,50 @@
+import {
+  DEFAULT_ERROR_PATTERNS,
+  DEFAULT_RETRY_DELAYS,
+  ERROR_EXIT_CODES,
+  createAuthError,
+  createCapacityError,
+  createNetworkError,
+  createRateLimitError,
+  createTimeoutError,
+  createUnknownError,
+  createValidationError,
+  extractRetryAfter,
+  formatParsedError,
+  getRetryDelay,
+  isAuthError,
+  isCapacityError,
+  isContextOverflowError,
+  isNetworkError,
+  isPermanentFailure,
+  isRateLimitError,
+  isTimeoutError,
+  isValidationError,
+  matchesErrorPattern
+} from "./chunk-2YFUIER7.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DEFAULT_ERROR_PATTERNS,
+  DEFAULT_RETRY_DELAYS,
+  ERROR_EXIT_CODES,
+  createAuthError,
+  createCapacityError,
+  createNetworkError,
+  createRateLimitError,
+  createTimeoutError,
+  createUnknownError,
+  createValidationError,
+  extractRetryAfter,
+  formatParsedError,
+  getRetryDelay,
+  isAuthError,
+  isCapacityError,
+  isContextOverflowError,
+  isNetworkError,
+  isPermanentFailure,
+  isRateLimitError,
+  isTimeoutError,
+  isValidationError,
+  matchesErrorPattern
+};
+//# sourceMappingURL=error-parser-core-PPZ36A4S.js.map

package/dist/escalation-ladder-MKTCEGSA.js

@@ -0,0 +1,130 @@
+import {
+  clampToMaxSafeMode,
+  getProviderModeConstraints
+} from "./chunk-UR2IBGIM.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-LPITVM7M.js";
+import {
+  POETIC_ESCALATION_ENABLED,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/providers/shared/escalation-ladder.ts
+var RAW_PROVIDER_LADDERS = {
+  claude: [
+    {
+      mode: "passthrough",
+      transport: "cli",
+      rationale: "Initial: CLI passthrough (native parity)"
+    }
+  ],
+  cursor: [
+    { mode: "enhanced", transport: "cli", rationale: "Initial: CLI enhanced (Cursor default)" }
+  ],
+  codex: [{ mode: "passthrough", transport: "cli", rationale: "Initial: CLI passthrough" }],
+  copilot: [
+    { mode: "passthrough", transport: "cli", rationale: "Initial: CLI passthrough" },
+    { mode: "enhanced", transport: "cli", rationale: "Escalation: CLI enhanced" }
+  ],
+  gemini: [
+    { mode: "enhanced", transport: "cli", rationale: "Initial: CLI enhanced (Gemini default)" }
+  ],
+  opencode: [{ mode: "passthrough", transport: "cli", rationale: "Initial: CLI passthrough" }]
+};
+function buildEscalationLadder(provider, startMode, startTransport) {
+  const normalized = provider.toLowerCase();
+  const constraints = getProviderModeConstraints(normalized);
+  const raw = RAW_PROVIDER_LADDERS[normalized] ?? [
+    {
+      mode: constraints.defaultMode,
+      transport: "cli",
+      rationale: `Initial: CLI ${constraints.defaultMode}`
+    }
+  ];
+  const steps = raw.map((step) => {
+    const { mode, clamped } = clampToMaxSafeMode(step.mode, constraints);
+    return {
+      workspaceMode: mode,
+      transport: step.transport,
+      rationale: clamped ? `${step.rationale} (clamped to ${mode})` : step.rationale
+    };
+  }).filter((step, idx, arr) => {
+    if (idx === 0) return true;
+    const prev = arr[idx - 1];
+    if (!prev) return true;
+    return step.workspaceMode !== prev.workspaceMode || step.transport !== prev.transport;
+  });
+  if (steps.length > 0 && (startMode || startTransport)) {
+    const first = steps[0];
+    if (!first) throw new Error("Expected at least one step");
+    const effectiveMode = startMode ?? first.workspaceMode;
+    const clampedStart = clampToMaxSafeMode(effectiveMode, constraints);
+    steps[0] = {
+      workspaceMode: clampedStart.mode,
+      transport: startTransport ?? first.transport,
+      rationale: clampedStart.clamped ? `${first.rationale} (start override clamped to ${clampedStart.mode})` : first.rationale
+    };
+  }
+  return {
+    provider: normalized,
+    steps,
+    currentStep: 0
+  };
+}
+function detectNoProgress(editsRequired, filesModified, exitCode) {
+  if (!filesModified) return false;
+  return editsRequired && filesModified.length === 0 && exitCode === 0;
+}
+function shouldEscalate(triggers, ladder, budget) {
+  if (triggers.terminalError) {
+    return {
+      shouldEscalate: false,
+      rationale: `Terminal error detected: ${triggers.errorDetail ?? "unspecified"}; not escalating`
+    };
+  }
+  const nextIndex = ladder.currentStep + 1;
+  if (nextIndex >= ladder.steps.length) {
+    return {
+      shouldEscalate: false,
+      rationale: `No more escalation steps for ${ladder.provider} (${ladder.steps.length} total)`
+    };
+  }
+  if (budget && !budget.hasRemaining()) {
+    return {
+      shouldEscalate: false,
+      rationale: "Retry budget exhausted; cannot escalate"
+    };
+  }
+  if (triggers.noProgress) {
+    return {
+      shouldEscalate: true,
+      nextStep: ladder.steps[nextIndex],
+      rationale: "No progress detected (edits required but no files modified); escalating"
+    };
+  }
+  if (triggers.nonZeroExit && !triggers.terminalError) {
+    return {
+      shouldEscalate: true,
+      nextStep: ladder.steps[nextIndex],
+      rationale: `Non-zero exit (${triggers.errorDetail ?? "unknown"}); escalating`
+    };
+  }
+  return {
+    shouldEscalate: false,
+    rationale: "No escalation trigger matched"
+  };
+}
+function isEscalationEnabled() {
+  return readEnv(POETIC_ESCALATION_ENABLED).value ?? false;
+}
+export {
+  buildEscalationLadder,
+  detectNoProgress,
+  isEscalationEnabled,
+  shouldEscalate
+};
+//# sourceMappingURL=escalation-ladder-MKTCEGSA.js.map

package/dist/evaluation-context-KV4GZNN7.js

@@ -0,0 +1,35 @@
+import {
+  buildJudgeEvaluationContext,
+  collectChangedFilesFromVariants,
+  formatVerificationProvenanceForPrompt,
+  resolveJudgeEvaluationContext
+} from "./chunk-N4VTRA7K.js";
+import "./chunk-ACDIT7OP.js";
+import "./chunk-CFBIG37O.js";
+import "./chunk-KT6VHSPF.js";
+import "./chunk-Q5XIXSHX.js";
+import "./chunk-7T7RUJI7.js";
+import "./chunk-JOSYEJKY.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  buildJudgeEvaluationContext,
+  collectChangedFilesFromVariants,
+  formatVerificationProvenanceForPrompt,
+  resolveJudgeEvaluationContext
+};
+//# sourceMappingURL=evaluation-context-KV4GZNN7.js.map

package/dist/evidence-plan-resolver-GBSYSAPX.js

@@ -0,0 +1,85 @@
+import {
+  detectProjectCapabilities
+} from "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/loop/evidence-plan-resolver.ts
+function uniqueCommands(commands) {
+  return Array.from(new Set(commands));
+}
+function detectProjectVerificationCommands(cwd) {
+  const capabilities = detectProjectCapabilities(cwd);
+  const commands = uniqueCommands([
+    ...capabilities.verification.typecheck,
+    ...capabilities.verification.test,
+    ...capabilities.verification.lint,
+    ...capabilities.verification.build
+  ]);
+  if (commands.length === 0) return null;
+  return {
+    id: "project-capabilities",
+    description: `Repo-declared verification commands for ${capabilities.languages.join(", ")}`,
+    commands,
+    deterministic: true,
+    source: "repo-declared",
+    rationale: [
+      `Detected project capabilities: ${capabilities.languages.join(", ")}`,
+      "Selected commands declared by repo scripts/config or implied by detected project manifests."
+    ]
+  };
+}
+function getDefaultFallback() {
+  return {
+    id: "default-fallback",
+    description: "No repo-declared deterministic validation available",
+    commands: [],
+    deterministic: true,
+    source: "default",
+    rationale: [
+      "No repo-declared deterministic validation found; not guessing toolchain commands.",
+      "To enable deterministic validation, add repo verifiers (package.json scripts, Makefile targets) or configure autoloop.gates/verify.commands."
+    ]
+  };
+}
+async function resolveEvidencePlan(analysis, _prompt, cwd = process.cwd()) {
+  const surfaces = [];
+  const rationale = [];
+  const capabilitySurface = detectProjectVerificationCommands(cwd);
+  if (capabilitySurface) {
+    surfaces.push(capabilitySurface);
+    rationale.push("Using project-capability verification commands");
+  }
+  const isFallback = surfaces.length === 0;
+  if (isFallback) {
+    surfaces.push(getDefaultFallback());
+    rationale.push(
+      `No repo-declared validation found; skipping inferred commands for domain "${analysis.domain}".`
+    );
+  }
+  const estimatedDurationMs = surfaces.reduce((total, s) => total + s.commands.length * 5e3, 0);
+  return {
+    surfaces,
+    rationale,
+    isFallback,
+    estimatedDurationMs
+  };
+}
+async function resolveEvidencePlanFromPrompt(input) {
+  const analysis = { domain: inferEvidenceDomain(input.prompt) };
+  return resolveEvidencePlan(analysis, input.prompt, input.cwd ?? process.cwd());
+}
+function inferEvidenceDomain(prompt) {
+  const normalized = prompt.toLowerCase();
+  if (/\b(?:doc|docs|documentation|readme|markdown)\b/.test(normalized)) return "documentation";
+  if (/\b(?:infra|terraform|kubernetes|docker|deploy|ci|pipeline)\b/.test(normalized)) {
+    return "infrastructure";
+  }
+  return "code";
+}
+export {
+  resolveEvidencePlan,
+  resolveEvidencePlanFromPrompt
+};
+//# sourceMappingURL=evidence-plan-resolver-GBSYSAPX.js.map

package/dist/execution-data-writer-3ODTBDLH.js

@@ -0,0 +1,53 @@
+import {
+  VariantExecutionWriteError,
+  resolveLocalBuilderId,
+  resolveProjectId,
+  updateCompetitionV2,
+  writeCompetitionStart,
+  writeJudgeRunV2,
+  writeVariantExecutionsV2
+} from "./chunk-MHLCBZJB.js";
+import "./chunk-XUXVDPSZ.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  VariantExecutionWriteError,
+  resolveLocalBuilderId,
+  resolveProjectId,
+  updateCompetitionV2,
+  writeCompetitionStart,
+  writeJudgeRunV2,
+  writeVariantExecutionsV2
+};
+//# sourceMappingURL=execution-data-writer-3ODTBDLH.js.map

package/dist/execution-policy-applier-ZHD3DCF3.js

@@ -0,0 +1,31 @@
+import {
+  EXECUTION_POLICY_STAMP_VERSION,
+  applyExecutionPolicy,
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged
+} from "./chunk-PIKLF7BM.js";
+import "./chunk-UH3JJSHK.js";
+import "./chunk-FC23CTXV.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  EXECUTION_POLICY_STAMP_VERSION,
+  applyExecutionPolicy,
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged
+};
+//# sourceMappingURL=execution-policy-applier-ZHD3DCF3.js.map

package/dist/execution-preflight-Z4Y64V3I.js

@@ -0,0 +1,209 @@
+import {
+  OrphanDetector
+} from "./chunk-CJC6GZ46.js";
+import {
+  ProcessRegistry
+} from "./chunk-XPHKYHO4.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-4CUY7AFY.js";
+import "./chunk-S2VQCZO4.js";
+import {
+  logDebug
+} from "./chunk-V72RMBM4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import {
+  collectActiveRunPids
+} from "./chunk-I5WRT7ZR.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  resolveWorktreeBase
+} from "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/safety/execution-preflight.ts
+import { tmpdir } from "os";
+import { resolve } from "path";
+function getActiveRunSentinelRoots() {
+  const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      resolveWorktreeBase(),
+      resolve(tmpdir(), "poetic-worktrees"),
+      resolve(repoRoot, ".poetic/labs")
+    ])
+  );
+}
+async function cleanupRegistryTargets(registry, cleanupTargets, verbose) {
+  try {
+    const cleanupResult = await registry.cleanup({
+      health: ["orphaned", "zombie", "stale"],
+      pids: cleanupTargets.map((entry) => entry.pid),
+      dryRun: false
+    });
+    return {
+      attempted: cleanupResult.attempted,
+      killed: cleanupResult.killed,
+      failed: cleanupResult.failed,
+      errors: cleanupResult.errors
+    };
+  } catch (error) {
+    if (verbose) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logDebug(
+        "ExecutionPreflight",
+        `Registry cleanup error; retrying targets individually (non-fatal): ${msg}`
+      );
+    }
+  }
+  const summary = {
+    attempted: 0,
+    killed: 0,
+    failed: 0,
+    errors: []
+  };
+  for (const entry of cleanupTargets) {
+    try {
+      const cleanupResult = await registry.cleanup({
+        health: ["orphaned", "zombie", "stale"],
+        pids: [entry.pid],
+        dryRun: false
+      });
+      summary.attempted += cleanupResult.attempted;
+      summary.killed += cleanupResult.killed;
+      summary.failed += cleanupResult.failed;
+      summary.errors.push(...cleanupResult.errors);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      summary.attempted += 1;
+      summary.failed += 1;
+      summary.errors.push({ pid: entry.pid, error: msg });
+      if (verbose) {
+        logDebug(
+          "ExecutionPreflight",
+          `Registry cleanup error for PID ${entry.pid} (non-fatal): ${msg}`
+        );
+      }
+    }
+  }
+  return summary;
+}
+function formatExecutionPreflightWarning(result) {
+  const reason = result?.orphanCleanupDisabledReason;
+  if (!reason) return void 0;
+  return `Warning: process registry unavailable (${reason}); orphan cleanup was skipped. Stray provider processes may persist; run 'poetic processes --health' to inspect.`;
+}
+async function runExecutionPreflight(options = {}) {
+  const { verbose = false, dryRun = false } = options;
+  const result = {
+    orphansKilled: 0,
+    registryOrphaned: 0,
+    registryZombie: 0,
+    registryStale: 0,
+    registryCleanupAttempted: 0,
+    registryCleaned: 0,
+    registryCleanupFailed: 0,
+    registryCleanupErrors: [],
+    registrySkippedActiveRunPids: [],
+    tmuxSessionsReaped: 0,
+    skipped: false
+  };
+  if (process.env.POETIC_SKIP_EXECUTION_PREFLIGHT === "1") {
+    result.skipped = true;
+    if (verbose) {
+      logDebug("ExecutionPreflight", "Skipped (POETIC_SKIP_EXECUTION_PREFLIGHT=1)");
+    }
+    return result;
+  }
+  const registry = new ProcessRegistry({ verbose: false });
+  let cleanupTargets = [];
+  let protectedDetachedPids = [];
+  let protectedActiveRunPids = /* @__PURE__ */ new Set();
+  let registryEntries = [];
+  let registryProtectionLoaded = false;
+  try {
+    await registry.init();
+    await registry.scan();
+    const entries = await registry.getAll();
+    registryEntries = entries;
+    const candidateCleanupTargets = entries.filter(
+      (entry) => entry.health === "orphaned" || entry.health === "zombie" || entry.health === "stale" && entry.ttl !== void 0
+    );
+    protectedActiveRunPids = await collectActiveRunPids(getActiveRunSentinelRoots());
+    cleanupTargets = candidateCleanupTargets.filter(
+      (entry) => !protectedActiveRunPids.has(entry.pid)
+    );
+    result.registrySkippedActiveRunPids = candidateCleanupTargets.filter((entry) => protectedActiveRunPids.has(entry.pid)).map((entry) => entry.pid);
+    result.registryOrphaned = cleanupTargets.filter((entry) => entry.health === "orphaned").length;
+    result.registryStale = cleanupTargets.filter((entry) => entry.health === "stale").length;
+    result.registryZombie = cleanupTargets.filter((entry) => entry.health === "zombie").length;
+    protectedDetachedPids = entries.filter(
+      (entry) => entry.category === "worker" && entry.health !== "zombie" && entry.metadata?.detached === true
+    ).map((entry) => entry.pid);
+    registryProtectionLoaded = true;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (verbose) {
+      logDebug("ExecutionPreflight", `Registry scan error before orphan scan (non-fatal): ${msg}`);
+    }
+    result.orphanCleanupDisabledReason = msg;
+  }
+  const detector = new OrphanDetector({
+    kill: !dryRun && registryProtectionLoaded,
+    verbose: false,
+    protectedPids: Array.from(/* @__PURE__ */ new Set([...protectedDetachedPids, ...protectedActiveRunPids])),
+    // Zombie means the live process no longer matches the registry identity
+    // (including PID reuse). Those PIDs are not ownership evidence for
+    // OrphanDetector; registry cleanup below still accounts for them.
+    ownedPids: registryEntries.filter((entry) => entry.health !== "zombie").map((entry) => entry.pid)
+  });
+  try {
+    const detectedOrKilled = await detector.detectAndClean();
+    result.orphansKilled = !dryRun && registryProtectionLoaded ? detectedOrKilled : 0;
+  } catch (error) {
+    if (verbose) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logDebug("ExecutionPreflight", `OrphanDetector error (non-fatal): ${msg}`);
+    }
+  }
+  try {
+    const reapedTmuxSessions = await reapOrphanedTmuxSessions({ dryRun });
+    result.tmuxSessionsReaped = reapedTmuxSessions.length;
+  } catch (error) {
+    if (verbose) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logDebug("ExecutionPreflight", `Tmux session reap error (non-fatal): ${msg}`);
+    }
+  }
+  const hasTargets = cleanupTargets.length > 0;
+  if (hasTargets && !dryRun) {
+    const cleanupSummary = await cleanupRegistryTargets(registry, cleanupTargets, verbose);
+    result.registryCleanupAttempted = cleanupSummary.attempted;
+    result.registryCleaned = cleanupSummary.killed;
+    result.registryCleanupFailed = cleanupSummary.failed;
+    result.registryCleanupErrors = cleanupSummary.errors;
+  }
+  const totalCleaned = result.orphansKilled + result.registryCleaned + result.tmuxSessionsReaped;
+  if (verbose && totalCleaned > 0) {
+    logDebug(
+      "ExecutionPreflight",
+      `Cleaned ${totalCleaned} process/session item(s) (${result.orphansKilled} orphans, ${result.registryCleaned} registry entries, ${result.tmuxSessionsReaped} tmux sessions)`
+    );
+  }
+  return result;
+}
+export {
+  formatExecutionPreflightWarning,
+  runExecutionPreflight
+};
+//# sourceMappingURL=execution-preflight-Z4Y64V3I.js.map