@nookplot/runtime 0.5.143 → 0.5.144

package/dist/autonomous.js

@@ -40,12 +40,12 @@
  * @module autonomous
  */
 import { prepareSignRelay } from "./signing.js";
-import { formatUsdc } from "./usdcBudget.js";
+import { runFrontierPass } from "./frontierPass.js";
 import { wrapUntrusted, sanitizeForPrompt, UNTRUSTED_CONTENT_INSTRUCTION } from "./contentSafety.js";
-import { getAvailableActionsFromMap } from "./signalActionMap.js";
+import { getAvailableActionsFromMap, resolveDispatchToolName, CORE_ACTIONS } from "./signalActionMap.js";
+import { resolvePackActions } from "./pack.js";
 import { getCategoryListing, getToolsInCategory } from "./actionCatalog.js";
 import { WakeUpStack } from "./wakeUpStack.js";
-import { GoalLoop } from "./goal/goalLoop.js";
 import { hooks as defaultHooks } from "./hooks.js";
 import { guardrails as defaultGuardrails, GuardrailTripped, InputGuardrailTripped, } from "./guardrails.js";
 import { buildCorrectivePrompt, checkForDoomLoopFromSignatures, makeSignature, } from "./doomLoop.js";
@@ -63,7 +63,7 @@ const ON_CHAIN_ACTIONS = new Set([
     "cancel_bounty", "unclaim_bounty",
     "expire_disputed_bounty", "sweep_treasury_fees", // V8
     "sweep_creator_refund", // V9 H4 admin recovery
-    "create_listing", "list_service", "update_service", "create_agreement", "api_onboard",
+    "create_listing", "list_service", "update_service", "create_agreement",
     "deliver_work", "settle_agreement", "dispute_agreement", "cancel_agreement",
     "expire_dispute", "expire_delivered",
     "deploy_preview",
@@ -101,6 +101,7 @@ const ON_CHAIN_ACTIONS = new Set([
     // roadmap §1h Decision 11. Approval-gates the submission before the gateway
     // pipes the artifact through /submit-solution → submitRlmTrajectory.
     "submit_rlm",
+    // API marketplace on-chain actions use existing service/* prepare endpoints
     // Social (missing)
     "remove_vote", "revoke_attestation",
     // Bounty lifecycle (missing)
@@ -124,9 +125,6 @@ const ON_CHAIN_ACTIONS = new Set([
     "claim_pending_guild_mining_treasury",
     // Ecosystem partner protocols (raw-tx, agent pays own gas)
     "ecosystem_stake_tokens", "ecosystem_claim_rewards",
-    // Per-call x402 API purchase (client-signed EIP-3009 USDC auth, spends real
-    // USDC) — gated for the same reason as ecosystem_*: it moves the agent's money.
-    "pay_api",
     // V11: Multi-payout Open bounties (6 actions — creator + submitter + recovery)
     "create_open_bounty", "submit_open_bounty", "approve_open_submission",
     "top_up_open_bounty", "close_open_bounty", "sweep_worker_payout",
@@ -148,8 +146,8 @@ const ON_CHAIN_ACTIONS = new Set([
  * // → "- reply: Send a text reply in the current context. Params: content (string)\n..."
  * ```
  */
-export function getAvailableActions(signalType, loadedCategories) {
-    return getAvailableActionsFromMap(signalType, loadedCategories ?? new Set());
+export function getAvailableActions(signalType, loadedCategories, externalActions, packActions) {
+    return getAvailableActionsFromMap(signalType, loadedCategories ?? new Set(), externalActions, packActions);
 }
 /**
  * Maps a `mining_opportunity` signal's optional `track` field to the
@@ -210,6 +208,29 @@ export class AutonomousAgent {
         this.approvalHandler = options.onApproval;
         this.cooldownSec = options.responseCooldown ?? 120;
         this.wakeUpStack = new WakeUpStack(runtime);
+        this.packActions = options.pack ? resolvePackActions(options.pack) : null;
+    }
+    /** External MCP tools (mounted servers) exposed as `mcp__<server>__<tool>` actions. */
+    externalMcpActions = [];
+    /**
+     * Resolved action set of the loaded pack (null = no pack, ungated).
+     * Set once at construction from options.pack — packs are immutable per load.
+     */
+    packActions;
+    /**
+     * Fetch the agent's mounted external MCP tools and expose them as
+     * available actions (ROADMAP_external-mcp-connectors Phase 1). Runs at
+     * start(); call again after connectMcpServer to pick up new mounts.
+     */
+    async refreshExternalMcpActions() {
+        const tools = await this.runtime.tools.listMcpTools();
+        // The gateway computes the provider-safe wire name at discovery; tools
+        // without one (unmappable names) are visible in listMcpTools but can
+        // never be dispatched, so they don't surface as actions.
+        this.externalMcpActions = tools
+            .map((t) => t.wireName)
+            .filter((n) => typeof n === "string" && n.startsWith("mcp__"));
+        return this.externalMcpActions;
     }
     /** Start listening for proactive signals and action requests. */
     start() {
@@ -246,19 +267,11 @@ export class AutonomousAgent {
         if (this.verbose) {
             console.log("[autonomous] AutonomousAgent started — handling signals + actions");
         }
-        // Pre-load tool categories so the LLM always has web_search +
-        // search_knowledge visible without a browse_tools cold-start.
-        // Saves ~1 LLM turn per goal-driven agent and simplifies the first
-        // step for reactive agents too (CLAUDE.md rule — small code change).
-        this.loadedCategories.add("tools");
-        this.loadedCategories.add("discovery");
-        this.loadedCategories.add("knowledge");
-        // Goal bootstrap — run the GoalLoop in background if this agent was
-        // forged with initial_goal set (L1 swarm auto-deploy). Failures are
-        // non-fatal: the agent continues in normal reactive mode.
-        this.maybeBootstrapGoal().catch((err) => {
+        // External MCP tools — loaded once at boot so mounted servers' tools
+        // surface in getAvailableActions and dispatch as `mcp:<server>:<tool>`.
+        this.refreshExternalMcpActions().catch((err) => {
             if (this.verbose) {
-                console.error("[autonomous] Goal bootstrap failed:", err);
+                console.error("[autonomous] External MCP tool load failed:", err);
             }
         });
     }
@@ -270,157 +283,6 @@ export class AutonomousAgent {
         }
     }
     // ================================================================
-    //  Goal bootstrap (L3 — migration 247)
-    // ================================================================
-    /**
-     * Check whether this agent has an initial_goal + pending status, and
-     * if so, spin up a GoalLoop in the background. Non-blocking — start()
-     * returns immediately so WebSocket signal subscriptions are live even
-     * while the goal loop is running its first step.
-     */
-    async maybeBootstrapGoal() {
-        let goalConfig;
-        try {
-            goalConfig = await this.runtime.identity.getGoal();
-        }
-        catch (err) {
-            if (this.verbose) {
-                console.error("[autonomous] getGoal failed — treating as no goal:", err);
-            }
-            return;
-        }
-        if (!goalConfig || !goalConfig.initialGoal)
-            return;
-        if (goalConfig.goalStatus !== "pending") {
-            if (this.verbose) {
-                console.log(`[autonomous] Skipping goal bootstrap — status is ${goalConfig.goalStatus}, not 'pending'`);
-            }
-            return;
-        }
-        if (this.verbose) {
-            console.log(`[autonomous] Goal bootstrap: "${goalConfig.initialGoal.slice(0, 80)}..." budget=${goalConfig.goalBudgetNook ?? "unlimited"}`);
-        }
-        // Transition status atomically before running the loop. If the
-        // gateway rejects (network, permissions), bail out — we do not want
-        // to run the loop with a mismatched DB state.
-        try {
-            await this.runtime.identity.updateGoalStatus("in_progress");
-        }
-        catch (err) {
-            if (this.verbose) {
-                console.error("[autonomous] Failed to transition goal → in_progress:", err);
-            }
-            return;
-        }
-        const budgetNook = goalConfig.goalBudgetNook ? BigInt(goalConfig.goalBudgetNook) : 0n;
-        const loopOptions = {
-            runtime: this.runtime,
-            goal: goalConfig.initialGoal,
-            budgetNook,
-            parentSwarmId: goalConfig.goalParentSwarmId,
-            verbose: this.verbose,
-        };
-        const loop = new GoalLoop(loopOptions);
-        let result;
-        try {
-            result = await loop.run();
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (this.verbose) {
-                console.error("[autonomous] GoalLoop threw:", err);
-            }
-            // Transition to failed so the UI reflects the error.
-            await this.runtime.identity.updateGoalStatus("failed").catch(() => { });
-            await this.runtime.identity.createPendingTask({
-                reason: "unclear_goal",
-                description: `Goal loop crashed: ${msg.slice(0, 400)}`,
-                parentSwarmId: goalConfig.goalParentSwarmId,
-            }).catch(() => { });
-            return;
-        }
-        await this.handleGoalResult(result, goalConfig);
-    }
-    /**
-     * Dispatch on the terminal state of a GoalLoop run:
-     *   - complete       → store artifact in private KG, pause agent
-     *   - blocked_budget → create pending task (budget_exhausted), pause
-     *   - blocked_stuck  → create pending task (stuck_3x), pause
-     *   - blocked_capability → create pending task (needs_capability), pause
-     */
-    async handleGoalResult(result, goalConfig) {
-        if (result.outcome === "complete") {
-            // Store deliverable in private KG
-            let artifactId = null;
-            try {
-                const storeResult = (await this.runtime.connection.request("POST", "/v1/agents/me/knowledge", {
-                    contentText: result.artifact.body,
-                    title: result.artifact.title,
-                    domain: result.artifact.domain,
-                    visibility: "private",
-                    knowledgeType: "fact",
-                    sourceType: "import",
-                    metadata: {
-                        goal: goalConfig.initialGoal,
-                        parentSwarmId: goalConfig.goalParentSwarmId,
-                        stepsExecuted: result.stepsExecuted,
-                        spentNook: result.spentNook.toString(),
-                    },
-                }));
-                artifactId = storeResult?.id ?? null;
-            }
-            catch (err) {
-                if (this.verbose) {
-                    console.error("[autonomous] Failed to store goal artifact:", err);
-                }
-            }
-            try {
-                await this.runtime.identity.completeGoal(artifactId ?? "unknown");
-            }
-            catch (err) {
-                if (this.verbose) {
-                    console.error("[autonomous] completeGoal failed:", err);
-                }
-            }
-            // Q3: agent pauses after completion, does not stay reactive
-            this.stop();
-            return;
-        }
-        if (result.outcome === "blocked_budget") {
-            // initialGoal is non-null here — maybeBootstrapGoal returned early otherwise.
-            const goalText = goalConfig.initialGoal ?? "(unknown)";
-            await this.runtime.identity.createPendingTask({
-                reason: "budget_exhausted",
-                description: `Needs top-off to continue goal: ${goalText.slice(0, 300)}`,
-                parentSwarmId: goalConfig.goalParentSwarmId,
-            }).catch(() => { });
-            await this.runtime.identity.updateGoalStatus("paused_awaiting_topoff").catch(() => { });
-            this.stop();
-            return;
-        }
-        if (result.outcome === "blocked_stuck") {
-            await this.runtime.identity.createPendingTask({
-                reason: "stuck_3x",
-                description: result.stuckReason,
-                parentSwarmId: goalConfig.goalParentSwarmId,
-            }).catch(() => { });
-            await this.runtime.identity.updateGoalStatus("blocked_needs_decision").catch(() => { });
-            this.stop();
-            return;
-        }
-        if (result.outcome === "blocked_capability") {
-            await this.runtime.identity.createPendingTask({
-                reason: "needs_capability",
-                description: result.capabilityNeeded,
-                suggestedPresetId: result.suggestedPreset,
-                parentSwarmId: goalConfig.goalParentSwarmId,
-            }).catch(() => { });
-            await this.runtime.identity.updateGoalStatus("blocked_needs_decision").catch(() => { });
-            this.stop();
-            return;
-        }
-    }
-    // ================================================================
     //  Signal handling (proactive.signal)
     // ================================================================
     /**
@@ -502,8 +364,6 @@ export class AutonomousAgent {
                 return `proj_bounty_done:${data.bountyId ?? ""}`;
             case "guild_opportunity":
                 return `guild:${data.guildId ?? ""}:${addr}`;
-            case "workspace_opportunity":
-                return `workspace:${data.workspaceId ?? data.sourceId ?? ""}:${addr}`;
             case "team_assembly_suggested":
                 return `team_suggest:${data.txHash ?? ""}`;
             case "team_invitation":
@@ -653,7 +513,9 @@ export class AutonomousAgent {
             case "community_gap":
                 await this.handleCommunityGap(data);
                 break;
-            // DD-7: directive case removed — swarm coordination uses DMs
+            case "directive":
+                await this.handleDirective(data);
+                break;
             case "files_committed":
                 await this.handleFilesCommitted(data);
                 break;
@@ -766,10 +628,6 @@ export class AutonomousAgent {
             case "guild_opportunity":
                 await this.handleGuildOpportunity(data);
                 break;
-            // ── Open Cognitive Workspaces (P3): discoverable/open workspace to join ──
-            case "workspace_opportunity":
-                await this.handleWorkspaceOpportunity(data);
-                break;
             // ── Mining signals ──
             case "mining_opportunity":
                 await this.handleMiningOpportunity(data);
@@ -1296,51 +1154,6 @@ export class AutonomousAgent {
                 console.error("[autonomous] Guild opportunity handling failed:", err);
         }
     }
-    async handleWorkspaceOpportunity(data) {
-        const meta = data;
-        const name = meta.name ?? meta.title ?? "Unknown Workspace";
-        const workspaceId = meta.workspaceId ?? meta.sourceId ?? "";
-        const visibility = meta.visibility ?? "discoverable";
-        const description = meta.description ?? data.messagePreview ?? "";
-        const memberCount = meta.memberCount ?? 0;
-        const regionCounts = meta.regionCounts ?? {};
-        const openJoinRole = meta.openJoinRole ?? 0;
-        try {
-            const isOpen = visibility === "open";
-            const joinNote = isOpen
-                ? `You can self-join instantly (you would join as ${openJoinRole === 1 ? "editor" : "viewer"}).`
-                : "You can request to join; the owner approves.";
-            const regionSummary = Object.entries(regionCounts)
-                .map(([r, c]) => `${r}: ${c}`)
-                .join(", ") || "no cognitive state yet";
-            const prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\n` +
-                "A cognitive workspace opportunity was found on Nookplot.\n" +
-                `Workspace: ${sanitizeForPrompt(name)}\n` +
-                `Description: ${wrapUntrusted(description, "workspace description")}\n` +
-                `Visibility: ${visibility}\n` +
-                `Members: ${memberCount}\n` +
-                `Cognitive state: ${sanitizeForPrompt(regionSummary)}\n` +
-                `ID: ${workspaceId}\n` +
-                `${joinNote}\n\n` +
-                "Should you join this workspace to collaborate on its shared reasoning state? Respond with INTERESTED or SKIP.\n" +
-                "If interested, briefly explain why (under 200 chars).\n\n" +
-                "Format:\nDECISION: INTERESTED or SKIP\nREASON: why you want to join";
-            const response = await this.generateResponse(prompt);
-            const text = response?.trim() ?? "";
-            if (text.toUpperCase().includes("INTERESTED")) {
-                if (this.verbose) {
-                    console.log(`[autonomous] ✓ Interested in workspace "${name}" (supervised — join surfaced as an action)`);
-                }
-                // Joining is surfaced as an available action (join_workspace /
-                // request_workspace_join) for the agent's decision loop — not
-                // auto-executed here (adversarial default: no auto-join).
-            }
-        }
-        catch (err) {
-            if (this.verbose)
-                console.error("[autonomous] Workspace opportunity handling failed:", err);
-        }
-    }
     async handleMiningOpportunity(data) {
         const meta = data;
         const opportunityType = meta.opportunityType ?? "unknown";
@@ -1625,7 +1438,11 @@ export class AutonomousAgent {
                 console.log("[autonomous] No action parsed from response");
             return;
         }
-        const actionType = actionMatch[1].toLowerCase();
+        // Wire names (`mcp__<server>__<tool>`) are case-sensitive registry keys —
+        // lowercasing a mixed-case server/tool segment would dispatch a name that
+        // doesn't exist (and trip pack gating with a misleading refusal).
+        const rawAction = actionMatch[1];
+        const actionType = rawAction.startsWith("mcp__") ? rawAction : rawAction.toLowerCase();
         let payload = {};
         const paramsMatch = text.match(/PARAMS:\s*(\{[\s\S]*\})/i);
         if (paramsMatch) {
@@ -2233,7 +2050,40 @@ export class AutonomousAgent {
                 console.error("[autonomous] Community gap handling failed:", err);
         }
     }
-    // DD-7: handleDirective removed — swarm coordination uses DMs exclusively
+    async handleDirective(data) {
+        const directiveContent = data.messagePreview ?? "";
+        const channelId = data.channelId;
+        const community = data.community ?? "general";
+        try {
+            const prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\n` +
+                "You received a directive on Nookplot.\n" +
+                `Directive:\n${wrapUntrusted(directiveContent, "directive")}\n\n` +
+                "Follow the directive and compose your response.\n" +
+                "If it asks you to post, write the post content.\n" +
+                "If it asks you to discuss, write a discussion message.\n" +
+                "If you can't follow this directive, respond with exactly: [SKIP]\n\n" +
+                "Your response (under 500 chars):";
+            const response = await this.generateResponse(prompt);
+            const content = response?.trim() ?? "";
+            if (content && content !== "[SKIP]") {
+                if (channelId) {
+                    await this.runtime.channels.send(channelId, content);
+                    if (this.verbose)
+                        console.log(`[autonomous] ✓ Directive response sent to channel ${channelId.slice(0, 12)}`);
+                }
+                else {
+                    const title = content.slice(0, 100);
+                    await this.runtime.memory.publishKnowledge({ title, body: content, community });
+                    if (this.verbose)
+                        console.log(`[autonomous] ✓ Directive response posted in ${community}`);
+                }
+            }
+        }
+        catch (err) {
+            if (this.verbose)
+                console.error("[autonomous] Directive handling failed:", err);
+        }
+    }
     // ================================================================
     //  Project collaboration signal handlers
     // ================================================================
@@ -2867,6 +2717,16 @@ export class AutonomousAgent {
     // ================================================================
     //  Action request handling (proactive.action.request)
     // ================================================================
+    /**
+     * Execute a `use_frontier_model` action — delegates to the shared
+     * {@link runFrontierPass} so the runtime + CLI dispatch paths can't drift on
+     * this money path. Consumes an owner-reserved pass, runs a one-shot Surplus
+     * completion paid by the agent's OWN x402 key, finalizes (or reverts on
+     * failure). Returns the frontier answer, or an `{ error }` tool result.
+     */
+    async executeFrontierPass(args, agentAddress) {
+        return runFrontierPass(this.runtime.connection, this.runtime.economy, args, agentAddress);
+    }
     async handleActionRequest(event) {
         if (!this.isRunning)
             return;
@@ -2882,6 +2742,29 @@ export class AutonomousAgent {
         if (this.verbose) {
             console.log(`[autonomous] Action request: ${actionType}${actionId ? ` (${actionId})` : ""}`);
         }
+        // Pack gating (ROADMAP_external-mcp-connectors Phase 3): with a pack
+        // loaded, refuse anything outside CORE ∪ pack ∪ mounted-MCP. Gated
+        // prompts never offer these — this guard catches handler-injected or
+        // hallucinated action types.
+        if (this.packActions) {
+            const allowed = actionType.startsWith("mcp__")
+                ? this.externalMcpActions.includes(actionType)
+                : CORE_ACTIONS.includes(actionType) || this.packActions.includes(actionType);
+            if (!allowed) {
+                if (this.verbose)
+                    console.log(`[autonomous] Action denied by pack gating: ${actionType}`);
+                hooks.emitFireAndForget("action_rejected", {
+                    actionType, args, reason: "Not allowed by loaded pack", actionId,
+                });
+                if (actionId) {
+                    try {
+                        await this.runtime.proactive.rejectDelegatedAction(actionId, "Not allowed by loaded pack");
+                    }
+                    catch { /* best-effort */ }
+                }
+                return;
+            }
+        }
         // Approval gate: on-chain actions require approval when handler is set
         if (this.approvalHandler && ON_CHAIN_ACTIONS.has(actionType)) {
             const approved = await this.approvalHandler(actionType, args);
@@ -2920,18 +2803,6 @@ export class AutonomousAgent {
                 triggers: this.doomLoopTriggers,
                 actionType,
             });
-            // Track C.2: also push to gateway as fire-and-forget telemetry so
-            // ops dashboards can answer "which tools most often misbehave?"
-            // and "is this agent stuck right now?" — see
-            // gateway/src/services/doomLoopMetrics.ts. Errors are swallowed so
-            // a backend outage never blocks the runtime's recovery path.
-            void this.runtime.connection
-                .request("POST", "/v1/agents/me/doom-loop-event", {
-                offender: doomOffender,
-                triggers: this.doomLoopTriggers,
-                actionType,
-            })
-                .catch(() => { });
             if (this.doomLoopTriggers >= AUTONOMOUS_DOOM_LOOP_MAX_TRIGGERS) {
                 if (this.verbose) {
                     console.warn(`[autonomous] ✗ doom loop on '${doomOffender}' (${this.doomLoopTriggers} triggers) — aborting cycle`);
@@ -3037,43 +2908,21 @@ export class AutonomousAgent {
                 });
                 return;
             }
-            // ── Intercept pay_api (per-call x402 purchase) ──
-            // Client-side-signed like ecosystem_*: payAndCall signs an EIP-3009 USDC
-            // authorization with the agent's own key (the gateway is non-custodial), so
-            // it CANNOT route through the unified dispatch. The hard USDC spend cap
-            // (budgetUsdc) is enforced HERE, at the point of spend.
-            if (actionType === "pay_api") {
-                const privateKey = this.runtime.connection.privateKey;
-                if (!privateKey)
-                    throw new Error("pay_api requires the agent's private key (none configured)");
-                const budget = this.runtime.usdcBudget;
-                const maxForCall = budget.maxForNextCall(); // bigint | undefined; 0n = exhausted
-                if (maxForCall === 0n) {
-                    result = { paid: false, blocked: "usdc_budget_exhausted", reason: `USDC daily spend cap exhausted (spent ${formatUsdc(budget.spent)})` };
-                }
-                else {
-                    const { ethers } = await import("ethers");
-                    const wallet = new ethers.Wallet(privateKey);
-                    const payResult = await this.runtime.x402.payAndCall({
-                        listingId: args.listingId,
-                        path: String(args.path ?? ""),
-                        method: args.method,
-                        body: args.body,
-                        ...(maxForCall !== undefined ? { maxAmountBaseUnits: maxForCall } : {}),
-                    }, wallet);
-                    if (payResult.paid && payResult.amountPaidBaseUnits)
-                        budget.record(BigInt(payResult.amountPaidBaseUnits));
-                    result = { ...payResult };
-                }
+            // ── Intercept use_frontier_model (client-executed frontier pass) ──
+            // Not a gateway tool: consume an owner-reserved pass, run a one-shot
+            // Surplus completion paid by the agent's OWN client-signed x402 key, then
+            // finalize (or revert on failure). The gateway can't run this
+            // non-custodially. See ROADMAP_frontier-passes.md.
+            if (actionType === "use_frontier_model") {
+                result = await this.executeFrontierPass(args, agentAddress);
                 result = await guardrails.runOutput(actionType, result);
                 hooks.emitFireAndForget("tool_output", { toolName: actionType, args, result });
-                // No txHash — the settlement tx is internal to the facilitator.
                 if (actionId)
                     await this.runtime.proactive.completeAction(actionId, undefined, result);
                 if (this.verbose)
-                    console.log(`[autonomous] ✓ pay_api listing=${String(args.listingId)} paid=${result.paid}`);
+                    console.log(`[autonomous] ✓ use_frontier_model`);
                 hooks.emitFireAndForget("action_end", {
-                    actionType, args, result, durationMs: Date.now() - startTime, actionId, txHash: undefined,
+                    actionType, args, result, durationMs: Date.now() - startTime, actionId,
                 });
                 return;
             }
@@ -3084,7 +2933,7 @@ export class AutonomousAgent {
             // the original `payload` — otherwise input-guardrail mutations
             // (lowercase normalization, content sanitization, etc.) silently get
             // dropped on the way to the gateway.
-            const toolName = `nookplot_${actionType}`;
+            const toolName = resolveDispatchToolName(actionType);
             const dispatchPayload = {
                 ...args,
                 ...(suggestedContent ? { suggestedContent } : {}),
@@ -3653,7 +3502,7 @@ export class AutonomousAgent {
         if (!this.generateResponse)
             return;
         try {
-            const actions = getAvailableActionsFromMap("swarm_subtask_available", this.loadedCategories);
+            const actions = getAvailableActionsFromMap("swarm_subtask_available", this.loadedCategories, this.externalMcpActions, this.packActions);
             const prompt = `A swarm "${sanitizeForPrompt(swarmTitle.slice(0, 100))}" has open subtasks matching your skills.\n` +
                 `Swarm ID: ${swarmId}\n` +
                 `Matching skills: ${skillTags.slice(0, 10).join(", ")}\n\n` +
@@ -3681,7 +3530,7 @@ export class AutonomousAgent {
         if (!this.generateResponse)
             return;
         try {
-            const actions = getAvailableActionsFromMap("swarm_result_submitted", this.loadedCategories);
+            const actions = getAvailableActionsFromMap("swarm_result_submitted", this.loadedCategories, this.externalMcpActions, this.packActions);
             const prompt = `A result was submitted for subtask "${sanitizeForPrompt(subtaskTitle.slice(0, 100))}" in your swarm.\n` +
                 `Swarm ID: ${swarmId}\n` +
                 `Submitted by: ${sanitizeForPrompt((submittedBy).slice(0, 12))}...\n\n` +
@@ -3731,7 +3580,7 @@ export class AutonomousAgent {
                 searchResult = await this.parseAndExecuteAction(searchText);
             }
             // Step 2: Based on search results, store an insight
-            const actions = getAvailableActionsFromMap("dream_prompt", this.loadedCategories);
+            const actions = getAvailableActionsFromMap("dream_prompt", this.loadedCategories, this.externalMcpActions, this.packActions);
             const searchContext = searchResult
                 ? `\nSearch results (summarized): ${JSON.stringify(searchResult).slice(0, 1500)}\n`
                 : "\nNo search results found — consider creating foundational knowledge for these domains.\n";