@nookplot/runtime 0.5.109 → 0.5.114

package/dist/autonomous.js

@@ -47,6 +47,9 @@ 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";
+const AUTONOMOUS_DOOM_LOOP_MAX_TRIGGERS = 3;
+const AUTONOMOUS_DOOM_LOOP_SIGNATURE_WINDOW = 30;
 // ----------------------------------------------------------------
 //  AutonomousAgent
 // ----------------------------------------------------------------
@@ -150,6 +153,17 @@ export class AutonomousAgent {
     processedSignals = new Map();
     /** Dynamic tool browsing: categories loaded via browse_tools. */
     loadedCategories = new Set();
+    /** Doom-loop detector state: ring buffer of recent action signatures + trigger counter. */
+    toolSignatures = [];
+    doomLoopTriggers = 0;
+    /**
+     * SRA Phase 4b — rolling buffer of skills loaded via nookplot_load_skill.
+     * Captured post-dispatch; flushed into args.loadedSkillRefs pre-dispatch on
+     * submit_reasoning_trace / submit_subtask_trace. Cap 64 (drop oldest); the
+     * gateway intersects against (agent, used=true, last 24h) signals so stale
+     * or unauthorized refs are dropped silently. Format on the wire: `${kind}:${ref}`.
+     */
+    loadedSkillRefs = [];
     /** Tiered knowledge context: L0 identity + L1 essentials (session-cached) + L2 on-demand. */
     wakeUpStack;
     constructor(runtime, options = {}) {
@@ -2790,6 +2804,58 @@ export class AutonomousAgent {
         }
         const startTime = Date.now();
         hooks.emitFireAndForget("action_start", { actionType, args, actionId, agentAddress });
+        // ── Doom-loop detection (parity with goal_loop.ts) ──
+        //     Push the action signature into a 30-slot ring; if the recent tail
+        //     shows 3+ identical calls or an A,B,A,B-style cycle, increment the
+        //     trigger counter. After 3 triggers in this agent's lifetime, abort
+        //     the current cycle so the outer proactive scheduler can re-route —
+        //     keeping the autonomous loop from spending NOOK on a stuck bug.
+        this.toolSignatures.push(makeSignature(actionType, args));
+        if (this.toolSignatures.length > AUTONOMOUS_DOOM_LOOP_SIGNATURE_WINDOW) {
+            this.toolSignatures = this.toolSignatures.slice(-AUTONOMOUS_DOOM_LOOP_SIGNATURE_WINDOW);
+        }
+        const doomOffender = checkForDoomLoopFromSignatures(this.toolSignatures);
+        if (doomOffender) {
+            this.doomLoopTriggers++;
+            hooks.emitFireAndForget("doom_loop_detected", {
+                offender: doomOffender,
+                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`);
+                }
+                const reason = buildCorrectivePrompt(doomOffender);
+                hooks.emitFireAndForget("action_error", {
+                    actionType, args, error: new Error(reason),
+                    durationMs: Date.now() - startTime, actionId,
+                });
+                if (actionId) {
+                    try {
+                        await this.runtime.proactive.rejectDelegatedAction(actionId, reason);
+                    }
+                    catch { /* best-effort */ }
+                }
+                // Reset trigger counter so the agent can recover after the outer
+                // scheduler reroutes — but keep the signature ring so a doom loop
+                // resurfacing on the next action still trips the detector.
+                this.doomLoopTriggers = 0;
+                return;
+            }
+        }
         // ── Input guardrails (Phase 3) ──
         // Run BEFORE the action body so a tripped guardrail prevents dispatch.
         // `tool_input` fires regardless so observability sees the call attempt;
@@ -2885,10 +2951,37 @@ export class AutonomousAgent {
                 ...args,
                 ...(suggestedContent ? { suggestedContent } : {}),
             };
+            // SRA Phase 4b — flush loaded-skill buffer into submit traces. If the
+            // caller already set loadedSkillRefs explicitly, respect it; otherwise
+            // populate from the buffer. Drop entries older than 24h client-side
+            // (server enforces the same window via intersection, but this keeps the
+            // payload small).
+            if ((actionType === "submit_reasoning_trace" || actionType === "submit_subtask_trace") &&
+                dispatchPayload.loadedSkillRefs == null &&
+                this.loadedSkillRefs.length > 0) {
+                const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+                this.loadedSkillRefs = this.loadedSkillRefs.filter(e => e.loadedAt >= cutoff);
+                if (this.loadedSkillRefs.length > 0) {
+                    dispatchPayload.loadedSkillRefs = this.loadedSkillRefs.map(e => `${e.kind}:${e.ref}`);
+                }
+            }
             const dispatchResult = await this.runtime.connection.request("POST", "/v1/actions/execute", { toolName, payload: dispatchPayload });
             switch (dispatchResult.status) {
                 case "completed": {
                     result = (dispatchResult.result ?? {});
+                    // SRA Phase 4b — capture canonical_ref from load_skill responses so
+                    // the next submit_reasoning_trace can declare them. The gateway's
+                    // recordLoad() already flips used=true on its skill_utility_signals
+                    // row; we just need to remember the ref for the trace-linkage step.
+                    if (actionType === "load_skill" && typeof result.canonical_ref === "string") {
+                        const kind = args.kind;
+                        if (typeof kind === "string") {
+                            this.loadedSkillRefs.push({ kind, ref: result.canonical_ref, loadedAt: Date.now() });
+                            if (this.loadedSkillRefs.length > 64) {
+                                this.loadedSkillRefs = this.loadedSkillRefs.slice(-64);
+                            }
+                        }
+                    }
                     break;
                 }
                 case "sign_required": {