pentesting 0.73.2 → 0.73.3

package/dist/{persistence-VFIOGTRC.js → persistence-2WKQHGOL.js}

@@ -3,8 +3,8 @@ import {
   clearWorkspace,
   loadState,
   saveState
-} from "./chunk-KBJPZDIL.js";
-import "./chunk-YFDJI3GO.js";
+} from "./chunk-UB7RW6LM.js";
+import "./chunk-GLO6TOJN.js";
 export {
   StateSerializer,
   clearWorkspace,

package/dist/{process-registry-GSHEX2LT.js → process-registry-QIW7ZIUT.js}

@@ -12,7 +12,7 @@ import {
   hasProcess,
   logEvent,
   setProcess
-} from "./chunk-YFDJI3GO.js";
+} from "./chunk-GLO6TOJN.js";
 export {
   clearAllProcesses,
   deleteProcess,

package/dist/prompts/main-agent.md

@@ -116,7 +116,9 @@ multiple sequential decisions that depend on each other's output.
 run_task({
   task: "WHAT to achieve — the goal, not the method",
   target: "IP:port or URL (optional)",
-  context: "Short context the sub-agent needs (optional)"
+  context: "Short context the sub-agent needs (optional)",
+  worker_type: "general | shell-supervisor | exploit | pwn (optional)"
+  resume_task_id: "delegated_task_... (optional when continuing an existing delegated chain)"
 })
 ```
 
@@ -124,6 +126,38 @@ run_task({
 Results come back as `[Status]`, `[Summary]`, `[Findings]`, `[Loot]`.
 After run_task completes: record key findings to canonical state if needed.
 
+### Active delegated tasks in `<current-state>`
+
+If `<current-state>` shows `Delegated Tasks`, treat them as live operational commitments, not passive notes.
+
+- `waiting` = an external event is pending; poll or supervise the related asset
+- `running` = a worker is mid-operation; avoid duplicating the same chain
+- `resume` = preferred next action to continue that delegated task
+- `worker:` = preferred worker type for the next delegated step
+- `assets:` and `sessions:` = operational handles you must reuse before creating new ones
+
+When an active delegated task exists:
+- prefer resuming/supervising it over starting a parallel duplicate
+- if the task already has the right listener/shell asset, reuse it
+- if it needs complex follow-up, call `run_task` again with the resume goal, not a fresh unrelated plan
+- if `worker:` is present, pass that same `worker_type` into `run_task` unless the evidence clearly suggests a different specialist
+- if you are continuing an existing delegated chain, pass `resume_task_id` for that active delegated task
+- if the task is obsolete or superseded, explicitly update mission/checklist so it is not retried blindly
+
+### `<delegated-execution-request>`
+
+If the system prompt includes `<delegated-execution-request>`, treat it as the current preferred delegated execution payload.
+
+- `task:` = exact delegated continuation objective
+- `worker_type:` = worker specialization to preserve
+- `resume_task_id:` = delegated chain ID to continue
+- `target:` / `context:` = optional carry-over execution context
+
+When this block is present:
+- do not invent a different delegated chain unless the evidence clearly invalidates the current one
+- prefer using these exact parameters if you call `run_task`
+- if you decide not to follow it, you must have concrete evidence that the delegated request is obsolete, dead, or superseded
+
 ## Parallel Operations
 
 Background everything that takes >2 min or can run alongside foreground work:

package/dist/prompts/strategist-system.md

@@ -436,3 +436,37 @@ DO NOT DELEGATE:
 ├─ Direct state updates (add_finding, add_loot)
 └─ Tasks requiring user interaction (ask_user)
 ```
+
+### Rule 13: ACTIVE DELEGATED TASKS
+```
+If Engagement State contains "Delegated Tasks", treat them as active operational context.
+
+INTERPRETATION:
+├─ status=waiting  → external event pending; recommend supervision/poll/resume
+├─ status=running  → operation already in progress; do not duplicate it
+├─ worker:<type>   → preferred next worker class for continuation
+├─ assets:         → reuse these listeners/shells/payload assets before creating new ones
+└─ resume:         → default continuation hint unless stronger evidence overrides it
+
+PLANNING RULES:
+├─ Prefer resuming an active delegated task over launching a duplicate chain
+├─ Reverse shell workflows should reuse existing listener/shell assets first
+├─ If a delegated task is waiting on connection, supervision is higher priority than starting a new listener
+└─ Only abandon an active delegated task if the evidence clearly shows it is dead, obsolete, or superseded
+```
+
+### Rule 14: DELEGATED EXECUTION REQUEST
+```
+If the system prompt contains <delegated-execution-request>, treat it as the runtime-selected continuation payload.
+
+INTERPRETATION:
+├─ task:           → exact delegated continuation objective
+├─ worker_type:    → worker specialization to preserve
+├─ resume_task_id: → delegated chain lineage to continue
+└─ context/target: → carry-over execution context
+
+PLANNING RULES:
+├─ Prefer this payload over inventing a fresh delegated chain
+├─ Preserve worker_type and resume_task_id unless concrete evidence invalidates them
+└─ If you reject the payload, the reason must be explicit and evidence-based
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pentesting",
-  "version": "0.73.2",
+  "version": "0.73.3",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/main.js",

package/dist/agent-tool-HYQGTZC4.js

@@ -1,256 +0,0 @@
-import {
-  CategorizedToolRegistry,
-  CoreAgent,
-  createContextExtractor,
-  getLLMClient
-} from "./chunk-BGEXGHPB.js";
-import {
-  AGENT_ROLES,
-  EVENT_TYPES,
-  LLM_ROLES,
-  TOOL_NAMES
-} from "./chunk-KBJPZDIL.js";
-import {
-  getActiveProcessSummary
-} from "./chunk-YFDJI3GO.js";
-
-// src/engine/agent-tool/completion-box.ts
-function createCompletionBox() {
-  return { done: false, result: null };
-}
-
-// src/engine/agent-tool/task-complete.ts
-function createTaskCompleteTool(completion) {
-  return {
-    name: TOOL_NAMES.TASK_COMPLETE,
-    description: `Signal task completion. Call this when the delegated task is done.
-Include all findings and loot discovered during the task.
-Use status: 'success' if goal achieved, 'partial' if partially done, 'failed' if blocked.`,
-    parameters: {
-      status: {
-        type: "string",
-        enum: ["success", "partial", "failed"],
-        description: "Task completion status"
-      },
-      summary: {
-        type: "string",
-        description: "What was accomplished (or why it failed)"
-      },
-      tried: {
-        type: "array",
-        items: { type: "string" },
-        description: "Approaches attempted during the task"
-      },
-      findings: {
-        type: "array",
-        items: { type: "string" },
-        description: "Security findings discovered (summary for main loop)"
-      },
-      loot: {
-        type: "array",
-        items: { type: "string" },
-        description: "Credentials, flags, or sensitive data obtained"
-      },
-      sessions: {
-        type: "array",
-        items: { type: "string" },
-        description: "Active session IDs established during the task"
-      },
-      suggested_next: {
-        type: "string",
-        description: "Recommended next action for the main agent"
-      }
-    },
-    required: ["status", "summary"],
-    execute: async (params) => {
-      const result = {
-        status: params["status"] ?? "partial",
-        summary: params["summary"] ?? "",
-        tried: params["tried"] ?? [],
-        findings: params["findings"] ?? [],
-        loot: params["loot"] ?? [],
-        sessions: params["sessions"] ?? [],
-        suggestedNext: params["suggested_next"] ?? ""
-      };
-      completion.done = true;
-      completion.result = result;
-      return {
-        success: true,
-        output: [
-          "[TASK_COMPLETE]",
-          `[Status] ${result.status}`,
-          `[Summary] ${result.summary}`
-        ].join("\n")
-      };
-    }
-  };
-}
-
-// src/engine/agent-tool/agent-registry.ts
-var AgentRegistry = class extends CategorizedToolRegistry {
-  constructor(state, scopeGuard, approvalGate, events, completion) {
-    super(state, scopeGuard, approvalGate, events);
-    const taskCompleteTool = createTaskCompleteTool(completion);
-    this.tools.set(taskCompleteTool.name, taskCompleteTool);
-  }
-  initializeRegistry() {
-    super.initializeRegistry();
-    this.tools.delete(TOOL_NAMES.RUN_TASK);
-    this.tools.delete(TOOL_NAMES.ASK_USER);
-  }
-};
-
-// src/engine/agent-tool/agent-runner.ts
-var MAX_AGENT_TOOL_ITERATIONS = 30;
-var COMPRESS_EVERY_N_STEPS = 5;
-var MAX_COMPRESS_FAILURES = 3;
-var AgentRunner = class extends CoreAgent {
-  completion;
-  contextExtractor;
-  stepCount = 0;
-  consecutiveCompressFailures = 0;
-  constructor(state, events, registry, completion) {
-    super(AGENT_ROLES.AGENT_TOOL, state, events, registry, MAX_AGENT_TOOL_ITERATIONS);
-    this.completion = completion;
-    this.contextExtractor = createContextExtractor(getLLMClient());
-  }
-  /**
-   * CoreAgent.step() 오버라이드
-   *
-   * 추가 동작 (super.step() 이후):
-   *   1. completion.done 확인 → task_complete 호출됐으면 즉시 완료 신호
-   *   2. COMPRESS_EVERY_N_STEPS마다 ContextExtractor 호출
-   */
-  async step(iteration, messages, systemPrompt, progress) {
-    const result = await super.step(iteration, messages, systemPrompt, progress);
-    if (this.completion.done) {
-      return {
-        output: JSON.stringify(this.completion.result),
-        toolsExecuted: result.toolsExecuted,
-        isCompleted: true
-      };
-    }
-    this.stepCount++;
-    if (this.stepCount % COMPRESS_EVERY_N_STEPS === 0) {
-      await this.compressContext(messages);
-    }
-    return result;
-  }
-  /**
-   * ContextExtractor를 사용해 messages[]를 1개 session-context로 압축.
-   *
-   * WHY: 실패 시 무시 (try/catch). CoreAgent의 trimMessagesIfNeeded(50)이
-   * 최후 안전망이므로 압축 실패가 치명적이지 않다.
-   * WHY (failure tracking): 연속 실패가 MAX_COMPRESS_FAILURES 초과 시 경고 emit.
-   * sub-agent가 초기 task를 잃어버릴 위험을 TUI에 노출해 사용자가 인지할 수 있게 한다.
-   */
-  async compressContext(messages) {
-    try {
-      const result = await this.contextExtractor.execute({ messages });
-      if (result.success && result.extractedContext) {
-        messages.length = 0;
-        messages.push({
-          role: LLM_ROLES.USER,
-          content: `<session-context>
-${result.extractedContext}
-</session-context>`
-        });
-        this.consecutiveCompressFailures = 0;
-      }
-    } catch {
-      this.consecutiveCompressFailures++;
-      if (this.consecutiveCompressFailures === MAX_COMPRESS_FAILURES) {
-        this.events.emit({
-          type: EVENT_TYPES.NOTIFICATION,
-          timestamp: Date.now(),
-          data: {
-            title: "Sub-Agent Context Warning",
-            message: `Context compression failed ${this.consecutiveCompressFailures}x in a row. Sub-agent may lose task direction. Consider reducing task scope.`,
-            level: "warning"
-          }
-        });
-      }
-    }
-  }
-};
-
-// src/engine/agent-tool/agent-prompt.ts
-function buildAgentPrompt(input) {
-  const parts = [
-    "You are an autonomous execution agent. Complete the delegated task using available tools.",
-    "",
-    `## Task
-${input.task}`
-  ];
-  if (input.target) {
-    parts.push(`
-## Target
-${input.target}`);
-  }
-  if (input.context) {
-    parts.push(`
-## Context
-${input.context}`);
-  }
-  const activeProcesses = getActiveProcessSummary();
-  if (activeProcesses) {
-    parts.push(`
-## Active Background Processes
-${activeProcesses}`);
-  }
-  parts.push(`
-## Rules
-- Do NOT call ask_user. You are autonomous. Make your best judgment.
-- Call task_complete when the task is done (status: success, partial, or failed).
-- Record findings with add_finding, loot with add_loot as you discover them.
-- If you hit 3 consecutive failures on the same approach, switch vectors or declare failed.
-- Be decisive \u2014 do not loop indefinitely on the same approach.`);
-  return parts.join("\n");
-}
-
-// src/engine/agent-tool/agent-tool.ts
-var TIMEOUT_RESULT = {
-  status: "failed",
-  summary: `Agent-tool timed out: max ${MAX_AGENT_TOOL_ITERATIONS} iterations reached without task_complete.`,
-  tried: [],
-  findings: [],
-  loot: [],
-  sessions: [],
-  suggestedNext: "Break the task into smaller sub-tasks and retry."
-};
-var AgentTool = class {
-  constructor(state, events, scopeGuard, approvalGate) {
-    this.state = state;
-    this.events = events;
-    this.scopeGuard = scopeGuard;
-    this.approvalGate = approvalGate;
-  }
-  async execute(input) {
-    const completion = createCompletionBox();
-    const registry = new AgentRegistry(
-      this.state,
-      this.scopeGuard,
-      this.approvalGate,
-      this.events,
-      completion
-    );
-    const runner = new AgentRunner(
-      this.state,
-      this.events,
-      registry,
-      completion
-    );
-    const prompt = buildAgentPrompt(input);
-    const loopResult = await runner.run(input.task, prompt);
-    if (completion.done && completion.result) {
-      return completion.result;
-    }
-    return {
-      ...TIMEOUT_RESULT,
-      tried: [`Reached ${loopResult.iterations} iterations without calling task_complete`]
-    };
-  }
-};
-export {
-  AgentTool
-};