pentesting 0.73.2 → 0.73.3

package/dist/main.js

@@ -28,9 +28,12 @@ import {
   formatChallengeAnalysis,
   formatTurnRecord,
   getApiKey,
+  getGlobalRequestCount,
+  getGlobalTokenUsage,
   getModel,
   getNextTurnNumber,
   getServiceContext,
+  getShellSupervisorLifecycleSnapshot,
   getTimeAdaptiveStrategy,
   parseTurnNumbers,
   readJournalSummary,
@@ -39,7 +42,7 @@ import {
   rotateTurnRecords,
   setCurrentTurn,
   writePolicyDocument
-} from "./chunk-BGEXGHPB.js";
+} from "./chunk-BKWCGMSV.js";
 import {
   AGENT_ROLES,
   APP_DESCRIPTION,
@@ -79,13 +82,13 @@ import {
   setActiveSessionRuntime,
   setTorEnabled,
   snapshotToPrompt
-} from "./chunk-KBJPZDIL.js";
+} from "./chunk-UB7RW6LM.js";
 import {
   EXIT_CODES,
   getPipelineConfig,
   getPromptBuilderConfig,
   getPromptSources
-} from "./chunk-YFDJI3GO.js";
+} from "./chunk-GLO6TOJN.js";
 
 // src/platform/tui/main.tsx
 import chalk5 from "chalk";
@@ -300,7 +303,7 @@ import chalk from "chalk";
 import { Box as Box18 } from "ink";
 
 // src/platform/tui/hooks/useAgent.ts
