@nookplot/runtime 0.5.108 → 0.5.110

package/dist/autonomous.js

@@ -44,6 +44,7 @@ import { wrapUntrusted, sanitizeForPrompt, UNTRUSTED_CONTENT_INSTRUCTION } from
 import { getAvailableActionsFromMap } from "./signalActionMap.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";
 // ----------------------------------------------------------------
@@ -112,6 +113,8 @@ const ON_CHAIN_ACTIONS = new Set([
     // Mining guild treasury (on-chain)
     "deposit_guild_mining_treasury", "claim_guild_mining_treasury",
     "claim_pending_guild_mining_treasury",
+    // Ecosystem partner protocols (raw-tx, agent pays own gas)
+    "ecosystem_stake_tokens", "ecosystem_claim_rewards",
 ]);
 /**
  * Get the list of available actions for a given signal type.
@@ -194,6 +197,21 @@ 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) => {
+            if (this.verbose) {
+                console.error("[autonomous] Goal bootstrap failed:", err);
+            }
+        });
     }
     /** Stop the autonomous agent. */
     stop() {
@@ -203,6 +221,157 @@ 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)
     // ================================================================
     /**
@@ -433,9 +602,7 @@ export class AutonomousAgent {
             case "community_gap":
                 await this.handleCommunityGap(data);
                 break;
-            case "directive":
-                await this.handleDirective(data);
-                break;
+            // DD-7: directive case removed — swarm coordination uses DMs
             case "files_committed":
                 await this.handleFilesCommitted(data);
                 break;
@@ -1954,40 +2121,7 @@ export class AutonomousAgent {
                 console.error("[autonomous] Community gap handling failed:", err);
         }
     }
-    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);
-        }
-    }
+    // DD-7: handleDirective removed — swarm coordination uses DMs exclusively
     // ================================================================
     //  Project collaboration signal handlers
     // ================================================================
@@ -2715,6 +2849,30 @@ export class AutonomousAgent {
                 });
                 return;
             }
+            // ── Intercept ecosystem raw-tx actions ──
+            // External partner contracts (BOTCOIN, etc.) don't trust Nookplot's
+            // EIP-2771 forwarder. The gateway returns { txRequests, meta } instead
+            // of a ForwardRequest, and the agent signs+submits with own wallet.
+            if (actionType === "ecosystem_stake_tokens" || actionType === "ecosystem_claim_rewards") {
+                const { prepareSignSend } = await import("./signing.js");
+                const preparePath = actionType === "ecosystem_stake_tokens"
+                    ? "/v1/prepare/ecosystem/stake-tokens"
+                    : "/v1/prepare/ecosystem/claim-rewards";
+                const sendResult = await prepareSignSend(this.runtime.connection, preparePath, args);
+                const hashes = sendResult.txHashes ?? [];
+                txHash = hashes.length > 0 ? hashes[hashes.length - 1] : undefined;
+                result = { txHashes: hashes, meta: sendResult.meta };
+                result = await guardrails.runOutput(actionType, result);
+                hooks.emitFireAndForget("tool_output", { toolName: actionType, args, result });
+                if (actionId)
+                    await this.runtime.proactive.completeAction(actionId, txHash, result);
+                if (this.verbose)
+                    console.log(`[autonomous] ✓ ${actionType}${txHash ? ` tx=${txHash}` : ""}`);
+                hooks.emitFireAndForget("action_end", {
+                    actionType, args, result, durationMs: Date.now() - startTime, actionId, txHash,
+                });
+                return;
+            }
             // ── Unified dispatch via POST /v1/actions/execute ──
             // The gateway's ToolDispatcher routes the call to the correct internal
             // endpoint, replacing the 2000+ line switch statement that was here before.