@nookplot/runtime 0.5.118 → 0.5.120

package/dist/autonomous.js

@@ -44,7 +44,6 @@ 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";
 import { buildCorrectivePrompt, checkForDoomLoopFromSignatures, makeSignature, } from "./doomLoop.js";
@@ -95,10 +94,6 @@ const ON_CHAIN_ACTIONS = new Set([
     "vote_kick_guild_member",
     "mining_counter_argument", "mining_defend_trace",
     "claim_mining_subtask", "submit_subtask_trace",
-    // RLM trajectory submission — symmetric with submit_reasoning_trace per
-    // 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",
@@ -144,29 +139,6 @@ const ON_CHAIN_ACTIONS = new Set([
 export function getAvailableActions(signalType, loadedCategories) {
     return getAvailableActionsFromMap(signalType, loadedCategories ?? new Set());
 }
-/**
- * Maps a `mining_opportunity` signal's optional `track` field to the
- * track-specific action set the agent's brain should consider. Values are
- * comma-joined strings ready to drop into the prompt's "Available actions"
- * line.
- *
- * Unknown / missing track falls back to the generic mining action list —
- * preserves pre-Phase-3 behaviour for callers that don't set `track`.
- */
-export function availableActionsForTrack(track) {
-    switch (track) {
-        case "knowledge":
-            return "discover_mining_challenges, get_mining_challenge, submit_reasoning_trace, upload_mining_content";
-        case "embedding":
-            return "list_embedding_challenges, submit_embeddings";
-        case "rlm":
-            return "discover_mining_challenges, get_mining_challenge, rlm_repl_exec, rlm_repl_llm_query, rlm_repl_finalize";
-        case "gradient":
-            return "discover_mining_challenges, get_mining_challenge"; // gradient solver still TBD
-        default:
-            return "discover_mining_challenges, get_mining_challenge, submit_reasoning_trace, upload_mining_content";
-    }
-}
 export class AutonomousAgent {
     runtime;
     verbose;
@@ -239,21 +211,6 @@ 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() {
@@ -263,157 +220,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)
     // ================================================================
     /**
@@ -644,7 +450,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;
@@ -1290,12 +1098,6 @@ export class AutonomousAgent {
         const challengeId = meta.challengeId ?? "";
         const difficulty = meta.difficulty ?? "";
         const domainTags = meta.domainTags ?? [];
-        // Phase 3d: optional `track` discriminator routes the prompt's "Available
-        // actions" hint to the right per-track action set so the agent's brain
-        // suggests the appropriate solver tool. `track` is informational — the
-        // existing dispatch surface still handles every action via the unified
-        // POST /v1/actions/execute route.
-        const track = meta.track ?? "";
         try {
             let prompt = `${UNTRUSTED_CONTENT_INSTRUCTION}\n\nA mining opportunity was found on Nookplot.\n`;
             if (opportunityType === "open_challenge") {
@@ -1303,10 +1105,8 @@ export class AutonomousAgent {
                 prompt += `Challenge: ${sanitizeForPrompt(challengeId)}\n`;
                 prompt += `Difficulty: ${difficulty}\n`;
                 prompt += `Domains: ${domainTags.join(", ")}\n\n`;
-                if (track)
-                    prompt += `Track: ${sanitizeForPrompt(track)}\n`;
                 prompt += "Should you attempt this challenge? Consider your expertise and current staking tier.\n";
-                prompt += `Available actions: ${availableActionsForTrack(track)}\n`;
+                prompt += "Available actions: discover_mining_challenges, get_mining_challenge, submit_reasoning_trace, upload_mining_content\n";
             }
             else if (opportunityType === "unclaimed_royalties") {
                 prompt += `Type: Unclaimed mining rewards\n`;
@@ -2171,7 +1971,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
     // ================================================================
@@ -2858,18 +2691,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`);