-import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef3 } from "react";
+import { useState as useState6, useEffect as useEffect2, useCallback as useCallback6, useRef as useRef6 } from "react";
 
 // src/engine/events.ts
 var AgentEventEmitter = class {
@@ -1409,7 +1412,7 @@ var makeRotateTurns = (_llm, _opts) => async (_ctx) => {
 };
 var makeSaveSession = (_llm, _opts) => async (ctx) => {
   try {
-    const { saveState: saveState2 } = await import("./persistence-VFIOGTRC.js");
+    const { saveState: saveState2 } = await import("./persistence-2WKQHGOL.js");
     saveState2(ctx.state);
   } catch {
   }
@@ -1734,6 +1737,1080 @@ var session = {
   load: (state) => loadState(state)
 };
 
+// src/agents/main-agent/delegated-task-scheduler.ts
+function getDelegatedTaskPriority(task) {
+  const workerPriority = task.nextWorkerType || task.workerType;
+  if (workerPriority === "shell-supervisor" && task.status === "waiting") return 0;
+  if (workerPriority === "shell-supervisor" && task.status === "running") return 1;
+  if (task.status === "waiting") return 2;
+  return 3;
+}
+function buildSelectionReason(task) {
+  const preferredWorkerType = task.nextWorkerType || task.workerType;
+  if (preferredWorkerType === "shell-supervisor" && task.status === "waiting") {
+    return "Selected first because shell supervision is waiting on an external callback and should be polled before duplicate chains start.";
+  }
+  if (preferredWorkerType === "shell-supervisor" && task.status === "running") {
+    return "Selected first because shell supervision is already active and should stay attached to the existing access path.";
+  }
+  if (task.status === "waiting") {
+    return "Selected because this delegated task is blocked on an external event and needs explicit supervision.";
+  }
+  return "Selected because this delegated task is already running and should progress before opening a fresh chain.";
+}
+function selectDelegatedTaskForResume(activeTasks, autoResumeCounts, lastAutoResumeTaskId) {
+  if (activeTasks.length === 0) {
+    return null;
+  }
+  const rankedTasks = [...activeTasks].sort((left, right) => {
+    const leftCount = autoResumeCounts.get(left.id) || 0;
+    const rightCount = autoResumeCounts.get(right.id) || 0;
+    if (leftCount !== rightCount) {
+      return leftCount - rightCount;
+    }
+    const leftPriority = getDelegatedTaskPriority(left);
+    const rightPriority = getDelegatedTaskPriority(right);
+    if (leftPriority !== rightPriority) {
+      return leftPriority - rightPriority;
+    }
+    if (left.updatedAt !== right.updatedAt) {
+      return left.updatedAt - right.updatedAt;
+    }
+    return left.createdAt - right.createdAt;
+  });
+  const selectedTask = rankedTasks.length > 1 ? rankedTasks.find((task) => task.id !== lastAutoResumeTaskId) || rankedTasks[0] : rankedTasks[0];
+  if (!selectedTask || selectedTask.id === lastAutoResumeTaskId) {
+    return null;
+  }
+  return {
+    task: selectedTask,
+    preferredWorkerType: selectedTask.nextWorkerType || selectedTask.workerType,
+    reason: buildSelectionReason(selectedTask),
+    resumeCount: autoResumeCounts.get(selectedTask.id) || 0
+  };
+}
+
+// src/agents/main-agent/delegated-task-queue.ts
+var DelegatedTaskQueue = class {
+  lastTaskId = null;
+  resumeCounts = /* @__PURE__ */ new Map();
+  reset() {
+    this.lastTaskId = null;
+    this.resumeCounts.clear();
+  }
+  sync(activeTasks) {
+    const activeIds = new Set(activeTasks.map((task) => task.id));
+    if (activeTasks.length === 0) {
+      this.reset();
+      return;
+    }
+    for (const taskId of this.resumeCounts.keys()) {
+      if (!activeIds.has(taskId)) {
+        this.resumeCounts.delete(taskId);
+      }
+    }
+    if (this.lastTaskId && !activeIds.has(this.lastTaskId)) {
+      this.lastTaskId = null;
+    }
+  }
+  next(activeTasks) {
+    this.sync(activeTasks);
+    return selectDelegatedTaskForResume(activeTasks, this.resumeCounts, this.lastTaskId);
+  }
+  acknowledge(taskId) {
+    this.lastTaskId = taskId;
+    const nextCount = (this.resumeCounts.get(taskId) || 0) + 1;
+    this.resumeCounts.set(taskId, nextCount);
+    return nextCount;
+  }
+  getLastTaskId() {
+    return this.lastTaskId;
+  }
+};
+
+// src/agents/main-agent/delegated-execution-plan.ts
+function getPhaseFromContext(context, key) {
+  if (!context) {
+    return null;
+  }
+  const match = context.match(new RegExp(`${key}=([a-z_]+)`));
+  return match?.[1] ?? null;
+}
+function getRecommendedBoundedTool(request) {
+  if (request.workerType === "shell-supervisor") {
+    const phase = getPhaseFromContext(request.context, "shell_phase");
+    if (phase === "listener_waiting") return "listener_status";
+    if (phase === "listener_callback_detected") return "shell_promote";
+    if (phase === "active_shell_stabilizing") return "shell_upgrade";
+    if (phase === "active_shell_stabilized" || phase === "post_exploitation_active") return "shell_check";
+    return null;
+  }
+  if (request.workerType === "exploit") {
+    const phase = getPhaseFromContext(request.context, "exploit_phase");
+    if (phase === "foothold_active") return "exploit_foothold_check";
+    if (phase === "credential_followup") return "exploit_credential_check";
+    if (phase === "artifact_ready") return "exploit_artifact_check";
+    return null;
+  }
+  if (request.workerType === "pwn") {
+    const phase = getPhaseFromContext(request.context, "pwn_phase");
+    if (phase === "offset_known") return "pwn_offset_check";
+    if (phase === "crash_iteration") return "pwn_crash_repro";
+    if (phase === "payload_iteration") return "pwn_payload_smoke";
+    return null;
+  }
+  return null;
+}
+function buildDelegatedExecutionPlan(request) {
+  if (request.workerType === "shell-supervisor") {
+    const phase = getPhaseFromContext(request.context, "shell_phase");
+    if (phase === "listener_waiting") return "Poll the listener and promote immediately if a callback appears.";
+    if (phase === "listener_callback_detected") return "Promote the callback path and validate the resulting shell.";
+    if (phase === "active_shell_stabilizing") return "Finish PTY stabilization before broader post-exploitation.";
+    if (phase === "active_shell_stabilized") return "Reuse the stabilized shell for controlled enumeration.";
+    if (phase === "post_exploitation_active") return "Continue post-exploitation through the existing shell rather than opening a new chain.";
+    return "Continue supervising the current shell/listener chain first.";
+  }
+  if (request.workerType === "exploit") {
+    const phase = getPhaseFromContext(request.context, "exploit_phase");
+    if (phase === "foothold_active") return "Reuse the existing foothold and prefer exploit_foothold_check for bounded access validation.";
+    if (phase === "credential_followup") return "Validate and reuse the obtained credentials or tokens, preferring exploit_credential_check for bounded probes.";
+    if (phase === "artifact_ready") return "Validate the current exploit artifact, preferring exploit_artifact_check before building a replacement.";
+    return "Continue the strongest surviving exploit vector and preserve branch evidence.";
+  }
+  if (request.workerType === "pwn") {
+    const phase = getPhaseFromContext(request.context, "pwn_phase");
+    if (phase === "foothold_active") return "Reuse the achieved execution foothold and continue from there.";
+    if (phase === "offset_known") return "Resume from the known offset and latest payload revision, preferring pwn_offset_check for bounded verification.";
+    if (phase === "crash_iteration") return "Reproduce the latest crash and continue debugging from the preserved crash state, preferring pwn_crash_repro.";
+    return "Continue the active payload-design loop with narrower iterations, preferring pwn_payload_smoke for the next bounded test.";
+  }
+  return "Continue the selected delegated chain before starting unrelated work.";
+}
+
+// src/agents/main-agent/exploit-lifecycle.ts
+function getReplayableExploitCommand(task) {
+  const candidates = [task.resumeHint || "", ...task.tried, ...task.findings, task.summary].map((value) => value.trim()).filter(Boolean);
+  return candidates.find(
+    (candidate) => candidate.includes("curl ") || candidate.includes("hydra ") || candidate.includes("sqlmap ") || candidate.includes("psql ") || candidate.includes("mysql ") || candidate.includes("ssh ") || candidate.includes("ftp ") || candidate.includes("smbclient ") || candidate.includes("xfreerdp ") || candidate.includes("evil-winrm ")
+  ) || null;
+}
+function hasCredentialLoot(task) {
+  return task.loot.some((item) => {
+    const normalized = item.toLowerCase();
+    return normalized.includes("password") || normalized.includes("credential") || normalized.includes("hash") || normalized.includes("token") || normalized.includes("key");
+  });
+}
+function hasFoothold(task) {
+  return task.sessions.length > 0 || task.assets.some((asset) => {
+    const normalized = asset.toLowerCase();
+    return normalized.includes("shell:") || normalized.includes("stabilized_shell:") || normalized.includes("post_exploitation_shell:") || normalized.includes("listener:") || normalized.includes("session:") || normalized.includes("foothold");
+  });
+}
+function getArtifactPath(task) {
+  for (const asset of task.assets) {
+    const trimmed = asset.trim();
+    const artifactMatch = trimmed.match(/^artifact:(.+)$/i);
+    if (artifactMatch?.[1]) {
+      return artifactMatch[1].trim();
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("./")) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function getExploitLifecycleSnapshot(task) {
+  const replayableCommand = getReplayableExploitCommand(task);
+  if (hasFoothold(task)) {
+    return {
+      phase: "foothold_active",
+      recommendation: "A foothold already exists. Reuse the current access path and continue the exploit chain from that foothold.",
+      boundedTool: "exploit_foothold_check",
+      boundedCommand: replayableCommand || void 0,
+      boundedTimeout: 4e3,
+      boundedInstruction: "Run one narrow foothold validation step before expanding the exploit chain."
+    };
+  }
+  if (hasCredentialLoot(task)) {
+    return {
+      phase: "credential_followup",
+      recommendation: "Credentials or tokens exist. Prioritize validation, reuse, and pivot from the current exploit chain.",
+      boundedTool: "exploit_credential_check",
+      boundedCommand: replayableCommand || void 0,
+      boundedTimeout: 5e3,
+      boundedInstruction: "Run one bounded credential or token validation step before changing exploit vectors."
+    };
+  }
+  if (task.assets.length > 0) {
+    const artifactPath = getArtifactPath(task);
+    return {
+      phase: "artifact_ready",
+      recommendation: "The exploit chain produced reusable artifacts. Validate and advance the current artifact before changing vectors.",
+      boundedTool: "exploit_artifact_check",
+      boundedCommand: artifactPath ? `test -e ${artifactPath} && ls -l ${artifactPath} && file ${artifactPath} 2>/dev/null` : void 0,
+      boundedTimeout: 3e3,
+      boundedInstruction: "Run one bounded artifact validation step before replacing the current artifact."
+    };
+  }
+  return {
+    phase: "vector_active",
+    recommendation: "The current exploit vector is still active. Continue adapting it before switching to a new chain."
+  };
+}
+
+// src/agents/main-agent/pwn-lifecycle.ts
+function joinedEvidence(task) {
+  return [
+    task.summary,
+    task.resumeHint,
+    task.waitingOn,
+    ...task.tried,
+    ...task.findings,
+    ...task.assets
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+function getReplayableCommand(task) {
+  const candidates = [...task.tried, task.resumeHint || "", task.summary].map((value) => value.trim()).filter(Boolean);
+  return candidates.find(
+    (candidate) => /^(?:\.\/|\/|python(?:3)?\b|gdb\b|qemu(?:-[\w-]+)?\b|nc\b)/i.test(candidate) || candidate.includes("pwntools")
+  ) || null;
+}
+function getCandidateBinaryPath(task) {
+  const candidates = [...task.assets, ...task.findings, task.summary].map((value) => value.trim()).filter(Boolean);
+  for (const candidate of candidates) {
+    const artifactMatch = candidate.match(/^artifact:(.+)$/i);
+    const normalized = artifactMatch?.[1]?.trim() || candidate;
+    if (normalized.startsWith("./") || normalized.startsWith("/")) {
+      return normalized;
+    }
+    const embeddedPath = normalized.match(/(\.\/[A-Za-z0-9_./-]+|\/[A-Za-z0-9_./-]+)/);
+    if (embeddedPath?.[1]) {
+      return embeddedPath[1];
+    }
+  }
+  return null;
+}
+function getPwnLifecycleSnapshot(task) {
+  const evidence = joinedEvidence(task);
+  const replayableCommand = getReplayableCommand(task);
+  const binaryPath = getCandidateBinaryPath(task);
+  if (task.sessions.length > 0 || task.assets.some((asset) => {
+    const normalized = asset.toLowerCase();
+    return normalized.includes("shell:") || normalized.includes("stabilized_shell:") || normalized.includes("post_exploitation_shell:");
+  })) {
+    return {
+      phase: "foothold_active",
+      recommendation: "The pwn chain already produced execution. Reuse the existing foothold instead of restarting the exploit loop."
+    };
+  }
+  if (evidence.includes("offset") || evidence.includes("pattern") || evidence.includes("eip") || evidence.includes("rip")) {
+    return {
+      phase: "offset_known",
+      recommendation: "Offsets or control primitives are known. Resume from the latest payload iteration instead of rediscovering the crash.",
+      boundedTool: "pwn_offset_check",
+      boundedCommand: replayableCommand || (binaryPath ? `test -x ${binaryPath} && timeout 5 ${binaryPath} </dev/null` : void 0),
+      boundedTimeout: 5e3,
+      boundedInstruction: "Run one bounded offset verification step against the latest exploit revision."
+    };
+  }
+  if (evidence.includes("crash") || evidence.includes("segfault") || evidence.includes("core")) {
+    return {
+      phase: "crash_iteration",
+      recommendation: "A crash state exists. Preserve it and continue the debug loop from the latest observed crash.",
+      boundedTool: "pwn_crash_repro",
+      boundedCommand: replayableCommand || (binaryPath ? `test -x ${binaryPath} && timeout 5 ${binaryPath} </dev/null` : void 0),
+      boundedTimeout: 1e4,
+      boundedInstruction: "Reproduce the latest crash once and preserve the exact crash state."
+    };
+  }
+  return {
+    phase: "payload_iteration",
+    recommendation: "The pwn loop is still iterating payload design. Continue from the latest payload revision and observations.",
+    boundedTool: "pwn_payload_smoke",
+    boundedCommand: replayableCommand || (binaryPath ? `test -x ${binaryPath} && timeout 5 ${binaryPath} </dev/null` : void 0),
+    boundedTimeout: 5e3,
+    boundedInstruction: "Run one bounded payload smoke test from the latest payload revision."
+  };
+}
+
+// src/agents/main-agent/delegated-task-handoff.ts
+function buildLifecycleSnapshot(decision) {
+  const task = decision.task;
+  if (decision.preferredWorkerType !== "shell-supervisor") {
+    if (decision.preferredWorkerType === "exploit") {
+      return getExploitLifecycleSnapshot(task);
+    }
+    if (decision.preferredWorkerType === "pwn") {
+      return getPwnLifecycleSnapshot(task);
+    }
+    return null;
+  }
+  return getShellSupervisorLifecycleSnapshot();
+}
+function buildDelegatedRequestContext(decision, lifecycleSnapshot) {
+  const task = decision.task;
+  if (!lifecycleSnapshot) {
+    return task.summary;
+  }
+  if (decision.preferredWorkerType === "exploit") {
+    return [
+      task.summary,
+      `exploit_phase=${lifecycleSnapshot.phase}`,
+      `recommendation=${lifecycleSnapshot.recommendation}`
+    ].filter(Boolean).join(" | ");
+  }
+  if (decision.preferredWorkerType === "pwn") {
+    return [
+      task.summary,
+      `pwn_phase=${lifecycleSnapshot.phase}`,
+      `recommendation=${lifecycleSnapshot.recommendation}`
+    ].filter(Boolean).join(" | ");
+  }
+  const shellSnapshot = lifecycleSnapshot;
+  return [
+    task.summary,
+    `shell_phase=${shellSnapshot.phase}`,
+    shellSnapshot.listenerId ? `listener=${shellSnapshot.listenerId}` : "",
+    shellSnapshot.activeShellId ? `active_shell=${shellSnapshot.activeShellId}` : "",
+    `recommendation=${shellSnapshot.recommendation}`
+  ].filter(Boolean).join(" | ");
+}
+function buildDelegatedExecutionRequest(decision, context, lifecycleSnapshot) {
+  const task = decision.task;
+  const preferredWorkerType = decision.preferredWorkerType;
+  const requestTask = task.resumeHint || task.task;
+  const boundedLifecycle = preferredWorkerType === "exploit" || preferredWorkerType === "pwn" ? lifecycleSnapshot : null;
+  return {
+    task: requestTask,
+    workerType: preferredWorkerType,
+    resumeTaskId: task.id,
+    target: task.target,
+    context,
+    boundedTool: preferredWorkerType ? getRecommendedBoundedTool({
+      task: requestTask,
+      workerType: preferredWorkerType,
+      target: task.target,
+      context
+    }) ?? void 0 : void 0,
+    boundedCommand: boundedLifecycle?.boundedCommand,
+    boundedTimeout: boundedLifecycle?.boundedTimeout,
+    boundedInstruction: preferredWorkerType ? boundedLifecycle?.boundedInstruction || buildDelegatedExecutionPlan({
+      task: requestTask,
+      workerType: preferredWorkerType,
+      target: task.target,
+      context
+    }) : void 0
+  };
+}
+function buildDelegatedTaskHandoff(decision) {
+  const task = decision.task;
+  const preferredWorkerType = decision.preferredWorkerType;
+  const lifecycleSnapshot = buildLifecycleSnapshot(decision);
+  const context = buildDelegatedRequestContext(decision, lifecycleSnapshot);
+  const delegatedExecutionRequest = buildDelegatedExecutionRequest(decision, context, lifecycleSnapshot);
+  const executionPlan = buildDelegatedExecutionPlan(delegatedExecutionRequest);
+  const details = [
+    `Resume delegated task: ${task.task}.`,
+    `Delegated task ID: ${task.id}.`,
+    `Scheduler reason: ${decision.reason}`,
+    `Scheduler cycle count: ${decision.resumeCount + 1}.`,
+    `Current status: ${task.status}.`,
+    task.waitingOn ? `Waiting on: ${task.waitingOn}.` : "",
+    task.assets.length > 0 ? `Reuse assets: ${task.assets.join(", ")}.` : "",
+    task.sessions.length > 0 ? `Reuse sessions: ${task.sessions.join(", ")}.` : "",
+    task.resumeHint ? `Resume guidance: ${task.resumeHint}.` : "",
+    preferredWorkerType ? `Preferred worker: ${preferredWorkerType}.` : "",
+    delegatedExecutionRequest.boundedTool ? `Bounded tool: ${delegatedExecutionRequest.boundedTool}.` : "",
+    delegatedExecutionRequest.boundedCommand ? `Bounded command candidate: ${delegatedExecutionRequest.boundedCommand}.` : "",
+    preferredWorkerType ? `Delegation policy: if this requires multi-step follow-up, call run_task with worker_type="${preferredWorkerType}" and resume_task_id="${task.id}" for this selected task before creating any unrelated delegated chain.` : "",
+    `Execution hint: ${executionPlan}`,
+    "Execution policy: continue the selected delegated chain first. Do not switch to a different active delegated task until this one is advanced or invalidated.",
+    "Goal: continue the existing chain instead of creating a duplicate operation."
+  ].filter(Boolean);
+  return {
+    shouldForwardToMain: true,
+    forwardedInput: details.join(" "),
+    directResponse: "",
+    shouldWritePolicy: false,
+    policyDocument: "",
+    policyUpdateSummary: "",
+    insightSummary: `Auto-resume delegated task ${task.id} via handoff builder.`,
+    delegatedExecutionRequest,
+    success: true
+  };
+}
+
+// src/agents/main-agent/exploit-runtime-signals.ts
+function outputContainsAny(output, patterns) {
+  return patterns.some((pattern) => output.includes(pattern.toLowerCase()));
+}
+function getExploitResultSignals(result) {
+  const output = (result.output || "").toLowerCase();
+  const hasSession = outputContainsAny(output, ["[sessions]", "shell", "session"]);
+  const hasLoot = outputContainsAny(output, ["[loot]", "password", "credential", "token", "hash"]);
+  const hasAsset = outputContainsAny(output, ["[assets]", "artifact", "file", "payload"]);
+  return {
+    hasSession,
+    hasLoot,
+    hasAsset,
+    indicatesProgress: hasSession || hasLoot || hasAsset || outputContainsAny(output, ["[status] running", "[status] success"])
+  };
+}
+function buildExploitExecutionAnalysis(phase, signals) {
+  if (signals.hasSession) {
+    return {
+      phaseObservation: "exploit chain produced a foothold or authenticated session",
+      nextHint: "reuse the current foothold and continue from the confirmed access path"
+    };
+  }
+  if (phase === "credential_followup") {
+    return {
+      phaseObservation: signals.hasLoot ? "credential follow-up produced reusable credential material" : "credential follow-up step executed",
+      nextHint: "reuse validated credentials before changing exploit vectors"
+    };
+  }
+  if (phase === "artifact_ready") {
+    return {
+      phaseObservation: signals.hasAsset ? "artifact validation produced a reusable artifact or asset" : "artifact validation step executed",
+      nextHint: "advance the current artifact before replacing it"
+    };
+  }
+  return {
+    phaseObservation: signals.indicatesProgress ? "exploit chain advanced and produced follow-up signals" : "delegated exploit step executed",
+    nextHint: "continue the selected exploit chain before switching vectors"
+  };
+}
+
+// src/agents/main-agent/pwn-runtime-signals.ts
+function outputContainsAny2(output, patterns) {
+  return patterns.some((pattern) => output.includes(pattern.toLowerCase()));
+}
+function getPwnResultSignals(result) {
+  const output = (result.output || "").toLowerCase();
+  const hasFoothold2 = outputContainsAny2(output, ["[sessions]", "shell", "uid=", "got shell"]);
+  const stillCrashing = outputContainsAny2(output, ["crash", "segfault", "core"]);
+  const hasFindings = outputContainsAny2(output, ["[findings]", "rip controlled", "offset", "eip", "pc controlled"]);
+  return {
+    hasFoothold: hasFoothold2,
+    stillCrashing,
+    hasFindings,
+    indicatesProgress: hasFoothold2 || hasFindings || outputContainsAny2(output, ["[status] running", "[status] success", "[nextworker] pwn"])
+  };
+}
+function buildPwnExecutionAnalysis(phase, signals) {
+  if (signals.hasFoothold) {
+    return {
+      phaseObservation: "pwn chain achieved code execution or an interactive foothold",
+      nextHint: "reuse the achieved foothold and continue from the working exploit state"
+    };
+  }
+  if (phase === "offset_known") {
+    return {
+      phaseObservation: signals.hasFindings ? "offset-guided pwn iteration confirmed control signals" : "offset-guided pwn iteration executed",
+      nextHint: "continue from the known offset and latest payload revision"
+    };
+  }
+  if (phase === "crash_iteration") {
+    return {
+      phaseObservation: signals.stillCrashing ? "crash-driven pwn iteration preserved the crash state" : "crash-driven pwn iteration executed",
+      nextHint: "preserve crash evidence and narrow the next payload iteration"
+    };
+  }
+  return {
+    phaseObservation: signals.indicatesProgress ? "pwn chain advanced and produced follow-up signals" : "delegated pwn step executed",
+    nextHint: "continue the selected exploit-development loop before broadening scope"
+  };
+}
+
+// src/agents/main-agent/delegated-execution-analysis.ts
+function getPhaseFromContext2(context, key) {
+  if (!context) {
+    return null;
+  }
+  const match = context.match(new RegExp(`${key}=([a-z_]+)`));
+  return match?.[1] ?? null;
+}
+function analyzeDelegatedExecutionResult(request, result) {
+  if (!request || !result) {
+    return null;
+  }
+  if (!result.success) {
+    return {
+      phaseObservation: "delegated step failed",
+      nextHint: "retry the same chain only after using the error to narrow the next step"
+    };
+  }
+  if (request.workerType === "shell-supervisor") {
+    const phase = getPhaseFromContext2(request.context, "shell_phase");
+    if (phase === "listener_waiting") {
+      return {
+        phaseObservation: "listener supervision step executed",
+        nextHint: "if callback evidence appeared, promote and validate the shell immediately"
+      };
+    }
+    if (phase === "active_shell_stabilizing") {
+      return {
+        phaseObservation: "shell stabilization step executed",
+        nextHint: "finish PTY stabilization before broader enumeration"
+      };
+    }
+    if (phase === "post_exploitation_active") {
+      return {
+        phaseObservation: "post-exploitation enumeration step executed",
+        nextHint: "continue controlled enumeration through the same shell"
+      };
+    }
+  }
+  if (request.workerType === "exploit") {
+    if (request.boundedTool === "exploit_credential_check") {
+      return {
+        phaseObservation: "bounded credential validation executed for the exploit chain",
+        nextHint: "reuse the validated credentials or convert the access path into a foothold before changing vectors"
+      };
+    }
+    if (request.boundedTool === "exploit_artifact_check") {
+      return {
+        phaseObservation: "bounded artifact validation executed for the exploit chain",
+        nextHint: "advance the validated artifact into data access, authenticated use, or foothold confirmation"
+      };
+    }
+    if (request.boundedTool === "exploit_foothold_check") {
+      return {
+        phaseObservation: "bounded foothold validation executed for the exploit chain",
+        nextHint: "reuse the foothold and continue from the confirmed access path instead of restarting delivery"
+      };
+    }
+    const phase = getPhaseFromContext2(request.context, "exploit_phase");
+    return buildExploitExecutionAnalysis(phase, getExploitResultSignals(result));
+  }
+  if (request.workerType === "pwn") {
+    if (request.boundedTool === "pwn_offset_check") {
+      return {
+        phaseObservation: "bounded offset verification executed for the pwn loop",
+        nextHint: "continue from the known offset and narrow the next payload iteration"
+      };
+    }
+    if (request.boundedTool === "pwn_crash_repro") {
+      return {
+        phaseObservation: "bounded crash reproduction executed for the pwn loop",
+        nextHint: "preserve the crash state and apply the narrowest next debugging or payload mutation step"
+      };
+    }
+    if (request.boundedTool === "pwn_payload_smoke") {
+      return {
+        phaseObservation: "bounded payload smoke test executed for the pwn loop",
+        nextHint: "preserve the last payload revision and continue narrowing the next test"
+      };
+    }
+    const phase = getPhaseFromContext2(request.context, "pwn_phase");
+    return buildPwnExecutionAnalysis(phase, getPwnResultSignals(result));
+  }
+  return {
+    phaseObservation: "delegated step executed",
+    nextHint: "continue the selected delegated chain before switching focus"
+  };
+}
+
+// src/agents/main-agent/delegated-execution-runtime.ts
+var DelegatedExecutionRuntime = class {
+  pendingRequest = null;
+  lastAttemptedSignature = null;
+  lastExecutionResult = null;
+  lastExecutionAnalysis = null;
+  getSignature(request) {
+    if (!request) return null;
+    return JSON.stringify(request);
+  }
+  set(request) {
+    const nextRequest = request || null;
+    const nextSignature = this.getSignature(nextRequest);
+    const currentSignature = this.getSignature(this.pendingRequest);
+    if (nextSignature !== currentSignature) {
+      this.lastAttemptedSignature = null;
+    }
+    this.pendingRequest = nextRequest;
+    if (nextSignature !== currentSignature) {
+      this.lastExecutionResult = null;
+      this.lastExecutionAnalysis = null;
+    }
+  }
+  peek() {
+    return this.pendingRequest;
+  }
+  canAutoExecute() {
+    const pendingSignature = this.getSignature(this.pendingRequest);
+    return pendingSignature !== null && pendingSignature !== this.lastAttemptedSignature;
+  }
+  markAutoExecutionAttempt() {
+    this.lastAttemptedSignature = this.getSignature(this.pendingRequest);
+  }
+  setLastExecutionResult(result) {
+    this.lastExecutionResult = result;
+    this.lastExecutionAnalysis = analyzeDelegatedExecutionResult(this.pendingRequest, result);
+  }
+  consume() {
+    const request = this.pendingRequest;
+    this.pendingRequest = null;
+    this.lastAttemptedSignature = null;
+    this.lastExecutionAnalysis = null;
+    return request;
+  }
+  reset() {
+    this.pendingRequest = null;
+    this.lastAttemptedSignature = null;
+    this.lastExecutionResult = null;
+    this.lastExecutionAnalysis = null;
+  }
+  toPromptFragment() {
+    if (!this.pendingRequest) {
+      return "";
+    }
+    const request = this.pendingRequest;
+    const executionPlan = buildDelegatedExecutionPlan(request);
+    const lines = [
+      "<delegated-execution-request>",
+      `task: ${request.task}`,
+      request.workerType ? `worker_type: ${request.workerType}` : "",
+      request.resumeTaskId ? `resume_task_id: ${request.resumeTaskId}` : "",
+      request.target ? `target: ${request.target}` : "",
+      request.context ? `context: ${request.context}` : "",
+      request.boundedTool ? `bounded_tool: ${request.boundedTool}` : "",
+      request.boundedCommand ? `bounded_command: ${request.boundedCommand}` : "",
+      request.boundedTimeout ? `bounded_timeout: ${request.boundedTimeout}` : "",
+      request.boundedInstruction ? `bounded_instruction: ${request.boundedInstruction}` : "",
+      executionPlan ? `execution_plan: ${executionPlan}` : "",
+      "</delegated-execution-request>"
+    ].filter(Boolean);
+    return lines.join("\n");
+  }
+  toResultFragment() {
+    if (!this.lastExecutionResult) {
+      return "";
+    }
+    const lines = [
+      "<delegated-execution-result>",
+      `success: ${this.lastExecutionResult.success ? "true" : "false"}`,
+      this.lastExecutionResult.error ? `error: ${this.lastExecutionResult.error}` : "",
+      this.lastExecutionResult.output ? `output: ${this.lastExecutionResult.output}` : "",
+      this.lastExecutionAnalysis?.phaseObservation ? `phase_observation: ${this.lastExecutionAnalysis.phaseObservation}` : "",
+      this.lastExecutionAnalysis?.nextHint ? `next_hint: ${this.lastExecutionAnalysis.nextHint}` : "",
+      "</delegated-execution-result>"
+    ].filter(Boolean);
+    return lines.join("\n");
+  }
+};
+
+// src/agents/main-agent/delegated-auto-executor.ts
+function didStatusDetectConnection(result) {
+  const output = result.output || "";
+  return output.includes("CONNECTION DETECTED") || output.includes("Promote to shell");
+}
+function didShellCheckShowStability(result) {
+  const output = (result.output || "").toLowerCase();
+  return output.includes("xterm") || output.includes("rows") || output.includes("columns") || output.includes("/dev/pts/");
+}
+async function executeShellUpgradeSequence(toolRegistry, processId) {
+  const initialCheck = await toolRegistry.execute({
+    name: TOOL_NAMES.SHELL_CHECK,
+    input: {
+      process_id: processId,
+      profile: "stability"
+    }
+  });
+  if (!initialCheck.success || didShellCheckShowStability(initialCheck)) {
+    return initialCheck;
+  }
+  const pythonUpgrade = await toolRegistry.execute({
+    name: TOOL_NAMES.SHELL_UPGRADE,
+    input: {
+      process_id: processId,
+      method: "python_pty"
+    }
+  });
+  if (!pythonUpgrade.success) {
+    return combineToolResults([initialCheck, pythonUpgrade]);
+  }
+  const postPythonCheck = await toolRegistry.execute({
+    name: TOOL_NAMES.SHELL_CHECK,
+    input: {
+      process_id: processId,
+      profile: "stability"
+    }
+  });
+  if (!postPythonCheck.success || didShellCheckShowStability(postPythonCheck)) {
+    return combineToolResults([initialCheck, pythonUpgrade, postPythonCheck]);
+  }
+  const scriptUpgrade = await toolRegistry.execute({
+    name: TOOL_NAMES.SHELL_UPGRADE,
+    input: {
+      process_id: processId,
+      method: "script"
+    }
+  });
+  if (!scriptUpgrade.success) {
+    return combineToolResults([initialCheck, pythonUpgrade, postPythonCheck, scriptUpgrade]);
+  }
+  const finalCheck = await toolRegistry.execute({
+    name: TOOL_NAMES.SHELL_CHECK,
+    input: {
+      process_id: processId,
+      profile: "stability"
+    }
+  });
+  return combineToolResults([initialCheck, pythonUpgrade, postPythonCheck, scriptUpgrade, finalCheck]);
+}
+function combineToolResults(results) {
+  const success = results.every((result) => result.success);
+  return {
+    success,
+    output: results.map((result, index) => `Step ${index + 1}:
+${result.output}`).join("\n\n"),
+    ...success ? {} : {
+      error: results.find((result) => !result.success)?.error || "delegated auto-execution failed"
+    }
+  };
+}
+function buildPatchedContext(context, key, value) {
+  const parts = (context || "").split("|").map((part) => part.trim()).filter(Boolean).filter((part) => !part.startsWith(`${key}=`));
+  parts.push(`${key}=${value}`);
+  return parts.join(" | ");
+}
+function getPhaseFromContext3(context, key) {
+  if (!context) {
+    return null;
+  }
+  const match = context.match(new RegExp(`${key}=([a-z_]+)`));
+  return match?.[1] ?? null;
+}
+function buildRunTaskInput(request, task, workerType, context) {
+  return {
+    name: TOOL_NAMES.RUN_TASK,
+    input: {
+      task,
+      worker_type: workerType,
+      ...request.resumeTaskId ? { resume_task_id: request.resumeTaskId } : {},
+      ...request.target ? { target: request.target } : {},
+      ...context ? { context } : {}
+    }
+  };
+}
+function shouldAutoExecuteDelegatedRequest(request) {
+  if (!request || typeof request.resumeTaskId !== "string") {
+    return false;
+  }
+  if (request.workerType === "shell-supervisor") {
+    return true;
+  }
+  if (request.workerType === "exploit") {
+    const phase = getPhaseFromContext3(request.context, "exploit_phase");
+    return phase === "artifact_ready" || phase === "credential_followup" || phase === "foothold_active";
+  }
+  if (request.workerType === "pwn") {
+    const phase = getPhaseFromContext3(request.context, "pwn_phase");
+    return phase === "offset_known" || phase === "crash_iteration" || phase === "foothold_active" || phase === "payload_iteration";
+  }
+  return false;
+}
+function buildDelegatedRunTaskCall(request) {
+  return {
+    name: TOOL_NAMES.RUN_TASK,
+    input: {
+      task: request.task,
+      ...request.workerType ? { worker_type: request.workerType } : {},
+      ...request.resumeTaskId ? { resume_task_id: request.resumeTaskId } : {},
+      ...request.target ? { target: request.target } : {},
+      ...request.context ? { context: request.context } : {}
+    }
+  };
+}
+function buildBoundedDelegatedToolCall(request) {
+  if (!request.boundedTool || !request.boundedCommand) {
+    return null;
+  }
+  return {
+    name: request.boundedTool,
+    input: {
+      command: request.boundedCommand,
+      ...request.boundedTimeout ? { timeout: request.boundedTimeout } : {}
+    }
+  };
+}
+function buildExploitPhaseRunTaskCall(request) {
+  const phase = getPhaseFromContext3(request.context, "exploit_phase");
+  const phaseTask = phase === "foothold_active" ? "Reuse the existing foothold and continue the exploit chain from the current access path." : phase === "credential_followup" ? "Validate and reuse the obtained credentials or tokens before changing exploit vectors." : phase === "artifact_ready" ? "Validate and advance the current exploit artifact before switching to a different vector." : request.task;
+  return buildRunTaskInput(request, phaseTask, "exploit", request.context);
+}
+function buildExploitFollowupRunTaskCall(request, previousResult) {
+  const phase = getPhaseFromContext3(request.context, "exploit_phase");
+  const signals = previousResult ? getExploitResultSignals(previousResult) : null;
+  const hasSession = signals?.hasSession ?? false;
+  const hasLoot = signals?.hasLoot ?? false;
+  if (phase === "credential_followup" || hasLoot) {
+    return buildRunTaskInput(
+      request,
+      hasSession ? "Reuse the confirmed foothold or authenticated path and continue the exploit chain without restarting delivery." : "If credential reuse succeeded, continue from the confirmed foothold or authenticated path without restarting the exploit chain.",
+      "exploit",
+      buildPatchedContext(request.context, "exploit_phase", hasSession ? "foothold_active" : "credential_followup")
+    );
+  }
+  if (phase === "artifact_ready") {
+    return buildRunTaskInput(
+      request,
+      hasSession ? "A foothold exists from the validated artifact. Reuse it and continue the chain from that access path." : "If the artifact validated successfully, turn it into data extraction, authenticated access, or foothold confirmation before changing vectors.",
+      "exploit",
+      buildPatchedContext(request.context, "exploit_phase", hasSession ? "foothold_active" : "artifact_ready")
+    );
+  }
+  return null;
+}
+function buildPwnPhaseRunTaskCall(request) {
+  const phase = getPhaseFromContext3(request.context, "pwn_phase");
+  const phaseTask = phase === "foothold_active" ? "Reuse the existing execution foothold and continue post-exploitation or objective completion." : phase === "offset_known" ? "Resume the exploit loop from the known offset and latest payload revision." : phase === "crash_iteration" ? "Reproduce the latest crash and continue debugging from the preserved crash state." : request.task;
+  return buildRunTaskInput(request, phaseTask, "pwn", request.context);
+}
+function buildPwnFollowupRunTaskCall(request, previousResult) {
+  const phase = getPhaseFromContext3(request.context, "pwn_phase");
+  const signals = previousResult ? getPwnResultSignals(previousResult) : null;
+  const hasFoothold2 = signals?.hasFoothold ?? false;
+  const stillCrashing = signals?.stillCrashing ?? false;
+  if (phase === "offset_known") {
+    return buildRunTaskInput(
+      request,
+      hasFoothold2 ? "Execution is confirmed. Reuse the achieved foothold and continue from the working exploit state." : "Use the known offset to perform the narrowest next payload smoke test and confirm progress toward execution.",
+      "pwn",
+      buildPatchedContext(request.context, "pwn_phase", hasFoothold2 ? "foothold_active" : "payload_iteration")
+    );
+  }
+  if (phase === "crash_iteration") {
+    return buildRunTaskInput(
+      request,
+      stillCrashing ? "The crash state persists. Apply the narrowest next debugging or payload mutation step from the preserved crash state." : hasFoothold2 ? "Execution is confirmed. Reuse the achieved foothold and continue from the working exploit state." : "Apply the narrowest next debugging or payload mutation step from the preserved crash state.",
+      "pwn",
+      buildPatchedContext(
+        request.context,
+        "pwn_phase",
+        hasFoothold2 ? "foothold_active" : stillCrashing ? "crash_iteration" : "payload_iteration"
+      )
+    );
+  }
+  return null;
+}
+function buildShellSupervisorFastPathCall() {
+  const snapshot = getShellSupervisorLifecycleSnapshot();
+  switch (snapshot.phase) {
+    case "post_exploitation_active":
+      return snapshot.activeShellId ? {
+        name: TOOL_NAMES.SHELL_CHECK,
+        input: {
+          process_id: snapshot.activeShellId,
+          profile: "post"
+        }
+      } : null;
+    case "active_shell_stabilized":
+      return snapshot.activeShellId ? {
+        name: TOOL_NAMES.SHELL_EXEC,
+        input: {
+          process_id: snapshot.activeShellId,
+          command: "pwd && uname -a"
+        }
+      } : null;
+    case "active_shell_stabilizing":
+      return snapshot.activeShellId ? {
+        name: TOOL_NAMES.SHELL_CHECK,
+        input: {
+          process_id: snapshot.activeShellId,
+          profile: "stability"
+        }
+      } : null;
+    case "listener_waiting":
+      return snapshot.listenerId ? {
+        name: TOOL_NAMES.LISTENER_STATUS,
+        input: {
+          process_id: snapshot.listenerId
+        }
+      } : null;
+    case "listener_callback_detected":
+      return snapshot.listenerId ? {
+        name: TOOL_NAMES.SHELL_PROMOTE,
+        input: {
+          process_id: snapshot.listenerId
+        }
+      } : null;
+    case "active_shell_ready":
+      return snapshot.activeShellId ? {
+        name: TOOL_NAMES.SHELL_CHECK,
+        input: {
+          process_id: snapshot.activeShellId,
+          profile: "identity"
+        }
+      } : null;
+    default:
+      return null;
+  }
+}
+async function executeShellSupervisorMiniLoop(toolRegistry) {
+  const snapshot = getShellSupervisorLifecycleSnapshot();
+  if (snapshot.phase === "post_exploitation_active" && snapshot.activeShellId) {
+    const identityResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_CHECK,
+      input: {
+        process_id: snapshot.activeShellId,
+        profile: "identity"
+      }
+    });
+    if (!identityResult.success) {
+      return identityResult;
+    }
+    const environmentResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_CHECK,
+      input: {
+        process_id: snapshot.activeShellId,
+        profile: "environment"
+      }
+    });
+    if (!environmentResult.success) {
+      return combineToolResults([identityResult, environmentResult]);
+    }
+    const networkResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_CHECK,
+      input: {
+        process_id: snapshot.activeShellId,
+        profile: "post"
+      }
+    });
+    return combineToolResults([identityResult, environmentResult, networkResult]);
+  }
+  if (snapshot.phase === "active_shell_stabilizing" && snapshot.activeShellId) {
+    return executeShellUpgradeSequence(toolRegistry, snapshot.activeShellId);
+  }
+  if (snapshot.phase === "listener_waiting" && snapshot.listenerId) {
+    const statusResult = await toolRegistry.execute({
+      name: TOOL_NAMES.LISTENER_STATUS,
+      input: {
+        process_id: snapshot.listenerId
+      }
+    });
+    if (!statusResult.success || !didStatusDetectConnection(statusResult)) {
+      return statusResult;
+    }
+    const promoteResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_PROMOTE,
+      input: {
+        process_id: snapshot.listenerId
+      }
+    });
+    if (!promoteResult.success) {
+      return combineToolResults([statusResult, promoteResult]);
+    }
+    const interactResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_CHECK,
+      input: {
+        process_id: snapshot.listenerId,
+        profile: "identity"
+      }
+    });
+    return combineToolResults([statusResult, promoteResult, interactResult]);
+  }
+  if (snapshot.phase === "listener_callback_detected" && snapshot.listenerId) {
+    const promoteResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_PROMOTE,
+      input: {
+        process_id: snapshot.listenerId
+      }
+    });
+    if (!promoteResult.success) {
+      return promoteResult;
+    }
+    const interactResult = await toolRegistry.execute({
+      name: TOOL_NAMES.SHELL_CHECK,
+      input: {
+        process_id: snapshot.listenerId,
+        profile: "identity"
+      }
+    });
+    return combineToolResults([promoteResult, interactResult]);
+  }
+  const singleCall = buildShellSupervisorFastPathCall();
+  if (!singleCall) {
+    return null;
+  }
+  return toolRegistry.execute(singleCall);
+}
+async function executeExploitMiniLoop(toolRegistry, request) {
+  return executeTwoStepLoop(
+    toolRegistry,
+    buildExploitPhaseRunTaskCall(request),
+    (firstResult) => buildExploitFollowupRunTaskCall(request, firstResult),
+    getExploitResultSignals
+  );
+}
+async function executeExploitDirectBoundedLoop(toolRegistry, request) {
+  const boundedCall = buildBoundedDelegatedToolCall(request);
+  if (!boundedCall) {
+    return executeExploitMiniLoop(toolRegistry, request);
+  }
+  return executeTwoStepLoop(
+    toolRegistry,
+    boundedCall,
+    (firstResult) => buildExploitFollowupRunTaskCall(request, firstResult),
+    getExploitResultSignals
+  );
+}
+async function executePwnMiniLoop(toolRegistry, request) {
+  return executeTwoStepLoop(
+    toolRegistry,
+    buildPwnPhaseRunTaskCall(request),
+    (firstResult) => buildPwnFollowupRunTaskCall(request, firstResult),
+    getPwnResultSignals
+  );
+}
+async function executePwnDirectBoundedLoop(toolRegistry, request) {
+  const boundedCall = buildBoundedDelegatedToolCall(request);
+  if (!boundedCall) {
+    return executePwnMiniLoop(toolRegistry, request);
+  }
+  return executeTwoStepLoop(
+    toolRegistry,
+    boundedCall,
+    (firstResult) => buildPwnFollowupRunTaskCall(request, firstResult),
+    getPwnResultSignals
+  );
+}
+async function executeTwoStepLoop(toolRegistry, firstCall, buildFollowupCall, getSignals) {
+  const firstResult = await toolRegistry.execute(firstCall);
+  if (!firstResult.success) {
+    return firstResult;
+  }
+  const followupCall = buildFollowupCall(firstResult);
+  if (!followupCall || !getSignals(firstResult).indicatesProgress) {
+    return firstResult;
+  }
+  const followupResult = await toolRegistry.execute(followupCall);
+  return combineToolResults([firstResult, followupResult]);
+}
+var DelegatedAutoExecutor = class {
+  canExecutePending(runtime) {
+    return runtime.canAutoExecute() && shouldAutoExecuteDelegatedRequest(runtime.peek());
+  }
+  async executePending(runtime, toolRegistry) {
+    if (!toolRegistry) {
+      return null;
+    }
+    const request = runtime.peek();
+    if (!request || !this.canExecutePending(runtime)) {
+      return null;
+    }
+    runtime.markAutoExecutionAttempt();
+    const result = request.workerType === "shell-supervisor" ? await executeShellSupervisorMiniLoop(toolRegistry) || await toolRegistry.execute(buildDelegatedRunTaskCall(request)) : request.workerType === "exploit" ? await executeExploitDirectBoundedLoop(toolRegistry, request) : request.workerType === "pwn" ? await executePwnDirectBoundedLoop(toolRegistry, request) : await toolRegistry.execute(buildDelegatedRunTaskCall(request));
+    runtime.setLastExecutionResult(result);
+    if (result.success) {
+      runtime.consume();
+    }
+    return result;
+  }
+};
+
 // src/agents/main-agent/main-agent.ts
 var MainAgent = class extends CoreAgent {
   promptBuilder;
@@ -1743,15 +2820,23 @@ var MainAgent = class extends CoreAgent {
   turnCounter = 0;
   userInputQueue = new UserInputQueue();
   pendingInitialUserInput = null;
+  delegatedTaskQueue = new DelegatedTaskQueue();
+  delegatedExecutionRuntime = new DelegatedExecutionRuntime();
+  delegatedAutoExecutor = new DelegatedAutoExecutor();
   pipelineRunner;
   turnCyclePipeline;
   inputProcessor;
   sessionRuntime;
-  constructor(state, events, toolRegistry, approvalGate, scopeGuard) {
-    super(AGENT_ROLES.ORCHESTRATOR, state, events, toolRegistry);
-    this.approvalGate = approvalGate;
-    this.scopeGuard = scopeGuard;
-    this.promptBuilder = new PromptBuilder(state);
+  constructor(options) {
+    super({
+      agentType: AGENT_ROLES.ORCHESTRATOR,
+      state: options.state,
+      events: options.events,
+      toolRegistry: options.toolRegistry
+    });
+    this.approvalGate = options.approvalGate;
+    this.scopeGuard = options.scopeGuard;
+    this.promptBuilder = new PromptBuilder(options.state);
     this.pipelineRunner = new PipelineRunner();
     this.inputProcessor = createInputProcessor(this.llm);
     this.sessionRuntime = createSessionRuntime();
@@ -1766,6 +2851,8 @@ var MainAgent = class extends CoreAgent {
   async execute(userInput) {
     this.userInput = "";
     this.pendingInitialUserInput = userInput;
+    this.delegatedTaskQueue.reset();
+    this.delegatedExecutionRuntime.reset();
     emitStart(this.events, userInput, this.state);
     initializeTask(this.state);
     try {
@@ -1812,6 +2899,12 @@ var MainAgent = class extends CoreAgent {
     const messages = this.collectPendingUserInputs();
     this.pendingInitialUserInput = null;
     if (messages.length === 0) {
+      const autoResume = this.buildAutoResumeResult();
+      if (autoResume) {
+        this.updateObjectiveFromInputProcessor(autoResume);
+        await this.maybeAutoExecuteDelegatedRequest();
+        return autoResume;
+      }
       return { shouldForwardToMain: true };
     }
     const rawInput = messages.map((text, index) => `[${index + 1}] ${text}`).join("\n");
@@ -1834,6 +2927,7 @@ var MainAgent = class extends CoreAgent {
     }
   }
   updateObjectiveFromInputProcessor(result) {
+    this.delegatedExecutionRuntime.set(result.delegatedExecutionRequest);
     if (result.shouldForwardToMain && result.forwardedInput.trim()) {
       this.userInput = this.appendUserInput(this.userInput, result.forwardedInput);
       if (!this.state.hasActiveEngagement()) {
@@ -1875,8 +2969,24 @@ var MainAgent = class extends CoreAgent {
 
 ${next}`;
   }
+  buildAutoResumeResult() {
+    const activeTasks = this.state.getActiveDelegatedTasks();
+    const decision = this.delegatedTaskQueue.next(activeTasks);
+    if (!decision) {
+      return null;
+    }
+    this.delegatedTaskQueue.acknowledge(decision.task.id);
+    return buildDelegatedTaskHandoff(decision);
+  }
   async buildDynamicPrompt(memory) {
-    return this.promptBuilder.build(this.userInput, this.state.getPhase() || PHASES.RECON, memory);
+    const basePrompt = await this.promptBuilder.build(
+      this.userInput,
+      this.state.getPhase() || PHASES.RECON,
+      memory
+    );
+    const delegatedExecutionRequest = this.delegatedExecutionRuntime.toPromptFragment();
+    const delegatedExecutionResult = this.delegatedExecutionRuntime.toResultFragment();
+    return [basePrompt, delegatedExecutionRequest, delegatedExecutionResult].filter(Boolean).join("\n\n");
   }
   // ─── Public API ────────────────────────────────────────────────────────────
   loadPreviousSession() {
@@ -1888,6 +2998,8 @@ ${next}`;
   async resetSession() {
     const result = await resetSessionAction(this.state, this.userInputQueue);
     this.userInput = "";
+    this.delegatedTaskQueue.reset();
+    this.delegatedExecutionRuntime.reset();
     return result;
   }
   setAutoApprove(shouldEnable) {
@@ -1905,6 +3017,22 @@ ${next}`;
   getSessionRuntime() {
     return this.sessionRuntime;
   }
+  getLastDelegatedExecutionRequest() {
+    return this.delegatedExecutionRuntime.peek();
+  }
+  consumeDelegatedExecutionRequest() {
+    return this.delegatedExecutionRuntime.consume();
+  }
+  async executePendingDelegatedRequest() {
+    return this.delegatedAutoExecutor.executePending(this.delegatedExecutionRuntime, this.toolRegistry);
+  }
+  async maybeAutoExecuteDelegatedRequest() {
+    if (!this.delegatedAutoExecutor.canExecutePending(this.delegatedExecutionRuntime)) {
+      return null;
+    }
+    const result = await this.executePendingDelegatedRequest();
+    return result;
+  }
   setScope(allowed, exclusions = []) {
     this.state.setScope({
       allowedCidrs: allowed.filter((a) => a.includes("/")),
@@ -1952,10 +3080,10 @@ ${next}`;
 import fs from "fs";
 import path2 from "path";
 var YamlRuntime = class _YamlRuntime {
-  static build(state, events, toolRegistry, approvalGate, scopeGuard) {
+  static build(options) {
     const cfg = getPipelineConfig();
     _YamlRuntime.setupWorkspace(cfg.workspace);
-    return new MainAgent(state, events, toolRegistry, approvalGate, scopeGuard);
+    return new MainAgent(options);
   }
   static setupWorkspace(workspaceCfg) {
     const directories = workspaceCfg?.directories ?? {};
@@ -1982,11 +3110,11 @@ function createMainAgent(shouldAutoApprove = false) {
     approvalGate,
     events
   );
-  return YamlRuntime.build(state, events, toolRegistry, approvalGate, scopeGuard);
+  return YamlRuntime.build({ state, events, toolRegistry, approvalGate, scopeGuard });
 }
 
 // src/platform/tui/hooks/useAgentState.ts
-import { useState, useRef, useCallback } from "react";
+import { useState as useState5, useRef as useRef4, useCallback as useCallback5 } from "react";
 
 // src/platform/tui/constants/limits.ts
 var TUI_DISPLAY_LIMITS = {
@@ -2054,27 +3182,6 @@ var TUI_DISPLAY_LIMITS = {
   maxStoppedProcesses: 3
 };
 
-// src/platform/tui/types.ts
-var DEFAULT_LIVE_PROGRESS = {
-  mode: "idle",
-  stage: "",
-  detail: "",
-  activeTool: "",
-  reasoningPreview: "",
-  responsePreview: ""
-};
-var DEFAULT_FOOTER_DISPLAY_CONFIG = {
-  showTarget: true,
-  showCounts: true,
-  showHints: true,
-  showQueue: true,
-  showWindow: true,
-  showTurn: true,
-  showContext: true,
-  showTokens: true,
-  showRuntime: true
-};
-
 // src/platform/tui/utils/format.ts
 function truncate(text, width) {
   if (width <= 0) return "";
@@ -2126,6 +3233,47 @@ var formatInlineStatus = () => {
   return JSON.stringify(statusData);
 };
 
+// src/platform/tui/hooks/useAgentState/useMessages.ts
+import { useState, useCallback } from "react";
+function useMessages() {
+  const [messages, setMessages] = useState([]);
+  const addMessage = useCallback((type, content) => {
+    const id = generateId();
+    setMessages((prev) => {
+      const next = [...prev, { id, type, content, timestamp: /* @__PURE__ */ new Date() }];
+      if (next.length > TUI_DISPLAY_LIMITS.MAX_MESSAGES) {
+        return next.slice(next.length - TUI_DISPLAY_LIMITS.MAX_MESSAGES);
+      }
+      return next;
+    });
+  }, []);
+  return { messages, setMessages, addMessage };
+}
+
+// src/platform/tui/hooks/useAgentState/useTimer.ts
+import { useState as useState2, useRef, useCallback as useCallback2 } from "react";
+function useTimer() {
+  const [elapsedTime, setElapsedTime] = useState2(0);
+  const startTimeRef = useRef(0);
+  const manageTimer = useCallback2((action) => {
+    if (action === "start") {
+      startTimeRef.current = Date.now();
+      setElapsedTime(0);
+    } else {
+      const startedAt = startTimeRef.current;
+      if (startedAt > 0) {
+        setElapsedTime(Math.max(0, Math.floor((Date.now() - startedAt) / 1e3)));
+      } else {
+        setElapsedTime(0);
+      }
+    }
+  }, []);
+  return { elapsedTime, setElapsedTime, manageTimer };
+}
+
+// src/platform/tui/hooks/useAgentState/useInputBroker.ts
+import { useState as useState3, useCallback as useCallback3, useRef as useRef2 } from "react";
+
 // src/platform/tui/utils/input-request-broker.ts
 function createInputRequestBrokerState() {
   return {
@@ -2175,7 +3323,61 @@ function clearAllInputRequests(state) {
   return pending;
 }
 
-// src/platform/tui/hooks/useAgentState.ts
+// src/platform/tui/hooks/useAgentState/useInputBroker.ts
+function useInputBroker() {
+  const [inputBroker, setInputBroker] = useState3(
+    createInputRequestBrokerState()
+  );
+  const inputBrokerRef = useRef2(inputBroker);
+  inputBrokerRef.current = inputBroker;
+  const enqueueInputRequest2 = useCallback3((request) => {
+    setInputBroker((prev) => enqueueInputRequest(prev, request));
+  }, []);
+  const settleActiveInputRequest = useCallback3((value) => {
+    const current = inputBrokerRef.current;
+    if (current.active.status !== "active") return;
+    current.active.resolve(value);
+    setInputBroker(resolveActiveInputRequest(current).nextState);
+  }, []);
+  const cancelAllInputRequests = useCallback3(() => {
+    const current = inputBrokerRef.current;
+    const pending = clearAllInputRequests(current);
+    for (const request of pending) request.resolve(null);
+    setInputBroker(createInputRequestBrokerState());
+  }, []);
+  return {
+    inputBroker,
+    enqueueInputRequest: enqueueInputRequest2,
+    settleActiveInputRequest,
+    cancelAllInputRequests
+  };
+}
+
+// src/platform/tui/hooks/useAgentState/useLiveProgress.ts
+import { useState as useState4, useCallback as useCallback4 } from "react";
+
+// src/platform/tui/types.ts
+var DEFAULT_LIVE_PROGRESS = {
+  mode: "idle",
+  stage: "",
+  detail: "",
+  activeTool: "",
+  reasoningPreview: "",
+  responsePreview: ""
+};
+var DEFAULT_FOOTER_DISPLAY_CONFIG = {
+  showTarget: true,
+  showCounts: true,
+  showHints: true,
+  showQueue: true,
+  showWindow: true,
+  showTurn: true,
+  showContext: true,
+  showTokens: true,
+  showRuntime: true
+};
+
+// src/platform/tui/hooks/useAgentState/useLiveProgress.ts
 function sanitizeLiveProgress(progress) {
   return {
     mode: progress.mode,
@@ -2186,87 +3388,57 @@ function sanitizeLiveProgress(progress) {
     responsePreview: truncate(progress.responsePreview, TUI_DISPLAY_LIMITS.LIVE_PROGRESS_TEXT_MAX)
   };
 }
-var useAgentState = (isTyping = false) => {
-  const [messages, setMessages] = useState([]);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [currentStatusState, setCurrentStatusState] = useState("");
-  const [elapsedTime, setElapsedTime] = useState(0);
-  const [retryState, setRetryState] = useState({ status: "idle" });
-  const [currentTokens, setCurrentTokens] = useState(0);
-  const [inputBroker, setInputBroker] = useState(
-    createInputRequestBrokerState()
-  );
-  const [stats, setStats] = useState({ phase: DEFAULTS.INIT_PHASE, targets: 0, findings: 0, todo: 0, targetLabel: "" });
-  const [turnCount, setTurnCount] = useState(0);
-  const [liveProgressState, setLiveProgressState] = useState(DEFAULT_LIVE_PROGRESS);
-  const startTimeRef = useRef(0);
-  const inputBrokerRef = useRef(createInputRequestBrokerState());
-  inputBrokerRef.current = inputBroker;
-  const retryCountdownRef = useRef(null);
-  const retryCountRef = useRef(0);
-  const tokenAccumRef = useRef(0);
-  const lastStepTokensRef = useRef(0);
-  const toolStartedAtRef = useRef(0);
-  const addMessage = useCallback((type, content) => {
-    const id = generateId();
-    setMessages((prev) => {
-      const next = [...prev, { id, type, content, timestamp: /* @__PURE__ */ new Date() }];
-      if (next.length > TUI_DISPLAY_LIMITS.MAX_MESSAGES) {
-        return next.slice(next.length - TUI_DISPLAY_LIMITS.MAX_MESSAGES);
-      }
-      return next;
-    });
-  }, []);
-  const setCurrentStatus = useCallback((value) => {
-    setCurrentStatusState(truncate(value, TUI_DISPLAY_LIMITS.STATUS_TEXT_MAX));
-  }, []);
-  const setLiveProgress = useCallback((value) => {
+function useLiveProgress() {
+  const [liveProgress, setLiveProgressState] = useState4(DEFAULT_LIVE_PROGRESS);
+  const setLiveProgress = useCallback4((value) => {
     setLiveProgressState((prev) => {
       const next = typeof value === "function" ? value(prev) : value;
       return sanitizeLiveProgress(next);
     });
   }, []);
-  const resetCumulativeCounters = useCallback(() => {
+  return { liveProgress, setLiveProgress };
+}
+
+// src/platform/tui/hooks/useAgentState.ts
+var useAgentState = (isTyping = false) => {
+  const { messages, setMessages, addMessage } = useMessages();
+  const { elapsedTime, setElapsedTime, manageTimer } = useTimer();
+  const { inputBroker, enqueueInputRequest: enqueueInputRequest2, settleActiveInputRequest, cancelAllInputRequests } = useInputBroker();
+  const { liveProgress, setLiveProgress } = useLiveProgress();
+  const [isProcessing, setIsProcessing] = useState5(false);
+  const [currentStatusState, setCurrentStatusState] = useState5("");
+  const [retryState, setRetryState] = useState5({ status: "idle" });
+  const [currentTokens, setCurrentTokens] = useState5(0);
+  const [stats, setStats] = useState5({ phase: DEFAULTS.INIT_PHASE, targets: 0, findings: 0, todo: 0, targetLabel: "" });
+  const [turnCount, setTurnCount] = useState5(0);
+  const retryCountdownRef = useRef4(null);
+  const retryCountRef = useRef4(0);
+  const tokenAccumRef = useRef4(0);
+  const lastStepTokensRef = useRef4(0);
+  const toolStartedAtRef = useRef4(0);
+  const setCurrentStatus = useCallback5((value) => {
+    setCurrentStatusState(truncate(value, TUI_DISPLAY_LIMITS.STATUS_TEXT_MAX));
+  }, []);
+  const resetCumulativeCounters = useCallback5(() => {
     setCurrentTokens(0);
     retryCountRef.current = 0;
     tokenAccumRef.current = 0;
     lastStepTokensRef.current = 0;
-    setLiveProgress(DEFAULT_LIVE_PROGRESS);
-  }, []);
-  const manageTimer = useCallback((action) => {
-    if (action === "start") {
-      startTimeRef.current = Date.now();
-      setElapsedTime(0);
-    } else {
-      const startedAt = startTimeRef.current;
-      if (startedAt > 0) {
-        setElapsedTime(Math.max(0, Math.floor((Date.now() - startedAt) / 1e3)));
-      } else {
-        setElapsedTime(0);
-      }
-    }
-  }, []);
-  const clearAllTimers = useCallback(() => {
+    setLiveProgress({
+      mode: "thinking",
+      stage: "",
+      detail: "",
+      activeTool: "",
+      reasoningPreview: "",
+      responsePreview: ""
+    });
+  }, [setLiveProgress]);
+  const clearAllTimers = useCallback5(() => {
     if (retryCountdownRef.current) {
       clearInterval(retryCountdownRef.current);
       retryCountdownRef.current = null;
     }
   }, []);
-  const enqueueInputRequest2 = useCallback((request) => {
-    setInputBroker((prev) => enqueueInputRequest(prev, request));
-  }, []);
-  const settleActiveInputRequest = useCallback((value) => {
-    const current = inputBrokerRef.current;
-    if (current.active.status !== "active") return;
-    current.active.resolve(value);
-    setInputBroker(resolveActiveInputRequest(current).nextState);
-  }, []);
-  const cancelAllInputRequests = useCallback(() => {
-    const current = inputBrokerRef.current;
-    const pending = clearAllInputRequests(current);
-    for (const request of pending) request.resolve(null);
-    setInputBroker(createInputRequestBrokerState());
-  }, []);
   return {
     // State
     messages,
@@ -2286,7 +3458,7 @@ var useAgentState = (isTyping = false) => {
     setStats,
     turnCount,
     setTurnCount,
-    liveProgress: liveProgressState,
+    liveProgress,
     setLiveProgress,
     // Refs (external consumers only)
     retryCountdownRef,
@@ -2294,8 +3466,6 @@ var useAgentState = (isTyping = false) => {
     tokenAccumRef,
     lastStepTokensRef,
     toolStartedAtRef,
-    // WHY timerRef excluded: internal to manageTimer/clearAllTimers only,
-    // no external consumer exists.
     // Helpers
     addMessage,
     resetCumulativeCounters,
@@ -2308,7 +3478,7 @@ var useAgentState = (isTyping = false) => {
 };
 
 // src/platform/tui/hooks/useAgentEvents/index.ts
-import { useEffect, useRef as useRef2 } from "react";
+import { useEffect, useRef as useRef5 } from "react";
 
 // src/platform/tui/constants/styles.ts
 var MESSAGE_STYLES = {
@@ -2967,7 +4137,7 @@ var useAgentEvents = (agent, eventsRef, state, isTyping = false) => {
     lastStepTokensRef,
     setCurrentTokens
   } = state;
-  const reasoningBufferRef = useRef2("");
+  const reasoningBufferRef = useRef5("");
   const getTargetLabel = () => {
     const firstTarget = agent.getState().getAllTargets()[0];
     return firstTarget?.hostname || firstTarget?.ip || "";
@@ -3076,8 +4246,8 @@ function trimQueuedMessages(queue, maxLength, maxItems) {
   return trimmed.slice(trimmed.length - maxItems);
 }
 var useAgent = (shouldAutoApprove, target, isTyping = false) => {
-  const [agent] = useState2(() => createMainAgent(shouldAutoApprove));
-  const eventsRef = useRef3(agent.getEventEmitter());
+  const [agent] = useState6(() => createMainAgent(shouldAutoApprove));
+  const eventsRef = useRef6(agent.getEventEmitter());
   const state = useAgentState(isTyping);
   const {
     messages,
@@ -3102,9 +4272,9 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
     settleActiveInputRequest,
     cancelAllInputRequests
   } = state;
-  const [messageQueue, setMessageQueue] = useState2([]);
-  const messageQueueLengthRef = useRef3(0);
-  const setMessageQueueSafe = useCallback2((value) => {
+  const [messageQueue, setMessageQueue] = useState6([]);
+  const messageQueueLengthRef = useRef6(0);
+  const setMessageQueueSafe = useCallback6((value) => {
     setMessageQueue((prev) => {
       const next = typeof value === "function" ? value(prev) : value;
       return trimQueuedMessages(
@@ -3141,8 +4311,8 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
     };
   }, [agent, addMessage, setMessageQueueSafe]);
   useAgentEvents(agent, eventsRef, state, isTyping);
-  const abortedRef = useRef3(false);
-  const executeTask = useCallback2(async (task) => {
+  const abortedRef = useRef6(false);
+  const executeTask = useCallback6(async (task) => {
     let currentTask = task;
     while (true) {
       abortedRef.current = false;
@@ -3188,7 +4358,7 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
       }
     }
   }, [agent, addMessage, manageTimer, resetCumulativeCounters, setIsProcessing, setCurrentStatus, setTurnCount]);
-  const abort = useCallback2(() => {
+  const abort = useCallback6(() => {
     abortedRef.current = true;
     agent.abort();
     setIsProcessing(false);
@@ -3196,21 +4366,21 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
     setCurrentStatus("");
     addMessage("system", UI_MESSAGES.INTERRUPTED);
   }, [agent, addMessage, manageTimer, setIsProcessing, setCurrentStatus]);
-  const recallQueuedInput = useCallback2(() => {
+  const recallQueuedInput = useCallback6(() => {
     const recalled = agent.dequeueLastUserInput();
     if (!recalled) return null;
     return recalled;
   }, [agent]);
-  const inputRequestRef = useRef3(inputRequest);
+  const inputRequestRef = useRef6(inputRequest);
   inputRequestRef.current = inputRequest;
-  const cancelInputRequest = useCallback2(() => {
+  const cancelInputRequest = useCallback6(() => {
     const ir = inputRequestRef.current;
     if (ir.status === "active") {
       settleActiveInputRequest(null);
       addMessage("system", UI_MESSAGES.INPUT_CANCELLED);
     }
   }, [settleActiveInputRequest, addMessage]);
-  const refreshStats = useCallback2(() => {
+  const refreshStats = useCallback6(() => {
     const s = agent.getState();
     setStats({
       phase: s.getPhase() || PHASES.RECON,
@@ -3248,7 +4418,7 @@ var useAgent = (shouldAutoApprove, target, isTyping = false) => {
 };
 
 // src/platform/tui/hooks/commands/index.ts
-import { useCallback as useCallback3, useMemo } from "react";
+import { useCallback as useCallback7, useMemo } from "react";
 
 // src/platform/tui/constants/commands.ts
 var COMMAND_DEFINITIONS = [
@@ -3826,7 +4996,7 @@ var useCommands = (props) => {
     ...createDisplayCommands(ctx),
     ...createToggleCommands(ctx)
   }), [ctx]);
-  const handleCommand = useCallback3(async (cmd, args) => {
+  const handleCommand = useCallback7(async (cmd, args) => {
     const handler = handlers[cmd];
     if (handler) {
       await handler(args);
@@ -3838,15 +5008,15 @@ var useCommands = (props) => {
 };
 
 // src/platform/tui/hooks/useKeyboardShortcuts.ts
-import { useCallback as useCallback6, useEffect as useEffect4 } from "react";
+import { useCallback as useCallback10, useEffect as useEffect4 } from "react";
 import { useInput } from "ink";
 
 // src/platform/tui/hooks/keyboard/useDoubleTap.ts
-import { useRef as useRef4, useCallback as useCallback4, useEffect as useEffect3 } from "react";
+import { useRef as useRef7, useCallback as useCallback8, useEffect as useEffect3 } from "react";
 var useDoubleTap = ({ onFirstTap, onSecondTap, windowMs }) => {
-  const timerRef = useRef4(null);
-  const pressedRef = useRef4(false);
-  const trigger = useCallback4(() => {
+  const timerRef = useRef7(null);
+  const pressedRef = useRef7(false);
+  const trigger = useCallback8(() => {
     if (pressedRef.current) {
       if (timerRef.current) clearTimeout(timerRef.current);
       pressedRef.current = false;
@@ -3861,7 +5031,7 @@ var useDoubleTap = ({ onFirstTap, onSecondTap, windowMs }) => {
       timerRef.current = null;
     }, windowMs);
   }, [onFirstTap, onSecondTap, windowMs]);
-  const reset = useCallback4(() => {
+  const reset = useCallback8(() => {
     if (timerRef.current) clearTimeout(timerRef.current);
     pressedRef.current = false;
     timerRef.current = null;
@@ -3894,7 +5064,7 @@ var useExitHandler = ({
 };
 
 // src/platform/tui/hooks/keyboard/useEscHandler.ts
-import { useCallback as useCallback5 } from "react";
+import { useCallback as useCallback9 } from "react";
 var useEscHandler = ({
   cancelInputRequest,
   abort,
@@ -3917,7 +5087,7 @@ var useEscHandler = ({
     },
     windowMs
   });
-  const handleEsc = useCallback5(() => {
+  const handleEsc = useCallback9(() => {
     if (inputRequestRef.current.status === "active") {
       cancelInputRequest();
       return;
@@ -3963,7 +5133,7 @@ var useKeyboardShortcuts = ({
     inputRef,
     windowMs: DOUBLE_TAP_WINDOW
   });
-  useInput(useCallback6((ch, key) => {
+  useInput(useCallback10((ch, key) => {
     if (isModalOpenRef.current) return;
     if (key.escape) handleEsc();
     if (key.ctrl && ch === "c") handleCtrlC();
@@ -3981,7 +5151,7 @@ var useKeyboardShortcuts = ({
 };
 
 // src/platform/tui/hooks/useAppLogic.ts
-import { useState as useState3, useCallback as useCallback7, useRef as useRef5 } from "react";
+import { useState as useState7, useCallback as useCallback11, useRef as useRef8 } from "react";
 import { useApp } from "ink";
 function sanitizeInput(value) {
   return value.replace(/(?:\x1b)?\[<\d+;\d+;\d+[mM]/g, "").replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/[\x00-\x08\x0B-\x1F\x7F-\x9F]/g, "").trim();
@@ -4005,11 +5175,11 @@ function parseSlashCommandInput(value) {
 var useAppLogic = ({ autoApprove = false, target }) => {
   const { exit } = useApp();
   const { columns: terminalWidth, rows: terminalHeight } = useTerminalSize();
-  const [input, setInput] = useState3("");
-  const [secretInput, setSecretInput] = useState3("");
-  const [autoApproveMode, setAutoApproveMode] = useState3(autoApprove);
-  const [modal, setModal] = useState3({ type: null, content: "", scrollOffset: 0 });
-  const [footerConfig, setFooterConfig] = useState3(DEFAULT_FOOTER_DISPLAY_CONFIG);
+  const [input, setInput] = useState7("");
+  const [secretInput, setSecretInput] = useState7("");
+  const [autoApproveMode, setAutoApproveMode] = useState7(autoApprove);
+  const [modal, setModal] = useState7({ type: null, content: "", scrollOffset: 0 });
+  const [footerConfig, setFooterConfig] = useState7(DEFAULT_FOOTER_DISPLAY_CONFIG);
   const isTyping = input.length > 0 || secretInput.length > 0;
   const {
     agent,
@@ -4035,26 +5205,26 @@ var useAppLogic = ({ autoApprove = false, target }) => {
     addMessage,
     refreshStats
   } = useAgent(autoApproveMode, target, isTyping);
-  const isProcessingRef = useRef5(isProcessing);
+  const isProcessingRef = useRef8(isProcessing);
   isProcessingRef.current = isProcessing;
-  const autoApproveModeRef = useRef5(autoApproveMode);
+  const autoApproveModeRef = useRef8(autoApproveMode);
   autoApproveModeRef.current = autoApproveMode;
-  const inputRequestRef = useRef5(inputRequest);
+  const inputRequestRef = useRef8(inputRequest);
   inputRequestRef.current = inputRequest;
-  const isModalOpenRef = useRef5(!!modal.type);
+  const isModalOpenRef = useRef8(!!modal.type);
   isModalOpenRef.current = !!modal.type;
-  const inputRef = useRef5(input);
+  const inputRef = useRef8(input);
   inputRef.current = input;
-  const clearInput = useCallback7(() => {
+  const clearInput = useCallback11(() => {
     setInput("");
   }, []);
-  const showModal = useCallback7((type, content) => {
+  const showModal = useCallback11((type, content) => {
     setModal({ type, content, scrollOffset: 0 });
   }, []);
-  const closeModal = useCallback7(() => {
+  const closeModal = useCallback11(() => {
     setModal({ type: null, content: "", scrollOffset: 0 });
   }, []);
-  const handleModalScroll = useCallback7((delta) => {
+  const handleModalScroll = useCallback11((delta) => {
     setModal((prev) => {
       const lines = prev.content.split("\n");
       const maxHeight = terminalHeight - TUI_DISPLAY_LIMITS.MODAL_CHROME_HEIGHT;
@@ -4063,12 +5233,19 @@ var useAppLogic = ({ autoApprove = false, target }) => {
       return { ...prev, scrollOffset: newOffset };
     });
   }, [terminalHeight]);
-  const handleExit = useCallback7(() => {
+  const handleExit = useCallback11(() => {
     cancelAllInputRequests();
     cleanupAllProcesses().catch(() => {
     });
     exit();
-    setTimeout(() => process.exit(0), DISPLAY_LIMITS.EXIT_DELAY);
+    setTimeout(() => {
+      const reqs = getGlobalRequestCount();
+      const usage = getGlobalTokenUsage();
+      console.log(`
+[Session Summary] Total LLM Requests: ${reqs} | Tokens In: ${usage.input_tokens} | Tokens Out: ${usage.output_tokens}
+`);
+      process.exit(0);
+    }, DISPLAY_LIMITS.EXIT_DELAY);
   }, [exit, cancelAllInputRequests]);
   const { handleCommand } = useCommands({
     agent,
@@ -4084,10 +5261,10 @@ var useAppLogic = ({ autoApprove = false, target }) => {
     isProcessingRef,
     autoApproveModeRef
   });
-  const handleRecallQueuedInput = useCallback7(() => {
+  const handleRecallQueuedInput = useCallback11(() => {
     return recallQueuedInput();
   }, [recallQueuedInput]);
-  const handleSecretSubmit = useCallback7((value) => {
+  const handleSecretSubmit = useCallback11((value) => {
     const ir = inputRequestRef.current;
     if (ir.status !== "active") return;
     const sanitized = sanitizeInput(value).slice(0, TUI_DISPLAY_LIMITS.MAX_INPUT_CHARS);
@@ -4096,7 +5273,7 @@ var useAppLogic = ({ autoApprove = false, target }) => {
     settleActiveInputRequest(sanitized);
     setSecretInput("");
   }, [addMessage, settleActiveInputRequest]);
-  const handleSubmit = useCallback7(async (value) => {
+  const handleSubmit = useCallback11(async (value) => {
     const trimmed = sanitizeInput(value);
     if (!trimmed) return;
     setInput("");
@@ -4159,11 +5336,11 @@ var useAppLogic = ({ autoApprove = false, target }) => {
 };
 
 // src/platform/tui/hooks/useTerminalSize.ts
-import { useState as useState4, useEffect as useEffect5 } from "react";
+import { useState as useState8, useEffect as useEffect5 } from "react";
 import { useStdout } from "ink";
 function useTerminalSize() {
   const { stdout } = useStdout();
-  const [size, setSize] = useState4({
+  const [size, setSize] = useState8({
     columns: stdout?.columns ?? TUI_DISPLAY_LIMITS.TERMINAL_DEFAULT_COLUMNS,
     rows: stdout?.rows ?? TUI_DISPLAY_LIMITS.TERMINAL_DEFAULT_ROWS
   });
@@ -4185,12 +5362,12 @@ function useTerminalSize() {
 }
 
 // src/platform/tui/hooks/useAnimationTick.tsx
-import { createContext, useContext, useState as useState5, useEffect as useEffect6 } from "react";
+import { createContext, useContext, useState as useState9, useEffect as useEffect6 } from "react";
 import { jsx } from "react/jsx-runtime";
 var ANIM_TICK_MS = 100;
 var AnimationContext = createContext(0);
 var AnimationProvider = ({ children }) => {
-  const [tick, setTick] = useState5(0);
+  const [tick, setTick] = useState9(0);
   useEffect6(() => {
     const timer = setInterval(() => {
       setTick((t) => t + 1);
@@ -4780,10 +5957,10 @@ var MessageList = memo6(({
 import { memo as memo9 } from "react";
 
 // src/platform/tui/hooks/useStatusTimer.ts
-import { useState as useState6, useEffect as useEffect7, useRef as useRef6 } from "react";
+import { useState as useState10, useEffect as useEffect7, useRef as useRef9 } from "react";
 var useStatusTimer = (currentStatus, isProcessing) => {
-  const [statusElapsed, setStatusElapsed] = useState6(0);
-  const lastStatusRef = useRef6("");
+  const [statusElapsed, setStatusElapsed] = useState10(0);
+  const lastStatusRef = useRef9("");
   useEffect7(() => {
     if (!isProcessing || !currentStatus) {
       lastStatusRef.current = "";
@@ -5038,7 +6215,7 @@ var StatusDisplay = memo9(({
 });
 
 // src/platform/tui/components/ChatInput.tsx
-import { useMemo as useMemo4, useCallback as useCallback8, useRef as useRef8, memo as memo10, useState as useState8 } from "react";
+import { useMemo as useMemo4, useCallback as useCallback12, useRef as useRef11, memo as memo10, useState as useState12 } from "react";
 import { Box as Box14, Text as Text15 } from "ink";
 
 // src/platform/tui/components/input/AutocompletePreview.tsx
@@ -5081,7 +6258,7 @@ var AutocompletePreview = ({
 import { Box as Box12, Text as Text13 } from "ink";
 
 // src/platform/tui/components/input/SimpleTextInput.tsx
-import { useState as useState7, useEffect as useEffect8, useRef as useRef7, useMemo as useMemo3 } from "react";
+import { useState as useState11, useEffect as useEffect8, useRef as useRef10, useMemo as useMemo3 } from "react";
 import { Box as Box11, Text as Text12, useInput as useInput2, useStdout as useStdout2 } from "ink";
 import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
 var MOUSE_SEQUENCE_RE = /(?:\x1b)?\[<\d+;\d+;\d+[mM]/g;
@@ -5109,7 +6286,7 @@ var SimpleTextInput = ({
   onSpecialKey
 }) => {
   const chars = useMemo3(() => Array.from(value || ""), [value]);
-  const [cursor, setCursor] = useState7(chars.length);
+  const [cursor, setCursor] = useState11(chars.length);
   const { write } = useStdout2();
   useEffect8(() => {
     write?.("\x1B[?25h");
@@ -5117,12 +6294,12 @@ var SimpleTextInput = ({
       write?.("\x1B[?25l");
     };
   }, [write]);
-  const lastInputRef = useRef7("");
-  const lastInputTimeRef = useRef7(0);
-  const valueRef = useRef7(value || "");
+  const lastInputRef = useRef10("");
+  const lastInputTimeRef = useRef10(0);
+  const valueRef = useRef10(value || "");
   valueRef.current = value || "";
-  const mouseFragmentRef = useRef7("");
-  const cursorRef = useRef7(cursor);
+  const mouseFragmentRef = useRef10("");
+  const cursorRef = useRef10(cursor);
   cursorRef.current = cursor;
   useEffect8(() => {
     setCursor((prev) => {
@@ -5313,40 +6490,40 @@ var ChatInput = memo10(({
   }, [isSlashMode, partialCmd, hasArgs]);
   const showPreview = isSlashMode && !hasArgs && suggestions.length > 0;
   const showCommandHelp = isSlashMode && !hasArgs && suggestions.length === 0 && value.length > 1;
-  const [selectedIdx, setSelectedIdx] = useState8(0);
+  const [selectedIdx, setSelectedIdx] = useState12(0);
   const clampedIdx = Math.min(selectedIdx, Math.max(0, suggestions.length - 1));
-  const selectedIdxRef = useRef8(clampedIdx);
+  const selectedIdxRef = useRef11(clampedIdx);
   selectedIdxRef.current = clampedIdx;
-  const suggestionsRef = useRef8(suggestions);
+  const suggestionsRef = useRef11(suggestions);
   suggestionsRef.current = suggestions;
-  const isSlashModeRef = useRef8(isSlashMode);
+  const isSlashModeRef = useRef11(isSlashMode);
   isSlashModeRef.current = isSlashMode;
-  const hasArgsRef = useRef8(hasArgs);
+  const hasArgsRef = useRef11(hasArgs);
   hasArgsRef.current = hasArgs;
-  const showPreviewRef = useRef8(showPreview);
+  const showPreviewRef = useRef11(showPreview);
   showPreviewRef.current = showPreview;
-  const inputRequestRef = useRef8(inputRequest);
+  const inputRequestRef = useRef11(inputRequest);
   inputRequestRef.current = inputRequest;
-  const onChangeRef = useRef8(onChange);
+  const onChangeRef = useRef11(onChange);
   onChangeRef.current = onChange;
-  const onRecallQueuedInputRef = useRef8(onRecallQueuedInput);
+  const onRecallQueuedInputRef = useRef11(onRecallQueuedInput);
   onRecallQueuedInputRef.current = onRecallQueuedInput;
-  const queuedCountRef = useRef8(queuedCount);
+  const queuedCountRef = useRef11(queuedCount);
   queuedCountRef.current = queuedCount;
-  const latestValueRef = useRef8(value);
+  const latestValueRef = useRef11(value);
   latestValueRef.current = value;
-  const handleLocalChange = useCallback8((newVal) => {
+  const handleLocalChange = useCallback12((newVal) => {
     latestValueRef.current = newVal;
     onChange(newVal);
   }, [onChange]);
-  const latestSecretRef = useRef8(secretInput);
+  const latestSecretRef = useRef11(secretInput);
   latestSecretRef.current = secretInput;
-  const handleSecretChange = useCallback8((newVal) => {
+  const handleSecretChange = useCallback12((newVal) => {
     latestSecretRef.current = newVal;
     setSecretInput(newVal);
   }, [setSecretInput]);
-  const [inputKey, setInputKey] = useState8(0);
-  const completeCommand = useCallback8((idx) => {
+  const [inputKey, setInputKey] = useState12(0);
+  const completeCommand = useCallback12((idx) => {
     const sug = suggestionsRef.current;
     if (!sug.length) return;
     const best = sug[Math.min(idx, sug.length - 1)];
@@ -5356,9 +6533,9 @@ var ChatInput = memo10(({
     setSelectedIdx(0);
     setInputKey((k) => k + 1);
   }, []);
-  const onSubmitRef = useRef8(onSubmit);
+  const onSubmitRef = useRef11(onSubmit);
   onSubmitRef.current = onSubmit;
-  const wrappedOnSubmit = useCallback8((_staleVal) => {
+  const wrappedOnSubmit = useCallback12((_staleVal) => {
     const finalValue = latestValueRef.current;
     if (showPreviewRef.current) {
       const sug = suggestionsRef.current;
@@ -5378,12 +6555,12 @@ var ChatInput = memo10(({
     }
     onSubmitRef.current(finalValue);
   }, [completeCommand]);
-  const onSecretSubmitRef = useRef8(onSecretSubmit);
+  const onSecretSubmitRef = useRef11(onSecretSubmit);
   onSecretSubmitRef.current = onSecretSubmit;
-  const wrappedSecretSubmit = useCallback8((_staleVal) => {
+  const wrappedSecretSubmit = useCallback12((_staleVal) => {
     onSecretSubmitRef.current(latestSecretRef.current);
   }, []);
-  const handleSpecialKey = useCallback8((key) => {
+  const handleSpecialKey = useCallback12((key) => {
     if (inputRequestRef.current.status === "active") return false;
     const sug = suggestionsRef.current;
     const visible = showPreviewRef.current;
@@ -5454,7 +6631,7 @@ var ChatInput = memo10(({
 });
 
 // src/platform/tui/components/footer.tsx
-import { memo as memo11, useState as useState9, useEffect as useEffect9 } from "react";
+import { memo as memo11, useState as useState13, useEffect as useEffect9 } from "react";
 import { Box as Box15, Text as Text16 } from "ink";
 import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
 var SECS_PER_HOUR = 3600;
@@ -5490,7 +6667,7 @@ var Footer = memo11(({
   const { columns } = useTerminalSize();
   const ctxPct = totalTokens > 0 ? Math.round(totalTokens / LLM_LIMITS.streamMaxTokens * 100) : 0;
   const canShowHint = !isProcessing && inputText.length === 0;
-  const [showHint, setShowHint] = useState9(false);
+  const [showHint, setShowHint] = useState13(false);
   useEffect9(() => {
     if (!canShowHint) {
       setShowHint(false);
@@ -5533,7 +6710,7 @@ var Footer = memo11(({
 var footer_default = Footer;
 
 // src/platform/tui/components/Modal.tsx
-import { useMemo as useMemo5, memo as memo12, useCallback as useCallback9, useRef as useRef9 } from "react";
+import { useMemo as useMemo5, memo as memo12, useCallback as useCallback13, useRef as useRef12 } from "react";
 import { Box as Box16, Text as Text17, useInput as useInput3 } from "ink";
 import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
 var MODAL_TITLES = {
@@ -5548,9 +6725,9 @@ var Modal = memo12(({
   onScroll,
   onClose
 }) => {
-  const onScrollRef = useRef9(onScroll);
+  const onScrollRef = useRef12(onScroll);
   onScrollRef.current = onScroll;
-  const onCloseRef = useRef9(onClose);
+  const onCloseRef = useRef12(onClose);
   onCloseRef.current = onClose;
   const { columns, rows } = useTerminalSize();
   const terminalHeight = rows;
@@ -5562,7 +6739,7 @@ var Modal = memo12(({
     () => lines.slice(scrollOffset, scrollOffset + maxHeight),
     [lines, scrollOffset, maxHeight]
   );
-  useInput3(useCallback9((input, key) => {
+  useInput3(useCallback13((input, key) => {
     if (key.escape || input === "q") {
       onCloseRef.current();
     } else if (key.upArrow || input === "k") {
@@ -5828,7 +7005,7 @@ var App = ({ autoApprove = false, target }) => {
 var app_default = App;
 
 // src/platform/tui/components/SplashScreen.tsx
-import { useEffect as useEffect11, useState as useState10 } from "react";
+import { useEffect as useEffect11, useState as useState14 } from "react";
 import { Box as Box19, Text as Text19 } from "ink";
 
 // src/platform/tui/components/CoinFrames.ts
@@ -6527,7 +7704,7 @@ var SplashScreen = ({
 }) => {
   const { columns, rows } = useTerminalSize();
   const tick = useAnimationTick();
-  const [elapsed, setElapsed] = useState10(0);
+  const [elapsed, setElapsed] = useState14(0);
   useEffect11(() => {
     const start = Date.now();
     const interval = setInterval(() => {
@@ -6607,6 +7784,10 @@ async function runAction(objective, options) {
   const shutdown = async (exitCode = 0) => {
     await cleanupAllProcesses().catch(() => {
     });
+    const reqs = getGlobalRequestCount();
+    const usage = getGlobalTokenUsage();
+    console.log(chalk2.hex(HEX.gray)(`
+[Session Summary] Requests: ${reqs} | In: ${usage.input_tokens} | Out: ${usage.output_tokens}`));
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown(EXIT_CODES.SIGINT));