@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-WMWQEFLN.js

@@ -0,0 +1,2177 @@
+import {
+  cleanupStaleGitIndexLock
+} from "./chunk-OMX5VL43.js";
+import {
+  classifyTask
+} from "./chunk-JHP7OT6K.js";
+import {
+  analyzeTask
+} from "./chunk-EKLUBDBQ.js";
+import {
+  parsePromptSpec
+} from "./chunk-INJ3SS6A.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-B7PYTV72.js";
+import {
+  calculateGuidanceTier,
+  generatePromptInjection,
+  hasUnfilledMarkers,
+  validateTaskSpec
+} from "./chunk-UAPHFJPN.js";
+import {
+  MemoryGuardian,
+  killAllFallbackTrackedSubprocesses
+} from "./chunk-633XZ7UF.js";
+import {
+  signalProcessGroup
+} from "./chunk-6CB3KJRY.js";
+import {
+  isDependencyManifestPath,
+  isGeneratedLockfilePath,
+  manifestKind
+} from "./chunk-D4VJFCGZ.js";
+import {
+  isProjectConfigPath
+} from "./chunk-RPIMAMV7.js";
+import {
+  MAX_CONSECUTIVE_PROGRESS_FAILURES,
+  PROGRESSIVE_CHECK_INTERVALS_MS
+} from "./chunk-RWQQIKIC.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/process-lifecycle-manager.ts
+import { execFileSync } from "child_process";
+import { promises as fs, readFileSync } from "fs";
+import chalk from "chalk";
+var PROGRESS_EARLY_TERMINATION_COMMANDS = /* @__PURE__ */ new Set([
+  // Provider CLIs can be legitimately quiet for long stretches while waiting on model output.
+  // Early termination on "no progress" causes false SIGTERM kills.
+  "claude",
+  "gemini",
+  "cursor-agent",
+  "codex",
+  "opencode",
+  "copilot"
+]);
+var PROVIDER_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  "claude",
+  "cursor",
+  "cursor-agent",
+  "codex",
+  "gemini",
+  "opencode",
+  "copilot"
+]);
+var HEAVY_TEST_COMMAND_TOKENS = /* @__PURE__ */ new Set(["vitest", "jest", "mocha", "ava", "tap", "test"]);
+var HEAVY_BUILD_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  "build",
+  "typecheck",
+  "tsc",
+  "tsup",
+  "webpack",
+  "vite"
+]);
+var MERGE_CLEANUP_COMMAND_TOKENS = /* @__PURE__ */ new Set(["merge", "cleanup", "git"]);
+var LIGHT_CLI_COMMAND_TOKENS = /* @__PURE__ */ new Set(["gh", "npm", "node"]);
+var FORCE_KILL_GRACE_MS = 5e3;
+var GROUP_EXIT_CONFIRMATION_MS = 1e3;
+var GROUP_EXIT_POLL_MS = 50;
+var CHILD_EXIT_CONFIRMATION_MS = 1e3;
+var CHILD_EXIT_POLL_MS = 50;
+function normalizeCommandToken(raw) {
+  const unquoted = raw.trim().replace(/^['"]|['"]$/g, "");
+  const normalizedSeparators = unquoted.replaceAll("\\", "/");
+  const base = normalizedSeparators.split("/").pop() ?? normalizedSeparators;
+  const lower = base.toLowerCase();
+  if (lower.endsWith(".exe") || lower.endsWith(".cmd")) {
+    return lower.slice(0, -4);
+  }
+  return lower;
+}
+function tokenizeCommand(command) {
+  if (typeof command !== "string" || command.trim().length === 0) {
+    return [];
+  }
+  return command.split(/\s+/).map(normalizeCommandToken).filter((token) => token.length > 0 && !token.startsWith("-"));
+}
+function hasCommandToken(tokens, candidates) {
+  return tokens.some((token) => candidates.has(token));
+}
+function inferMemoryWorkloadClassFromMetadata(metadata) {
+  const tokens = tokenizeCommand(metadata?.command);
+  const provider = typeof metadata?.provider === "string" ? metadata.provider.trim() : "";
+  if (provider.length > 0 || hasCommandToken(tokens, PROVIDER_COMMAND_TOKENS)) {
+    return "provider-cli";
+  }
+  if (hasCommandToken(tokens, HEAVY_TEST_COMMAND_TOKENS)) {
+    return "heavy-test";
+  }
+  if (hasCommandToken(tokens, HEAVY_BUILD_COMMAND_TOKENS)) {
+    return "heavy-build";
+  }
+  if (hasCommandToken(tokens, MERGE_CLEANUP_COMMAND_TOKENS)) {
+    return "merge-cleanup";
+  }
+  if (hasCommandToken(tokens, LIGHT_CLI_COMMAND_TOKENS)) {
+    return "light-cli";
+  }
+  return "unknown";
+}
+var ProcessLifecycleManager = class _ProcessLifecycleManager {
+  static instance = null;
+  processes = /* @__PURE__ */ new Map();
+  config;
+  isShuttingDown = false;
+  progressMonitoringTimers = /* @__PURE__ */ new Map();
+  // Process type statistics
+  stats = {
+    total: 0,
+    running: 0,
+    completed: 0,
+    failed: 0,
+    terminated: 0,
+    timeout: 0
+  };
+  // Resource monitoring
+  resourceMonitoringTimer;
+  totalCpuUsage = 0;
+  resourcesKilledByMonitor = 0;
+  // Track the child handle and start identity together. A bare PID is not an
+  // ownership proof because the operating system may recycle it.
+  trackedChildProcesses = /* @__PURE__ */ new Map();
+  activeForcedKillTimers = /* @__PURE__ */ new Set();
+  // Automatic cleanup timer for old processes
+  oldProcessCleanupTimer;
+  // Configuration for automatic cleanup
+  OLD_PROCESS_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+  // 2 hours
+  CLEANUP_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+  // Check every 5 minutes
+  // Retention window for terminal (completed/failed/terminated/timeout) registrations.
+  // Generous so callers can still inspect recent results, but bounded so long-lived
+  // managers do not retain completionPromise/childProcess refs and resource histories forever.
+  TERMINAL_REGISTRATION_RETENTION_MS = 2 * 60 * 60 * 1e3;
+  // 2 hours
+  // Count of terminal registrations evicted from the map after their retention
+  // window. Folded into stats.total so cumulative totals survive eviction.
+  evictedTerminalRegistrations = 0;
+  constructor(config = {}) {
+    this.config = {
+      defaultTimeoutMinutes: config.defaultTimeoutMinutes ?? 60,
+      cleanupOnTermination: config.cleanupOnTermination ?? false,
+      verbose: config.verbose ?? false,
+      maxConcurrentProcesses: config.maxConcurrentProcesses ?? 50,
+      verificationIntervalMs: config.verificationIntervalMs ?? 5e3,
+      resourceMonitoringIntervalMs: config.resourceMonitoringIntervalMs ?? 6e4,
+      maxCpuPercentage: config.maxCpuPercentage ?? 1e3,
+      maxProcessesWarning: config.maxProcessesWarning ?? 50,
+      progressiveCheckIntervals: config.progressiveCheckIntervals ?? PROGRESSIVE_CHECK_INTERVALS_MS,
+      maxConsecutiveProgressFailures: config.maxConsecutiveProgressFailures ?? MAX_CONSECUTIVE_PROGRESS_FAILURES
+    };
+    this.startResourceMonitoring();
+    this.startOldProcessCleanup();
+    if (this.config.verbose) {
+      console.log(chalk.gray("ProcessLifecycleManager initialized"));
+      console.log(chalk.gray(`   Default timeout: ${this.config.defaultTimeoutMinutes} minutes`));
+      console.log(chalk.gray(`   Max concurrent: ${this.config.maxConcurrentProcesses}`));
+      console.log(chalk.gray(`   Verification interval: ${this.config.verificationIntervalMs}ms`));
+      console.log(
+        chalk.gray(`   Resource monitoring: ${this.config.resourceMonitoringIntervalMs}ms`)
+      );
+      console.log(chalk.gray(`   Max CPU: ${this.config.maxCpuPercentage}%`));
+      console.log(
+        chalk.gray(`   Old process timeout: ${this.OLD_PROCESS_TIMEOUT_MS / 1e3 / 60 / 60} hours`)
+      );
+      console.log(
+        chalk.gray(
+          `   Progressive checks: ${this.config.progressiveCheckIntervals.map((i) => `${i / 1e3 / 60}m`).join(", ")}`
+        )
+      );
+      console.log(
+        chalk.gray(`   Max consecutive failures: ${this.config.maxConsecutiveProgressFailures}`)
+      );
+    }
+  }
+  shouldSkipEarlyTerminationOnNoProgress(registration) {
+    const commandTokens = tokenizeCommand(registration.metadata?.command);
+    return commandTokens.some((token) => PROGRESS_EARLY_TERMINATION_COMMANDS.has(token)) || inferMemoryWorkloadClassFromMetadata(registration.metadata) === "provider-cli";
+  }
+  async cleanupStaleGitIndexLockForRegistration(registration) {
+    const candidates = [
+      registration.metadata?.cwd,
+      registration.metadata?.worktreePath,
+      registration.metadata?.repoRoot,
+      registration.metadata?.workingDirectory
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    for (const cwd of candidates) {
+      try {
+        const cleaned = await cleanupStaleGitIndexLock(cwd);
+        if (cleaned) {
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get singleton instance of ProcessLifecycleManager
+   * Creates a new instance if one doesn't exist
+   */
+  static getInstance(config) {
+    if (!_ProcessLifecycleManager.instance) {
+      _ProcessLifecycleManager.instance = new _ProcessLifecycleManager(config);
+    }
+    return _ProcessLifecycleManager.instance;
+  }
+  /**
+   * Reset the singleton instance (primarily for testing)
+   */
+  static resetInstance() {
+    if (_ProcessLifecycleManager.instance) {
+      _ProcessLifecycleManager.instance.close().catch(console.error);
+      _ProcessLifecycleManager.instance = null;
+    }
+  }
+  /**
+   * Register a new process using object-style parameters (preferred for new code)
+   *
+   * @param options - Process registration options
+   * @returns Promise that resolves to unique process ID
+   */
+  async registerProcessWithOptions(options) {
+    const processId = `PLM-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    await this.registerProcess(
+      processId,
+      options.processType ?? "local",
+      options.completionPromise,
+      options.verificationFn,
+      options.terminateFn,
+      options.timeoutMs,
+      options.metadata,
+      options.progressCallback,
+      options.childProcess,
+      options.ownsProcessGroup
+    );
+    return processId;
+  }
+  /**
+   * Register a new process for lifecycle management
+   *
+   * @param processId - Unique process identifier
+   * @param processType - Process execution location
+   * @param completionPromise - Promise that resolves when process completes
+   * @param verificationFn - Function to verify actual completion
+   * @param terminateFn - Function to force terminate the process
+   * @param timeoutMs - Timeout in milliseconds
+   * @param metadata - Additional metadata
+   * @param progressCallback - Optional callback to check if process is making progress
+   * @param childProcess - Optional child process reference for group kills
+   * @returns Process registration record
+   */
+  async registerProcess(processId, processType, completionPromise, verificationFn, terminateFn, timeoutMs, metadata, progressCallback, childProcess, ownsProcessGroup = false) {
+    if (this.processes.size >= this.config.maxConcurrentProcesses) {
+      throw new Error(
+        `Maximum concurrent processes (${this.config.maxConcurrentProcesses}) reached`
+      );
+    }
+    if (this.processes.has(processId)) {
+      throw new Error(`Process ${processId} already registered`);
+    }
+    const resolvedTimeoutMs = timeoutMs ?? this.config.defaultTimeoutMinutes * 60 * 1e3;
+    const timeoutEnabled = resolvedTimeoutMs > 0;
+    const actualTimeoutMs = timeoutEnabled ? resolvedTimeoutMs : 0;
+    const childPid = childProcess?.pid;
+    const processStartIdentity = childPid ? this.readProcessStartIdentity(childPid) : void 0;
+    const registration = {
+      processId,
+      processType,
+      childProcess,
+      ownsProcessGroup,
+      processStartIdentity,
+      completionPromise,
+      verificationFn,
+      terminateFn,
+      progressCallback,
+      createdAt: /* @__PURE__ */ new Date(),
+      timeoutMs: actualTimeoutMs,
+      timeoutEnabled,
+      status: "running",
+      metadata,
+      consecutiveProgressFailures: 0,
+      consecutiveFrequentProgressFailures: 0
+    };
+    this.processes.set(processId, registration);
+    this.trackChildProcess(registration);
+    this.updateStats();
+    if (this.config.verbose) {
+      console.log(chalk.cyan(`Registered process: ${processId} (${processType})`));
+      console.log(chalk.gray(`   Timeout: ${actualTimeoutMs / 1e3}s`));
+      if (metadata) {
+        console.log(chalk.gray(`   Metadata: ${JSON.stringify(metadata, null, 2)}`));
+      }
+    }
+    this.monitorProcess(processId);
+    return registration;
+  }
+  /**
+   * Unregister a process from lifecycle management
+   * Cleans up timers and removes from tracking
+   *
+   * @param processId - Process ID to unregister
+   */
+  unregisterProcess(processId) {
+    const registration = this.processes.get(processId);
+    if (registration) {
+      this.untrackRegistrationChild(registration);
+      this.clearHardTimeout(registration);
+      const progressTimer = this.progressMonitoringTimers.get(processId);
+      if (progressTimer) {
+        this.progressMonitoringTimers.delete(processId);
+        clearInterval(progressTimer);
+      }
+      if (registration.forceKillTimeoutHandle) {
+        this.clearForcedKillTimer(registration.forceKillTimeoutHandle);
+        registration.forceKillTimeoutHandle = void 0;
+      }
+      if (registration.progressCheckTimers) {
+        for (const timer of registration.progressCheckTimers) {
+          clearTimeout(timer);
+        }
+        registration.progressCheckTimers = void 0;
+      }
+      this.processes.delete(processId);
+      this.updateStats();
+      if (this.config.verbose) {
+        console.log(chalk.gray(`Unregistered process: ${processId}`));
+      }
+    }
+  }
+  clearForcedKillTimer(timer) {
+    clearTimeout(timer);
+    this.activeForcedKillTimers.delete(timer);
+  }
+  /** Test seam around the OS process-start identity probe. */
+  readProcessStartIdentity(pid) {
+    if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return void 0;
+    try {
+      if (process.platform === "linux") {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const closeParen = stat.lastIndexOf(")");
+        if (closeParen < 0) return void 0;
+        const fieldsAfterCommand = stat.slice(closeParen + 2).trim().split(/\s+/);
+        const startTicks = fieldsAfterCommand[19];
+        return startTicks ? `proc-start-ticks:${startTicks}` : void 0;
+      }
+      const value = execFileSync(
+        "ps",
+        ["-o", "lstart=", "-o", "ppid=", "-o", "command=", "-p", String(pid)],
+        {
+          timeout: 2e3,
+          stdio: ["ignore", "pipe", "ignore"],
+          encoding: "utf8"
+        }
+      ).trim();
+      return value.length > 0 ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  readProcessGroupMembers(processGroupId) {
+    if (!Number.isInteger(processGroupId) || processGroupId <= 0 || process.platform === "win32") {
+      return void 0;
+    }
+    try {
+      const output = execFileSync("ps", ["-axo", "pid=,pgid="], {
+        timeout: 2e3,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8"
+      });
+      const members = /* @__PURE__ */ new Map();
+      for (const line of output.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)$/);
+        if (!match || Number(match[2]) !== processGroupId) continue;
+        const pid = Number(match[1]);
+        const identity = this.readProcessStartIdentity(pid);
+        if (!identity) return void 0;
+        members.set(pid, identity);
+      }
+      return members;
+    } catch {
+      return void 0;
+    }
+  }
+  childHasExited(childProcess) {
+    return childProcess.exitCode != null || childProcess.signalCode != null;
+  }
+  probePidLiveness(pid) {
+    try {
+      process.kill(pid, 0);
+      return "alive";
+    } catch (error) {
+      if (this.isNoSuchProcessError(error)) return "gone";
+      if (error?.code === "EPERM") return "alive";
+      return "unavailable";
+    }
+  }
+  probeTrackedIdentity(tracked) {
+    const expectedIdentity = tracked.processStartIdentity;
+    const currentIdentity = this.readProcessStartIdentity(tracked.pid);
+    if (expectedIdentity && currentIdentity) {
+      return currentIdentity === expectedIdentity ? "match" : "mismatch";
+    }
+    const liveness = this.probePidLiveness(tracked.pid);
+    return liveness === "gone" ? "gone" : "unavailable";
+  }
+  probeOwnedProcessGroup(tracked) {
+    if (!tracked.ownsProcessGroup || process.platform === "win32") return "unavailable";
+    try {
+      signalProcessGroup(tracked.pid, 0);
+      return "alive";
+    } catch (error) {
+      if (this.isNoSuchProcessError(error)) return "gone";
+      return "unavailable";
+    }
+  }
+  async waitForOwnedProcessGroupGone(tracked) {
+    const deadline = Date.now() + GROUP_EXIT_CONFIRMATION_MS;
+    let lastProbe = this.probeOwnedProcessGroup(tracked);
+    while (lastProbe !== "gone" && Date.now() < deadline) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, GROUP_EXIT_POLL_MS);
+      });
+      lastProbe = this.probeOwnedProcessGroup(tracked);
+    }
+    return lastProbe;
+  }
+  async waitForTrackedChildGone(tracked) {
+    const deadline = Date.now() + CHILD_EXIT_CONFIRMATION_MS;
+    let lastProbe = this.probeTrackedIdentity(tracked);
+    while (!tracked.childExited && !this.childHasExited(tracked.childProcess) && lastProbe !== "gone" && lastProbe !== "mismatch" && Date.now() < deadline) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, CHILD_EXIT_POLL_MS);
+      });
+      lastProbe = this.probeTrackedIdentity(tracked);
+    }
+    if (tracked.childExited || this.childHasExited(tracked.childProcess)) return "gone";
+    return lastProbe;
+  }
+  removeTrackedChildListeners(tracked) {
+    if (tracked.exitListener && typeof tracked.childProcess.removeListener === "function") {
+      tracked.childProcess.removeListener("exit", tracked.exitListener);
+    }
+    if (tracked.closeListener && typeof tracked.childProcess.removeListener === "function") {
+      tracked.childProcess.removeListener("close", tracked.closeListener);
+    }
+    tracked.exitListener = void 0;
+    tracked.closeListener = void 0;
+  }
+  trackChildProcess(registration) {
+    const childProcess = registration.childProcess;
+    const pid = childProcess?.pid;
+    if (!childProcess || !pid) return;
+    const previous = this.trackedChildProcesses.get(pid);
+    if (previous) {
+      this.untrackChildProcess(previous);
+    }
+    const tracked = {
+      processId: registration.processId,
+      pid,
+      childProcess,
+      ownsProcessGroup: registration.ownsProcessGroup,
+      processStartIdentity: registration.processStartIdentity,
+      childExited: this.childHasExited(childProcess),
+      processGroupOwnershipConfirmed: false,
+      leaderExitHandled: false
+    };
+    const onExit = () => {
+      tracked.childExited = true;
+      if (tracked.leaderExitHandled) return;
+      tracked.leaderExitHandled = true;
+      this.removeTrackedChildListeners(tracked);
+      if (tracked.forceKillPromise && tracked.ownsProcessGroup) {
+        if (tracked.processGroupOwnershipConfirmed && this.probeOwnedProcessGroup(tracked) === "gone") {
+          this.untrackChildProcess(tracked, { confirmed: true, reason: "group-gone" });
+        } else if (!tracked.processGroupOwnershipConfirmed) {
+          this.untrackChildProcess(tracked, {
+            confirmed: false,
+            reason: "group-liveness-unavailable"
+          });
+        }
+        return;
+      }
+      this.untrackChildProcess(tracked, { confirmed: true, reason: "child-exited" });
+    };
+    tracked.exitListener = onExit;
+    tracked.closeListener = onExit;
+    if (typeof childProcess.once === "function") {
+      childProcess.once("exit", onExit);
+      childProcess.once("close", onExit);
+    }
+    this.trackedChildProcesses.set(pid, tracked);
+  }
+  untrackRegistrationChild(registration) {
+    const childProcess = registration.childProcess;
+    const pid = childProcess?.pid;
+    if (!childProcess || !pid) return;
+    const tracked = this.trackedChildProcesses.get(pid);
+    if (tracked && tracked.processId === registration.processId && tracked.childProcess === childProcess) {
+      this.untrackChildProcess(tracked);
+    }
+  }
+  untrackChildProcess(tracked, outcome = { confirmed: false, reason: "tracking-removed" }) {
+    if (this.trackedChildProcesses.get(tracked.pid) === tracked) {
+      this.trackedChildProcesses.delete(tracked.pid);
+    }
+    this.removeTrackedChildListeners(tracked);
+    tracked.finishForceKill?.(outcome);
+  }
+  signalTrackedChild(tracked, signal) {
+    if (this.trackedChildProcesses.get(tracked.pid) !== tracked) {
+      return { delivered: false, identity: "gone", target: "none" };
+    }
+    const identity = this.probeTrackedIdentity(tracked);
+    if (identity === "mismatch" || identity === "gone") {
+      return { delivered: false, identity, target: "none" };
+    }
+    if (tracked.childExited || this.childHasExited(tracked.childProcess)) {
+      return { delivered: false, identity: "gone", target: "none" };
+    }
+    if (this.trackedChildProcesses.get(tracked.pid) !== tracked) {
+      return { delivered: false, identity: "gone", target: "none" };
+    }
+    const processGroupSignalRequested = tracked.ownsProcessGroup && process.platform !== "win32";
+    if (processGroupSignalRequested && identity === "match") {
+      const groupMembers = this.readProcessGroupMembers(tracked.pid);
+      if (groupMembers && groupMembers.get(tracked.pid) === tracked.processStartIdentity) {
+        tracked.processGroupMembersAtSignal = groupMembers;
+        tracked.processGroupOwnershipConfirmed = true;
+        try {
+          signalProcessGroup(tracked.pid, signal);
+          return { delivered: true, identity, target: "group" };
+        } catch (error) {
+          if (this.isNoSuchProcessError(error)) {
+            return { delivered: false, identity: "gone", target: "none" };
+          }
+        }
+      }
+    }
+    try {
+      const delivered = typeof tracked.childProcess.kill === "function" ? tracked.childProcess.kill(signal) : false;
+      return { delivered, identity, target: delivered ? "child" : "none" };
+    } catch (error) {
+      if (!this.isNoSuchProcessError(error) && this.config.verbose) {
+        console.log(chalk.yellow(`Process signal failed: ${error}`));
+      }
+      return {
+        delivered: false,
+        identity: this.isNoSuchProcessError(error) ? "gone" : identity,
+        target: "none"
+      };
+    }
+  }
+  async forceTrackedChildTermination(tracked, registration) {
+    if (tracked.ownsProcessGroup && tracked.processGroupOwnershipConfirmed) {
+      const groupState = this.probeOwnedProcessGroup(tracked);
+      if (groupState === "gone") {
+        return { confirmed: true, reason: "group-gone" };
+      }
+      const currentMembers = this.readProcessGroupMembers(tracked.pid);
+      const confirmedMembers = tracked.processGroupMembersAtSignal;
+      if (!currentMembers || !confirmedMembers) {
+        return { confirmed: false, reason: "group-liveness-unavailable" };
+      }
+      for (const [pid, identity] of currentMembers) {
+        if (confirmedMembers.get(pid) !== identity) {
+          return { confirmed: false, reason: "identity-changed" };
+        }
+      }
+      try {
+        signalProcessGroup(tracked.pid, "SIGKILL");
+        if (registration) {
+          void this.cleanupStaleGitIndexLockForRegistration(registration);
+        }
+      } catch (error) {
+        if (this.isNoSuchProcessError(error)) {
+          return { confirmed: true, reason: "group-gone" };
+        }
+        return {
+          confirmed: false,
+          reason: groupState === "unavailable" ? "group-liveness-unavailable" : "signal-failed"
+        };
+      }
+      const finalGroupState = await this.waitForOwnedProcessGroupGone(tracked);
+      if (finalGroupState === "gone") {
+        return { confirmed: true, reason: "group-gone" };
+      }
+      return {
+        confirmed: false,
+        reason: finalGroupState === "unavailable" ? "group-liveness-unavailable" : "group-still-alive"
+      };
+    }
+    const result = this.signalTrackedChild(tracked, "SIGKILL");
+    if (result.identity === "mismatch") {
+      return { confirmed: true, reason: "identity-changed" };
+    }
+    if (result.identity === "gone") {
+      return { confirmed: true, reason: "pid-gone" };
+    }
+    if (result.identity === "unavailable") {
+      return { confirmed: false, reason: "identity-unavailable" };
+    }
+    if (result.delivered) {
+      if (registration) {
+        void this.cleanupStaleGitIndexLockForRegistration(registration);
+      }
+      const finalIdentity = await this.waitForTrackedChildGone(tracked);
+      if (tracked.ownsProcessGroup) {
+        return { confirmed: false, reason: "group-liveness-unavailable" };
+      }
+      if (finalIdentity === "gone") {
+        return { confirmed: true, reason: "pid-gone" };
+      }
+      if (finalIdentity === "mismatch") {
+        return { confirmed: true, reason: "identity-changed" };
+      }
+      if (finalIdentity === "unavailable") {
+        return { confirmed: false, reason: "identity-unavailable" };
+      }
+      return { confirmed: false, reason: "child-still-alive" };
+    }
+    return { confirmed: false, reason: "signal-failed" };
+  }
+  beginTrackedChildTermination(tracked, registration) {
+    if (tracked.forceKillPromise) return tracked.forceKillPromise;
+    let settled = false;
+    let resolvePromise;
+    const forceKillPromise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    tracked.forceKillPromise = forceKillPromise;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      const timer2 = tracked.forceKillTimer;
+      if (timer2) {
+        this.clearForcedKillTimer(timer2);
+        tracked.forceKillTimer = void 0;
+      }
+      if (registration && registration.forceKillTimeoutHandle === timer2) {
+        registration.forceKillTimeoutHandle = void 0;
+      }
+      tracked.finishForceKill = void 0;
+      resolvePromise(outcome);
+    };
+    tracked.finishForceKill = finish;
+    const initialSignal = this.signalTrackedChild(tracked, "SIGTERM");
+    if (initialSignal.identity === "mismatch" || initialSignal.identity === "gone") {
+      this.untrackChildProcess(tracked, {
+        confirmed: true,
+        reason: initialSignal.identity === "mismatch" ? "identity-changed" : "pid-gone"
+      });
+      return forceKillPromise;
+    }
+    if (settled) return forceKillPromise;
+    const timer = setTimeout(() => {
+      void this.forceTrackedChildTermination(tracked, registration).then((outcome) => {
+        this.untrackChildProcess(tracked, outcome);
+        finish(outcome);
+      }).catch(() => {
+        const outcome = {
+          confirmed: false,
+          reason: "signal-failed"
+        };
+        this.untrackChildProcess(tracked, outcome);
+        finish(outcome);
+      });
+    }, FORCE_KILL_GRACE_MS);
+    tracked.forceKillTimer = timer;
+    this.activeForcedKillTimers.add(timer);
+    if (registration) {
+      registration.forceKillTimeoutHandle = timer;
+    }
+    return forceKillPromise;
+  }
+  /**
+   * True when a kill/signal error indicates the target process no longer exists
+   * (ESRCH / "no such process"). This is the success case for a late SIGKILL: the
+   * process already exited on its own, so the signal harmlessly missed. It must be
+   * swallowed silently rather than surfaced as a termination failure.
+   */
+  isNoSuchProcessError(error) {
+    if (error && typeof error === "object") {
+      const code = error.code;
+      if (code === "ESRCH") {
+        return true;
+      }
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /no such process/i.test(message);
+  }
+  clearHardTimeout(registration) {
+    if (registration.hardTimeoutHandle) {
+      clearTimeout(registration.hardTimeoutHandle);
+      registration.hardTimeoutHandle = void 0;
+    }
+  }
+  /**
+   * Monitor a registered process from birth to death
+   */
+  async monitorProcess(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: processId,
+          subsystem: "orchestrator",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "monitorProcess",
+            reason: "Process not found for monitoring"
+          }
+        }
+      );
+      return;
+    }
+    if (registration.timeoutEnabled) {
+      this.setupProgressiveTimeoutChecks(processId);
+      this.setupFrequentProgressMonitoring(processId);
+      registration.hardTimeoutHandle = setTimeout(async () => {
+        try {
+          const current = this.processes.get(processId);
+          if (current && current.status === "running") {
+            console.log(
+              chalk.yellow(`Process ${processId} timed out after ${registration.timeoutMs / 1e3}s`)
+            );
+            await this.terminateProcess(processId, "timeout");
+          }
+        } catch (error) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: processId,
+              subsystem: "orchestrator",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "timeoutTerminate",
+                reason: "terminateProcess_failed",
+                error: error instanceof Error ? error.message : String(error)
+              }
+            }
+          );
+        }
+      }, registration.timeoutMs);
+      registration.hardTimeoutHandle.unref?.();
+    }
+    try {
+      const result = await registration.completionPromise;
+      this.clearHardTimeout(registration);
+      if (!this.processes.has(processId) || registration.status !== "running") {
+        this.updateStats();
+        return;
+      }
+      const isVerified = await this.verifyProcess(processId);
+      if (!this.processes.has(processId) || registration.status !== "running") {
+        this.updateStats();
+        return;
+      }
+      if (isVerified) {
+        registration.status = "completed";
+        registration.terminalAt = Date.now();
+        registration.result = result;
+        this.stats.completed++;
+        this.untrackRegistrationChild(registration);
+        if (this.config.verbose) {
+          console.log(chalk.green(`Process ${processId} completed and verified`));
+        }
+      } else {
+        console.log(chalk.red(`Process ${processId} claimed success but verification failed`));
+        registration.status = "failed";
+        registration.terminalAt = Date.now();
+        registration.error = new Error("verification_failed");
+        this.stats.failed++;
+        await this.cleanupProcess(processId);
+        this.updateStats();
+      }
+    } catch (error) {
+      this.clearHardTimeout(registration);
+      if (!this.processes.has(processId) || registration.status !== "running") {
+        this.updateStats();
+        return;
+      }
+      registration.status = "failed";
+      registration.terminalAt = Date.now();
+      registration.error = error instanceof Error ? error : new Error(String(error));
+      this.stats.failed++;
+      if (this.config.verbose) {
+        console.log(chalk.red(`Process ${processId} failed: ${registration.error.message}`));
+      }
+      await this.cleanupProcess(processId);
+    }
+    this.updateStats();
+  }
+  /**
+   * Verify actual process completion (mandatory verification loop)
+   *
+   * CRITICAL: Never trust process completion signals without verification
+   */
+  async verifyProcess(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return false;
+    }
+    try {
+      const startTime = Date.now();
+      const isVerified = await registration.verificationFn();
+      const verificationTime = Date.now() - startTime;
+      if (this.config.verbose) {
+        console.log(
+          chalk.gray(
+            `Process ${processId} verification: ${isVerified ? "PASSED" : "FAILED"} (${verificationTime}ms)`
+          )
+        );
+      }
+      return isVerified;
+    } catch (error) {
+      console.log(chalk.red(`Process ${processId} verification _error: ${error}`));
+      return false;
+    }
+  }
+  /**
+   * Set up progressive timeout checks at intermediate intervals
+   *
+   * This sets up checkpoints at 15min, 30min, 60min etc. to verify the process
+   * is still making progress. If no progress is detected for consecutive checks,
+   * the process may be terminated early.
+   */
+  setupProgressiveTimeoutChecks(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return;
+    }
+    const relevantIntervals = this.config.progressiveCheckIntervals.filter(
+      (interval) => interval < registration.timeoutMs
+    );
+    const timers = [];
+    if (relevantIntervals.length === 0) {
+      const minCheckInterval = this.config.verificationIntervalMs;
+      if (minCheckInterval < registration.timeoutMs) {
+        const checkCount = Math.max(2, Math.floor(registration.timeoutMs / minCheckInterval / 2));
+        for (let i = 1; i <= checkCount; i++) {
+          const checkTime = minCheckInterval * i;
+          if (checkTime < registration.timeoutMs) {
+            const timer = setTimeout(async () => {
+              await this.performProgressCheck(processId, checkTime);
+            }, checkTime);
+            timer.unref();
+            timers.push(timer);
+          }
+        }
+        if (this.config.verbose && timers.length > 0) {
+          console.log(
+            chalk.gray(
+              `Set up ${timers.length} minimum progress checks for ${processId} at intervals of ${minCheckInterval}ms (timeout ${registration.timeoutMs}ms)`
+            )
+          );
+        }
+      } else if (this.config.verbose) {
+        console.log(
+          chalk.gray(
+            `No progress checks for ${processId} (timeout ${registration.timeoutMs}ms is too short)`
+          )
+        );
+      }
+    } else {
+      for (const interval of relevantIntervals) {
+        const timer = setTimeout(async () => {
+          await this.performProgressCheck(processId, interval);
+        }, interval);
+        timer.unref();
+        timers.push(timer);
+      }
+      if (this.config.verbose) {
+        console.log(
+          chalk.gray(
+            `Set up ${relevantIntervals.length} progressive timeout checks for ${processId}: ${relevantIntervals.map((i) => `${i / 1e3 / 60}m`).join(", ")}`
+          )
+        );
+      }
+    }
+    if (timers.length > 0) {
+      registration.progressCheckTimers = timers;
+    }
+  }
+  /**
+   * Perform a progress check at a specific interval
+   *
+   * Checks if the process is:
+   * - Still alive
+   * - Making progress (file changes, output, custom callback)
+   * - Within resource limits
+   *
+   * If no progress detected, increments failure counter.
+   * If consecutive failures exceed threshold, considers early termination.
+   */
+  async performProgressCheck(processId, intervalMs) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return;
+    }
+    if (registration.status !== "running") {
+      return;
+    }
+    const elapsedMs = Date.now() - registration.createdAt.getTime();
+    const elapsedMinutes = Math.round(elapsedMs / 1e3 / 60);
+    if (this.config.verbose) {
+      console.log(
+        chalk.blue(
+          `Progressive check for ${processId} at ${elapsedMinutes}min mark (${intervalMs / 1e3 / 60}min checkpoint)`
+        )
+      );
+    }
+    const isAlive = await this.checkProcessAlive(processId);
+    if (!isAlive) {
+      console.log(
+        chalk.yellow(`Process ${processId} is not alive at ${elapsedMinutes}min checkpoint`)
+      );
+      registration.consecutiveProgressFailures++;
+      await this.handleProgressFailure(processId, elapsedMinutes);
+      return;
+    }
+    const hasProgress = await this.checkProcessProgress(processId);
+    if (!hasProgress) {
+      if (!this.config.verbose && this.shouldSkipEarlyTerminationOnNoProgress(registration)) {
+        return;
+      }
+      console.log(
+        chalk.yellow(
+          `Process ${processId} shows no progress at ${elapsedMinutes}min checkpoint (${registration.consecutiveProgressFailures + 1}/${this.config.maxConsecutiveProgressFailures} failures)`
+        )
+      );
+      registration.consecutiveProgressFailures++;
+      await this.handleProgressFailure(processId, elapsedMinutes);
+    } else {
+      if (registration.consecutiveProgressFailures > 0) {
+        console.log(
+          chalk.green(
+            `Process ${processId} showing progress at ${elapsedMinutes}min checkpoint (reset failure counter)`
+          )
+        );
+        registration.consecutiveProgressFailures = 0;
+      } else if (this.config.verbose) {
+        console.log(
+          chalk.green(`Process ${processId} showing progress at ${elapsedMinutes}min checkpoint`)
+        );
+      }
+    }
+  }
+  /**
+   * Check if a process is still alive (has running child process or recent activity)
+   */
+  async checkProcessAlive(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return false;
+    }
+    if (registration.childProcess) {
+      return !registration.childProcess.killed && registration.childProcess.exitCode === null;
+    }
+    return true;
+  }
+  /**
+   * Check if a process is making progress
+   *
+   * Progress indicators:
+   * 1. Custom progress callback (if provided)
+   * 2. Resource usage changes (CPU/memory activity)
+   * 3. Recent output/activity
+   *
+   */
+  async checkProcessProgress(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return false;
+    }
+    if (registration.progressCallback) {
+      try {
+        const currentProgress = await registration.progressCallback();
+        registration.lastProgress = currentProgress;
+        const baseline = registration.lastProgressForTermination;
+        if (!baseline) {
+          registration.lastProgressForTermination = currentProgress;
+          return true;
+        }
+        const hasFileChanges = currentProgress.filesChanged > baseline.filesChanged;
+        const hasOutput = currentProgress.outputLines > baseline.outputLines;
+        const hasActivity = currentProgress.lastActivityTimestamp > baseline.lastActivityTimestamp;
+        const hasProgress = hasFileChanges || hasOutput || hasActivity;
+        if (hasProgress) {
+          registration.lastProgressForTermination = currentProgress;
+        }
+        return hasProgress;
+      } catch (error) {
+        if (this.config.verbose) {
+          console.log(
+            chalk.yellow(
+              `Progress callback failed for ${processId}: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
+    }
+    if (registration.resourceHistory && registration.resourceHistory.length >= 2) {
+      const recent = registration.resourceHistory.slice(-5);
+      const hasCpuActivity = recent.some((usage) => usage.cpuPercentage > 0.1);
+      if (hasCpuActivity) {
+        return true;
+      }
+    }
+    if (registration.childProcess && !registration.resourceHistory) {
+      return true;
+    }
+    if (!registration.progressCallback && !registration.childProcess && (!registration.resourceHistory || registration.resourceHistory.length === 0)) {
+      if (this.config.verbose) {
+        console.log(
+          chalk.gray(`No progress monitoring available for ${processId}, assuming progress`)
+        );
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Handle consecutive progress check failures
+   *
+   * If failures exceed threshold, terminate the process early
+   */
+  async handleProgressFailure(processId, elapsedMinutes) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return;
+    }
+    if (registration.consecutiveProgressFailures >= this.config.maxConsecutiveProgressFailures) {
+      const elapsedMs = Date.now() - registration.createdAt.getTime();
+      const earlyLifecycleMs = Math.min(5 * 60 * 1e3, Math.floor(registration.timeoutMs * 0.1));
+      if (elapsedMs < earlyLifecycleMs) {
+        return;
+      }
+      if (this.shouldSkipEarlyTerminationOnNoProgress(registration)) {
+        if (this.config.verbose) {
+          console.log(
+            chalk.gray(
+              `Skipping early termination for ${processId} (provider CLI; no-progress heuristics are noisy)`
+            )
+          );
+        }
+        return;
+      }
+      const nearTimeoutMs = Math.floor(registration.timeoutMs * 0.9);
+      if (elapsedMs < nearTimeoutMs) {
+        return;
+      }
+      console.log(
+        chalk.red(
+          `Process ${processId} failed ${registration.consecutiveProgressFailures} consecutive progress checks - terminating early (${elapsedMinutes}min elapsed)`
+        )
+      );
+      await this.terminateProcess(processId, "progress_check_failed");
+    }
+  }
+  /**
+   * Force terminate a process
+   *
+   * @param processId - Process to terminate
+   * @param reason - Reason for termination
+   */
+  async terminateProcess(processId, reason) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: processId,
+          subsystem: "orchestrator",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "terminateProcess",
+            reason: "Process not found for termination"
+          }
+        }
+      );
+      return;
+    }
+    if (registration.status === "completed" || registration.status === "failed" || registration.status === "terminating" || registration.status === "terminated" || registration.status === "timeout") {
+      if (this.config.verbose) {
+        console.log(
+          chalk.gray(
+            `Skipping termination for terminal process ${processId} (${registration.status})`
+          )
+        );
+      }
+      return;
+    }
+    console.log(chalk.yellow(`Terminating process ${processId} (${reason})`));
+    registration.terminationFailed = false;
+    const statusBeforeTermination = registration.status;
+    if (statusBeforeTermination === "running") {
+      registration.status = "terminating";
+    }
+    try {
+      await registration.terminateFn({ reason, source: "process-lifecycle-manager" });
+      registration.terminationFailed = false;
+      registration.status = reason === "timeout" ? "timeout" : "terminated";
+      registration.terminalAt = Date.now();
+      this.stats[reason === "timeout" ? "timeout" : "terminated"]++;
+      if (this.config.verbose) {
+        console.log(chalk.yellow(`Process ${processId} terminated (${reason})`));
+      }
+    } catch (error) {
+      if (registration.status === "terminating") {
+        registration.status = statusBeforeTermination;
+      }
+      registration.error = error instanceof Error ? error : new Error(`Termination failed: ${String(error)}`);
+      registration.terminationFailed = true;
+      emitWarning(
+        "PR-001",
+        {
+          taskId: processId,
+          subsystem: "orchestrator",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            operation: "terminateProcess",
+            reason: "Process termination failed",
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+    await this.cleanupProcess(processId);
+    this.updateStats();
+  }
+  async finalizeStaleTrackedRegistration(processId, registration, tracked, identity, terminationReason) {
+    this.untrackChildProcess(tracked, {
+      confirmed: true,
+      reason: identity === "mismatch" ? "identity-changed" : "pid-gone"
+    });
+    if (registration.status === "running") {
+      const terminalStatus = terminationReason === "timeout" ? "timeout" : "terminated";
+      registration.terminationFailed = false;
+      registration.status = terminalStatus;
+      registration.terminalAt = Date.now();
+      this.stats[terminalStatus]++;
+    }
+    await this.cleanupProcess(processId);
+    this.updateStats();
+  }
+  /**
+   * Gracefully terminate a process: send SIGTERM, wait up to graceMs for the
+   * process to exit on its own, then fall back to forced termination via
+   * terminateProcess() if it is still running.
+   *
+   * terminateProcess()/terminateFn have no graceful option, so the graceful
+   * phase signals the child process directly (process group first, mirroring
+   * cleanupProcess). If the process exits during the grace window, the
+   * regular monitorProcess completion handling owns the final status; no
+   * forced termination is issued.
+   *
+   * @param processId - Process to terminate
+   * @param reason - Reason for termination
+   * @param graceMs - Milliseconds to wait after SIGTERM before forcing
+   */
+  async terminateProcessWithGrace(processId, reason, graceMs) {
+    const registration = this.processes.get(processId);
+    const child = registration?.childProcess;
+    const childExited = () => !child || child.exitCode !== null || child.signalCode !== null;
+    if (!registration || !child || !child.pid || childExited()) {
+      await this.terminateProcess(processId, reason);
+      return;
+    }
+    try {
+      const tracked = this.trackedChildProcesses.get(child.pid);
+      if (tracked && tracked.processId === processId && tracked.childProcess === child) {
+        const signalResult = this.signalTrackedChild(tracked, "SIGTERM");
+        if (signalResult.identity === "mismatch" || signalResult.identity === "gone") {
+          await this.finalizeStaleTrackedRegistration(
+            processId,
+            registration,
+            tracked,
+            signalResult.identity,
+            reason
+          );
+          return;
+        }
+      } else {
+        await this.terminateProcess(processId, reason);
+        return;
+      }
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const finish = () => {
+        clearTimeout(timer);
+        child.removeListener("exit", finish);
+        resolve();
+      };
+      const timer = setTimeout(finish, graceMs);
+      timer.unref?.();
+      if (childExited()) {
+        finish();
+        return;
+      }
+      child.once("exit", finish);
+    });
+    const current = this.processes.get(processId);
+    if (current && current.status === "running") {
+      await this.terminateProcess(processId, reason);
+    }
+  }
+  /**
+   * Clean up process resources
+   */
+  async cleanupProcess(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return;
+    }
+    this.clearHardTimeout(registration);
+    const progressTimer = this.progressMonitoringTimers.get(processId);
+    if (progressTimer) {
+      this.progressMonitoringTimers.delete(processId);
+      clearInterval(progressTimer);
+    }
+    if (registration.progressCheckTimers) {
+      for (const timer of registration.progressCheckTimers) {
+        clearTimeout(timer);
+      }
+      registration.progressCheckTimers = void 0;
+    }
+    const childProcess = registration.childProcess;
+    const pid = childProcess?.pid;
+    if (childProcess && pid) {
+      const tracked = this.trackedChildProcesses.get(pid);
+      if (this.childHasExited(childProcess)) {
+        if (tracked) this.untrackChildProcess(tracked);
+      } else if (tracked && tracked.processId === registration.processId && tracked.childProcess === childProcess) {
+        void this.beginTrackedChildTermination(tracked, registration).then((outcome) => {
+          if (!outcome.confirmed) {
+            registration.terminationFailed = true;
+            registration.error = new Error(`Child process cleanup unconfirmed: ${outcome.reason}`);
+          }
+        });
+      }
+    }
+    if (this.config.cleanupOnTermination && registration.status !== "completed") {
+      this.processes.delete(processId);
+    }
+  }
+  /**
+   * Set up frequent progress checks for running processes.
+   *
+   * Progressive checks (15m/30m/60m) are useful for long-running jobs, but we also want
+   * short-cadence checks to:
+   * - populate `lastProgress` quickly (for UX and tests)
+   * - detect stalled processes when `verificationIntervalMs` is intentionally small
+   */
+  setupFrequentProgressMonitoring(processId) {
+    const registration = this.processes.get(processId);
+    if (!registration) {
+      return;
+    }
+    if (this.progressMonitoringTimers.has(processId)) {
+      return;
+    }
+    const intervalMs = Math.max(10, this.config.verificationIntervalMs);
+    let isTickRunning = false;
+    const timer = setInterval(async () => {
+      if (isTickRunning) return;
+      isTickRunning = true;
+      try {
+        const current = this.processes.get(processId);
+        if (!current || current.status !== "running") {
+          clearInterval(timer);
+          this.progressMonitoringTimers.delete(processId);
+          return;
+        }
+        const hasProgress = await this.checkProcessProgress(processId);
+        if (!hasProgress) {
+          current.consecutiveFrequentProgressFailures++;
+          return;
+        }
+        if (current.consecutiveFrequentProgressFailures > 0) {
+          current.consecutiveFrequentProgressFailures = 0;
+        }
+      } finally {
+        isTickRunning = false;
+      }
+    }, intervalMs);
+    timer.unref();
+    this.progressMonitoringTimers.set(processId, timer);
+  }
+  /**
+   * Terminate all running processes
+   */
+  async terminateAll(reason = "shutdown") {
+    const runningProcesses = Array.from(this.processes.entries()).filter(
+      ([, registration]) => registration.status === "running" || registration.status === "terminating"
+    );
+    if (runningProcesses.length === 0) {
+      if (this.config.verbose) {
+        console.error(chalk.green(`No running processes to terminate (${reason})`));
+      }
+      return;
+    }
+    console.error(chalk.yellow(`Terminating all processes (${reason})...`));
+    const terminationPromises = [];
+    for (const [processId] of runningProcesses) {
+      terminationPromises.push(this.terminateProcess(processId, reason));
+    }
+    await Promise.allSettled(terminationPromises);
+    const failedCount = runningProcesses.filter(
+      ([, registration]) => registration.terminationFailed === true
+    ).length;
+    if (failedCount > 0) {
+      emitWarning(
+        "PR-001",
+        {
+          subsystem: "orchestrator",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            operation: "terminateAll",
+            reason: `Process termination completed with ${failedCount} failure(s) during cleanup`,
+            terminationReason: reason,
+            failedCount
+          }
+        }
+      );
+      return;
+    }
+    console.error(chalk.green(`All processes terminated (${reason})`));
+  }
+  /**
+   * Get process registration by ID
+   */
+  getProcess(processId) {
+    return this.processes.get(processId);
+  }
+  /**
+   * Get all processes (optionally filtered by status)
+   */
+  getProcesses(status) {
+    const allProcesses = Array.from(this.processes.values());
+    return status ? allProcesses.filter((p) => p.status === status) : allProcesses;
+  }
+  /**
+   * Get running processes
+   */
+  getRunningProcesses() {
+    return this.getProcesses("running");
+  }
+  /**
+   * Get process statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      running: this.getProcesses("running").length,
+      history: this.processes.size
+    };
+  }
+  /**
+   * Update internal statistics
+   */
+  updateStats() {
+    this.stats.total = this.processes.size + this.evictedTerminalRegistrations;
+    this.stats.running = this.getProcesses("running").length;
+  }
+  /**
+   * Build a structured shutdown intent without exiting the process.
+   * CLI code is responsible for turning this intent into runtime exit behavior.
+   */
+  async createShutdownIntent(reason, code) {
+    if (!this.isShuttingDown) {
+      this.isShuttingDown = true;
+      await this.runShutdownCleanup(reason);
+    }
+    return {
+      code,
+      reason,
+      cleanupDone: true
+    };
+  }
+  async handleSignal(signal) {
+    const code = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+    return this.createShutdownIntent(`signal_${signal}`, code);
+  }
+  async handleUncaughtException(error) {
+    console.error(chalk.red(`
+Uncaught exception: ${error.message}`));
+    return this.createShutdownIntent("uncaught_exception", 1);
+  }
+  async handleUnhandledRejection(reason, promise) {
+    console.error(chalk.red(`
+Unhandled rejection at: ${promise}`));
+    console.error(chalk.red(`   Reason: ${reason}`));
+    return this.createShutdownIntent("unhandled_rejection", 1);
+  }
+  /**
+   * Create verification function for local processes
+   */
+  static createLocalVerification(requirements) {
+    return async () => {
+      try {
+        if (requirements.expectedFiles) {
+          for (const file of requirements.expectedFiles) {
+            try {
+              await fs.access(file);
+            } catch (_error) {
+              return false;
+            }
+          }
+        }
+        if (requirements.expectedArtifacts) {
+          for (const artifact of requirements.expectedArtifacts) {
+            try {
+              await fs.access(artifact);
+            } catch (_error) {
+              return false;
+            }
+          }
+        }
+        if (requirements.customVerification) {
+          return await requirements.customVerification();
+        }
+        return true;
+      } catch (error) {
+        console.log(chalk.red(`Local verification _error: ${error}`));
+        return false;
+      }
+    };
+  }
+  /**
+   * Check for orphaned processes and clean them up
+   */
+  async cleanupOrphanedProcesses() {
+    const runningProcesses = this.getRunningProcesses();
+    const now = Date.now();
+    for (const process2 of runningProcesses) {
+      const elapsed = now - process2.createdAt.getTime();
+      if (!process2.timeoutEnabled) {
+        if (elapsed > this.OLD_PROCESS_TIMEOUT_MS) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: process2.processId,
+              subsystem: "orchestrator",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "cleanupOrphanedProcesses",
+                reason: "stale_timeout_disabled",
+                elapsedMs: elapsed
+              }
+            }
+          );
+          await this.terminateProcess(process2.processId, "stale_timeout_disabled");
+        }
+        continue;
+      }
+      if (elapsed > process2.timeoutMs * 2) {
+        console.log(
+          chalk.yellow(
+            `[orphan] Found orphaned process: ${process2.processId} (running for ${elapsed / 1e3}s)`
+          )
+        );
+        await this.terminateProcess(process2.processId, "orphaned");
+      }
+    }
+  }
+  /**
+   * Generate process lifecycle report
+   */
+  generateReport() {
+    const lines = [];
+    const stats = this.getStats();
+    lines.push(chalk.bold("Process Lifecycle Manager Report"));
+    lines.push("");
+    lines.push(chalk.cyan("Statistics:"));
+    lines.push(`  Total processes: ${stats.total}`);
+    lines.push(`  Running: ${chalk.green(stats.running)}`);
+    lines.push(`  Completed: ${chalk.green(stats.completed)}`);
+    lines.push(`  Failed: ${chalk.red(stats.failed)}`);
+    lines.push(`  Terminated: ${chalk.yellow(stats.terminated)}`);
+    lines.push(`  Timeout: ${chalk.yellow(stats.timeout)}`);
+    lines.push("");
+    if (stats.running > 0) {
+      lines.push(chalk.cyan("Running Processes:"));
+      this.getRunningProcesses().forEach((process2) => {
+        const elapsed = (Date.now() - process2.createdAt.getTime()) / 1e3;
+        lines.push(`  ${process2.processId} (${process2.processType}) - ${elapsed.toFixed(1)}s`);
+      });
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Start automatic cleanup timer for processes older than 2 hours
+   * This prevents accumulation of old processes that might otherwise go unnoticed
+   */
+  startOldProcessCleanup() {
+    if (this.oldProcessCleanupTimer) {
+      clearInterval(this.oldProcessCleanupTimer);
+    }
+    this.oldProcessCleanupTimer = setInterval(() => {
+      void this.cleanupOldProcesses();
+    }, this.CLEANUP_CHECK_INTERVAL_MS);
+    this.oldProcessCleanupTimer.unref?.();
+  }
+  /**
+   * Clean up processes that have been running for longer than the timeout threshold
+   * Prevents accumulation of old processes (e.g., from 2+ hours ago)
+   */
+  async cleanupOldProcesses() {
+    const now = Date.now();
+    const oldProcessesToClean = [];
+    const terminalProcessesToEvict = [];
+    for (const [processId, registration] of this.processes) {
+      const processAge = now - registration.createdAt.getTime();
+      if (processAge > this.OLD_PROCESS_TIMEOUT_MS && registration.timeoutEnabled) {
+        if (registration.status === "running") {
+          oldProcessesToClean.push(processId);
+        }
+      }
+      if (registration.status !== "running" && registration.status !== "terminating" && now - (registration.terminalAt ?? registration.createdAt.getTime()) > this.TERMINAL_REGISTRATION_RETENTION_MS) {
+        terminalProcessesToEvict.push(processId);
+      }
+    }
+    for (const processId of oldProcessesToClean) {
+      const registration = this.processes.get(processId);
+      if (registration) {
+        const ageHours = (now - registration.createdAt.getTime()) / 1e3 / 60 / 60;
+        console.log(
+          chalk.yellow(
+            `Cleaning up old process: ${processId} (running for ${ageHours.toFixed(1)} hours)`
+          )
+        );
+        await this.terminateProcess(processId, "old_process_timeout");
+      }
+    }
+    for (const processId of terminalProcessesToEvict) {
+      if (this.processes.has(processId)) {
+        this.evictedTerminalRegistrations++;
+        this.unregisterProcess(processId);
+      }
+    }
+  }
+  /**
+   * Clean up all tracked child processes by PID
+   * This method forcefully kills all tracked child processes
+   */
+  async cleanupAllProcesses() {
+    if (this.trackedChildProcesses.size === 0) {
+      if (this.config.verbose) {
+        console.log(chalk.gray("No child processes to cleanup"));
+      }
+      return;
+    }
+    console.log(
+      chalk.yellow(`Cleaning up ${this.trackedChildProcesses.size} tracked child processes...`)
+    );
+    const trackedChildren = Array.from(this.trackedChildProcesses.values());
+    const outcomes = await Promise.all(
+      trackedChildren.map((tracked) => {
+        if (tracked.forceKillPromise) {
+          return this.beginTrackedChildTermination(tracked, this.processes.get(tracked.processId));
+        }
+        if (tracked.childExited || this.childHasExited(tracked.childProcess)) {
+          const outcome = {
+            confirmed: true,
+            reason: "child-exited"
+          };
+          this.untrackChildProcess(tracked, outcome);
+          return Promise.resolve(outcome);
+        }
+        const registration = this.processes.get(tracked.processId);
+        return this.beginTrackedChildTermination(tracked, registration);
+      })
+    );
+    const unconfirmed = outcomes.map((outcome, index) => ({ outcome, tracked: trackedChildren[index] })).filter(({ outcome }) => !outcome.confirmed);
+    if (unconfirmed.length > 0) {
+      for (const { outcome, tracked } of unconfirmed) {
+        const registration = tracked ? this.processes.get(tracked.processId) : void 0;
+        if (registration) {
+          registration.terminationFailed = true;
+          registration.error = new Error(`Child process cleanup unconfirmed: ${outcome.reason}`);
+        }
+      }
+      throw new Error(
+        `Child process cleanup unconfirmed for ${unconfirmed.length} process(es): ${unconfirmed.map(({ outcome, tracked }) => `${tracked?.processId ?? "unknown"}=${outcome.reason}`).join(", ")}`
+      );
+    }
+    console.log(
+      chalk.green(`Child process cleanup completed for ${trackedChildren.length} processes`)
+    );
+  }
+  /**
+   * Start resource monitoring (CPU and memory) for child processes
+   *
+   * Monitors resource usage every 60 seconds and:
+   * - Tracks CPU and memory for each process
+   * - Warns when approaching limits
+   * - Kills oldest processes when limits exceeded
+   */
+  startResourceMonitoring() {
+    this.resourceMonitoringTimer = setInterval(() => {
+      this.monitorResourceUsage();
+    }, this.config.resourceMonitoringIntervalMs);
+    this.resourceMonitoringTimer.unref();
+    if (this.config.verbose) {
+      console.log(
+        chalk.gray(
+          `Resource monitoring started (interval: ${this.config.resourceMonitoringIntervalMs}ms)`
+        )
+      );
+    }
+  }
+  /**
+   * Monitor resource usage and enforce limits
+   *
+   * Thresholds:
+   * - Max 50 processes
+   * - Max 1000% total CPU usage
+   * - Kills oldest processes when limits exceeded
+   */
+  async monitorResourceUsage() {
+    const runningProcesses = this.getRunningProcesses();
+    if (runningProcesses.length === 0) {
+      return;
+    }
+    try {
+      const RESOURCE_MEASURE_CONCURRENCY = 4;
+      for (let i = 0; i < runningProcesses.length; i += RESOURCE_MEASURE_CONCURRENCY) {
+        const batch = runningProcesses.slice(i, i + RESOURCE_MEASURE_CONCURRENCY);
+        await Promise.all(batch.map((process2) => this.measureProcessResources(process2)));
+      }
+      this.totalCpuUsage = runningProcesses.reduce(
+        (sum, p) => sum + (p.lastResourceUsage?.cpuPercentage ?? 0),
+        0
+      );
+      this.checkResourceThresholds(runningProcesses);
+    } catch (error) {
+      if (this.config.verbose) {
+        console.log(
+          chalk.yellow(
+            `Resource monitoring error: ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+      }
+    }
+  }
+  /**
+   * Measure CPU and memory usage for a process
+   */
+  async measureProcessResources(process2) {
+    try {
+      if (!process2.childProcess?.pid) {
+        return;
+      }
+      const pid = process2.childProcess.pid;
+      const now = Date.now();
+      let cpuPercentage = 0;
+      let memoryBytes = 0;
+      try {
+        const { isValidPid } = await import("./security-JI22TBEB.js");
+        if (!isValidPid(pid)) {
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: process2.processId,
+              subsystem: "orchestrator",
+              executionPhase: "execution"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                operation: "measureProcessResources",
+                pid,
+                reason: "Invalid PID detected (security validation failed)"
+              }
+            }
+          );
+          return;
+        }
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        const { stdout } = await execFileAsync("ps", ["-o", "%cpu=,rss=", "-p", String(pid)], {
+          encoding: "utf-8",
+          timeout: 5e3
+        });
+        const result = stdout.trim();
+        if (result) {
+          const parts = result.split(/\s+/);
+          if (parts.length >= 2 && parts[0] && parts[1]) {
+            cpuPercentage = parseFloat(parts[0]) || 0;
+            memoryBytes = (parseInt(parts[1], 10) || 0) * 1024;
+          }
+        }
+      } catch (_error) {
+        return;
+      }
+      const usage = {
+        cpuPercentage,
+        memoryBytes,
+        timestamp: now
+      };
+      process2.lastResourceUsage = usage;
+      if (!process2.resourceHistory) {
+        process2.resourceHistory = [];
+      }
+      process2.resourceHistory.push(usage);
+      if (process2.resourceHistory.length > 60) {
+        process2.resourceHistory.shift();
+      }
+      if (this.config.verbose && (cpuPercentage > 10 || memoryBytes > 100 * 1024 * 1024)) {
+        console.log(
+          chalk.gray(
+            `${process2.processId}: CPU ${cpuPercentage.toFixed(1)}% | Memory ${(memoryBytes / 1024 / 1024).toFixed(1)}MB`
+          )
+        );
+      }
+    } catch (_error) {
+    }
+  }
+  /**
+   * Check resource thresholds and take action if exceeded
+   */
+  async checkResourceThresholds(runningProcesses) {
+    if (runningProcesses.length >= this.config.maxProcessesWarning * 0.8) {
+      console.log(
+        chalk.yellow(
+          `Process count approaching limit: ${runningProcesses.length}/${this.config.maxProcessesWarning}`
+        )
+      );
+    }
+    if (this.totalCpuUsage > this.config.maxCpuPercentage) {
+      console.log(
+        chalk.red(
+          `Total CPU usage exceeded (${this.totalCpuUsage.toFixed(1)}% > ${this.config.maxCpuPercentage}%)`
+        )
+      );
+      const oldest = this.getOldestRunningProcess();
+      if (oldest) {
+        console.log(
+          chalk.yellow(`Killing oldest process to reduce resource usage: ${oldest.processId}`)
+        );
+        await this.terminateProcess(oldest.processId, "resource_limit_exceeded");
+        this.resourcesKilledByMonitor++;
+      }
+    }
+    for (const process2 of runningProcesses) {
+      const memory = process2.lastResourceUsage?.memoryBytes ?? 0;
+      const memoryMB = memory / 1024 / 1024;
+      const cpuPct = process2.lastResourceUsage?.cpuPercentage ?? 0;
+      const sample = {
+        processId: process2.processId,
+        pid: process2.childProcess?.pid ?? 0,
+        timestampMs: Date.now(),
+        rssMB: memoryMB,
+        cpuPct,
+        command: process2.metadata?.command,
+        provider: process2.metadata?.provider,
+        workloadClass: this.inferWorkloadClass(process2)
+      };
+      const decision = MemoryGuardian.getInstance().evaluateProcessSample(sample);
+      if (memoryMB > 1e3 && decision.action !== "kill") {
+        console.log(
+          chalk.gray(
+            `Legacy 1000MB kill suppressed for ${process2.processId} (${memoryMB.toFixed(1)}MB) - Guardian decision: ${decision.action}`
+          )
+        );
+      }
+      if (decision.action === "warn") {
+        console.log(
+          chalk.yellow(
+            `Memory warning for ${process2.processId}: ${decision.reason} (${memoryMB.toFixed(1)}MB)`
+          )
+        );
+      }
+      if (decision.action === "kill") {
+        console.log(
+          chalk.red(
+            `Memory kill for ${process2.processId}: ${decision.reason} (${memoryMB.toFixed(1)}MB, grace=${decision.graceMs}ms)`
+          )
+        );
+        if (decision.graceMs === 0) {
+          await this.terminateProcess(process2.processId, "memory_limit_exceeded");
+        } else {
+          await this.terminateProcessWithGrace(
+            process2.processId,
+            "memory_limit_exceeded",
+            decision.graceMs
+          );
+        }
+        this.resourcesKilledByMonitor++;
+      }
+    }
+    if (runningProcesses.length >= this.config.maxProcessesWarning) {
+      console.log(
+        chalk.red(
+          `Process limit reached (${runningProcesses.length}/${this.config.maxProcessesWarning})`
+        )
+      );
+      const oldest = this.getOldestRunningProcess();
+      if (oldest) {
+        console.log(chalk.yellow(`Killing oldest process: ${oldest.processId}`));
+        await this.terminateProcess(oldest.processId, "process_limit_exceeded");
+        this.resourcesKilledByMonitor++;
+      }
+    }
+  }
+  /**
+   * Get the oldest running process by creation timestamp
+   */
+  getOldestRunningProcess() {
+    const runningProcesses = this.getRunningProcesses();
+    if (runningProcesses.length === 0) {
+      return void 0;
+    }
+    return runningProcesses.reduce((oldest, current) => {
+      return current.createdAt < oldest.createdAt ? current : oldest;
+    });
+  }
+  /**
+   * Infer workload class from process metadata for memory policy decisions.
+   */
+  inferWorkloadClass(process2) {
+    return inferMemoryWorkloadClassFromMetadata(process2.metadata);
+  }
+  /**
+   * Get resource usage statistics
+   */
+  getResourceStats() {
+    return {
+      totalCpuUsage: this.totalCpuUsage,
+      resourcesKilledByMonitor: this.resourcesKilledByMonitor,
+      monitoringInterval: this.config.resourceMonitoringIntervalMs,
+      maxCpuPercentage: this.config.maxCpuPercentage,
+      maxProcessesWarning: this.config.maxProcessesWarning
+    };
+  }
+  /**
+   * Close the process lifecycle manager
+   */
+  async close() {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    if (this.config.verbose) {
+      console.log(chalk.gray("Closing ProcessLifecycleManager..."));
+    }
+    await this.runShutdownCleanup("manager_shutdown");
+    this.processes.clear();
+    this.trackedChildProcesses.clear();
+    if (this.config.verbose) {
+      console.log(chalk.green("ProcessLifecycleManager closed"));
+    }
+  }
+  stopBackgroundTimers() {
+    if (this.resourceMonitoringTimer) {
+      clearInterval(this.resourceMonitoringTimer);
+      this.resourceMonitoringTimer = void 0;
+    }
+    if (this.oldProcessCleanupTimer) {
+      clearInterval(this.oldProcessCleanupTimer);
+      this.oldProcessCleanupTimer = void 0;
+    }
+    for (const [_processId, timer] of this.progressMonitoringTimers) {
+      clearInterval(timer);
+    }
+    this.progressMonitoringTimers.clear();
+    for (const registration of this.processes.values()) {
+      this.clearHardTimeout(registration);
+      if (registration.progressCheckTimers) {
+        for (const timer of registration.progressCheckTimers) {
+          clearTimeout(timer);
+        }
+        registration.progressCheckTimers = void 0;
+      }
+    }
+  }
+  async runShutdownCleanup(reason) {
+    this.stopBackgroundTimers();
+    await this.terminateAll(reason);
+    let cleanupError;
+    try {
+      await this.cleanupAllProcesses();
+    } catch (error) {
+      cleanupError = error;
+    } finally {
+      killAllFallbackTrackedSubprocesses("SIGTERM");
+      killAllFallbackTrackedSubprocesses("SIGKILL");
+      await reapOrphanedTmuxSessions({ includeOwnPid: true });
+    }
+    if (cleanupError) throw cleanupError;
+  }
+  /**
+   * Retained for backward compatibility.
+   * Signal handlers now live in the CLI layer (`exit-handler`).
+   */
+  static cleanupGlobalHandlers() {
+  }
+};
+
+// src/utils/cli-breadcrumbs.ts
+import chalk2 from "chalk";
+var DEFAULT_IDLE_AFTER_MS = 3e4;
+function formatBreadcrumbLine(prefix, label, detail) {
+  const message = detail && detail.trim().length > 0 ? `${prefix}: ${label}: ${detail}` : `${prefix}: ${label}`;
+  return `${chalk2.gray(message)}
+`;
+}
+function createCliBreadcrumb(options) {
+  if (isQuietOutputRequested()) {
+    const handle2 = {
+      markActivity() {
+      },
+      complete() {
+      },
+      fail() {
+      },
+      dispose() {
+      },
+      [Symbol.dispose]() {
+        handle2.dispose();
+      }
+    };
+    return handle2;
+  }
+  const label = options.label.trim();
+  const stream = options.stream ?? process.stderr;
+  const idleAfterMs = typeof options.idleAfterMs === "number" && Number.isFinite(options.idleAfterMs) ? Math.max(0, Math.floor(options.idleAfterMs)) : DEFAULT_IDLE_AFTER_MS;
+  let idleTimer;
+  let disposed = false;
+  const clearIdleTimer = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+  };
+  const emit = (symbol, detail) => {
+    if (disposed) return;
+    stream.write(formatBreadcrumbLine(symbol, label, detail));
+  };
+  const armIdleHeartbeat = () => {
+    clearIdleTimer();
+    if (disposed || idleAfterMs <= 0) return;
+    idleTimer = setTimeout(() => {
+      idleTimer = void 0;
+      emit("Info", "still working...");
+      armIdleHeartbeat();
+    }, idleAfterMs);
+  };
+  emit("Info", options.detail);
+  armIdleHeartbeat();
+  const handle = {
+    markActivity(detail) {
+      if (disposed) return;
+      if (detail) emit("Info", detail);
+      armIdleHeartbeat();
+    },
+    complete(detail) {
+      if (disposed) return;
+      clearIdleTimer();
+      if (detail) emit("OK", detail);
+      disposed = true;
+    },
+    fail(detail) {
+      if (disposed) return;
+      clearIdleTimer();
+      if (detail) emit("Error", detail);
+      disposed = true;
+    },
+    dispose() {
+      if (disposed) return;
+      clearIdleTimer();
+      disposed = true;
+    },
+    [Symbol.dispose]() {
+      handle.dispose();
+    }
+  };
+  return handle;
+}
+
+// src/planning/execution-spec-signals.ts
+function evaluateExecutionSpec(taskDescription) {
+  const hasFillPlaceholders = taskDescription.length > 0 && hasUnfilledMarkers(taskDescription);
+  if (!hasFillPlaceholders) {
+    return null;
+  }
+  const hasAdr = /^##\s*Context/im.test(taskDescription) && /^##\s*Decision/im.test(taskDescription);
+  const hasResearch = /^##\s*Research\s+Questions?/im.test(taskDescription);
+  const hasBug = /^##\s*Reproduction\s+Steps/im.test(taskDescription);
+  const mockBoosts = hasAdr ? [{ kind: "adr" }] : hasResearch ? [{ kind: "research" }] : hasBug ? [{ kind: "reproducibility" }] : [{ kind: "scope" }, { kind: "acceptance" }, { kind: "testing" }];
+  const completeness = validateTaskSpec(taskDescription, mockBoosts);
+  const guidanceTier = calculateGuidanceTier(completeness);
+  return {
+    completenessScore: completeness.score,
+    guidanceTier,
+    missingFields: completeness.missing,
+    hasFillPlaceholders,
+    promptInjection: generatePromptInjection(completeness, guidanceTier)
+  };
+}
+
+// src/core/verification/off-scope-config-edits.ts
+import path from "path";
+var TEST_CONFIG_PATTERNS = [
+  /^phpunit(?:\.dist)?\.xml(?:\.dist)?$/i,
+  /^pytest\.ini$/i,
+  /^tox\.ini$/i,
+  /^\.coveragerc$/i,
+  /^\.rspec$/i,
+  /^codecov\.ya?ml$/i,
+  /^(?:jest|vitest|karma|playwright|cypress)\.config\.[cm]?[jt]s$/i,
+  /^\.mocharc\.(?:json|ya?ml|[cm]?js)$/i
+];
+var AGENT_INSTRUCTION_BASENAMES = /* @__PURE__ */ new Set([
+  "agents.md",
+  "claude.md",
+  "gemini.md",
+  ".mcp.json",
+  "opencode.json",
+  "opencode.jsonc",
+  ".cursorrules",
+  ".windsurfrules"
+]);
+var AGENT_INSTRUCTION_DIRS = [
+  ".claude/",
+  ".cursor/",
+  ".grok/",
+  ".codex/",
+  ".gemini/",
+  ".opencode/",
+  ".kiro/",
+  ".github/instructions/"
+];
+function normalize(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function categoryOf(normalizedPath) {
+  const base = path.posix.basename(normalizedPath);
+  const lowerPath = normalizedPath.toLowerCase();
+  if (AGENT_INSTRUCTION_BASENAMES.has(base.toLowerCase()) || lowerPath === ".github/copilot-instructions.md" || AGENT_INSTRUCTION_DIRS.some((dir) => lowerPath.startsWith(dir) || lowerPath.includes(`/${dir}`))) {
+    return "agent-instruction";
+  }
+  if (TEST_CONFIG_PATTERNS.some((pattern) => pattern.test(base))) return "test-config";
+  if (isDependencyManifestPath(normalizedPath) || manifestKind(base) !== null || isGeneratedLockfilePath(normalizedPath) || /^requirements[\w.-]*\.txt$/i.test(base)) {
+    return "build-manifest";
+  }
+  if (isProjectConfigPath(normalizedPath) && !lowerPath.startsWith(".github/workflows/")) {
+    return "gate-config";
+  }
+  return void 0;
+}
+function findOffScopeConfigEdits(changedPaths, taskText) {
+  const task = taskText.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  const edits = [];
+  for (const raw of changedPaths) {
+    const normalized = normalize(raw);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    const category = categoryOf(normalized);
+    if (!category) continue;
+    const base = path.posix.basename(normalized).toLowerCase();
+    if (task.includes(normalized.toLowerCase()) || task.includes(base)) continue;
+    edits.push({ path: normalized, category });
+  }
+  return edits;
+}
+function formatOffScopeConfigEdits(edits, limit = 8) {
+  const shown = edits.slice(0, limit).map((edit) => `${edit.path} (${edit.category})`);
+  const rest = edits.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")} (+${rest} more)` : shown.join(", ");
+}
+function findGateControllingEdits(edits) {
+  return edits.filter((edit) => edit.category === "test-config" || edit.category === "gate-config");
+}
+function formatGateConfigUnverifiedReason(edits) {
+  return `gate configuration was changed without the task naming it (${formatOffScopeConfigEdits(edits)}), so passing gates do not verify the change`;
+}
+
+// src/core/judge/prompt-spec-summary.ts
+function toPromptSpecSummary(spec) {
+  return {
+    intent: spec.intent,
+    editsRequired: spec.editsRequired,
+    prefersMinimalChange: spec.prefersMinimalChange,
+    testsRequested: spec.testsRequested,
+    testExecutionRequested: spec.testExecutionRequested,
+    isTestIntent: spec.isTestIntent,
+    isAnalysisIntent: spec.isAnalysisIntent,
+    fileTargets: spec.fileConstraint.targets,
+    deliverableSpecified: spec.deliverableConstraint.specified,
+    deliverableTargets: spec.deliverableConstraint.targets,
+    requirementCount: spec.requirements.length
+  };
+}
+
+// src/core/classification/task-profile.ts
+function buildTaskProfile(classification, promptSpec, analysis) {
+  return {
+    classification,
+    promptSpec,
+    analysis,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "1.0"
+  };
+}
+function buildTaskProfileFromPrompt(prompt, options) {
+  const classification = classifyTask(prompt, {
+    stripInjections: options?.stripInjections,
+    variants: options?.variants
+  });
+  const fullSpec = parsePromptSpec(prompt, {
+    analysisMode: options?.analysisMode
+  });
+  const promptSpec = toPromptSpecSummary(fullSpec);
+  const analysis = analyzeTask(prompt);
+  return buildTaskProfile(classification, promptSpec, analysis);
+}
+
+export {
+  ProcessLifecycleManager,
+  findOffScopeConfigEdits,
+  formatOffScopeConfigEdits,
+  findGateControllingEdits,
+  formatGateConfigUnverifiedReason,
+  createCliBreadcrumb,
+  buildTaskProfileFromPrompt,
+  evaluateExecutionSpec
+};
+//# sourceMappingURL=chunk-WMWQEFLN.js.map