rterm-backend 3.8.7 → 3.8.9

package/bin/gybackend.cjs

@@ -346328,6 +346328,7 @@ var AgentRunLedger = class {
 var CHECKPOINT_STRING_CAP = 8 * 1024;
 var CHECKPOINT_BYTES_CAP = 16 * 1024 * 1024;
 var CHECKPOINT_MAX_MESSAGES = 40;
+var CHECKPOINT_RETENTION = 8;
 function truncateString(input, max = CHECKPOINT_STRING_CAP) {
   if (input.length <= max) return input;
   const omitted = input.length - max;
@@ -346395,8 +346396,18 @@ function isAllocationError(error40) {
 var SafeMemorySaver = class extends MemorySaver {
   async put(config2, checkpoint, metadata) {
     const pruned = pruneCheckpointForSaver(checkpoint);
+    const threadId = config2?.configurable?.thread_id;
+    const ns = config2?.configurable?.checkpoint_ns ?? "";
+    const checkpointId = checkpoint?.id;
+    if (threadId && checkpointId) {
+      const order = this.putOrderFor(threadId, ns);
+      order.push(checkpointId);
+      this.setPutOrder(threadId, ns, order.slice(-CHECKPOINT_RETENTION * 4));
+    }
     try {
-      return await super.put(config2, pruned, pruneValue(metadata));
+      const result = await super.put(config2, pruned, pruneValue(metadata));
+      this.evictOldCheckpoints(config2);
+      return result;
     } catch (error40) {
       if (!isAllocationError(error40)) throw error40;
       console.warn(
@@ -346409,12 +346420,15 @@ var SafeMemorySaver = class extends MemorySaver {
           channels.messages = channels.messages.slice(-8);
         }
         tighter.channel_values = channels;
-        return await super.put(config2, tighter, { source: "oom-pruned" });
+        const result = await super.put(config2, tighter, { source: "oom-pruned" });
+        this.evictOldCheckpoints(config2);
+        return result;
       } catch (retryError) {
         if (!isAllocationError(retryError)) throw retryError;
         console.warn(
           "[SafeMemorySaver] checkpoint still too large \u2014 skipping persist so the run can finish"
         );
+        this.evictOldCheckpoints(config2);
         return {
           configurable: {
             thread_id: config2?.configurable?.thread_id,
@@ -346425,6 +346439,46 @@ var SafeMemorySaver = class extends MemorySaver {
       }
     }
   }
+  /**
+   * Keep only the newest CHECKPOINT_RETENTION checkpoints for the thread/ns
+   * in this config. MemorySaver stores them as
+   * storage[threadId][ns][checkpointId] = [serializedCheckpoint, metadata,
+   * parentId]; there is no timestamp, but checkpoint ids from langgraph are
+   * UUIDv4-orderable-ish in practice and — more reliably — the number of
+   * entries is what matters for memory. We cannot know insertion order from
+   * the object shape alone, so we track it ourselves: the ids we just put
+   * are recorded, and anything beyond the newest window is dropped.
+   */
+  evictOldCheckpoints(config2) {
+    try {
+      const threadId = config2?.configurable?.thread_id;
+      const ns = config2?.configurable?.checkpoint_ns ?? "";
+      if (!threadId) return;
+      const storage = this.storage;
+      const nsMap = storage?.[threadId]?.[ns];
+      if (!nsMap) return;
+      const ids = Object.keys(nsMap);
+      if (ids.length <= CHECKPOINT_RETENTION) return;
+      const order = this.putOrderFor(threadId, ns);
+      const keep = new Set(order.slice(-CHECKPOINT_RETENTION));
+      for (const id of ids) {
+        if (!keep.has(id) && !order.includes(id)) keep.add(id);
+      }
+      for (const id of ids) {
+        if (!keep.has(id)) delete nsMap[id];
+      }
+      const remaining = order.filter((id) => id in nsMap);
+      this.setPutOrder(threadId, ns, remaining.slice(-CHECKPOINT_RETENTION * 2));
+    } catch {
+    }
+  }
+  putOrders = /* @__PURE__ */ new Map();
+  putOrderFor(threadId, ns) {
+    return this.putOrders.get(`${threadId}\0${ns}`) ?? [];
+  }
+  setPutOrder(threadId, ns, ids) {
+    this.putOrders.set(`${threadId}\0${ns}`, ids);
+  }
   async putWrites(config2, writes, taskId) {
     const prunedWrites = Array.isArray(writes) ? writes.map((w) => {
       if (Array.isArray(w) && w.length >= 2) {
@@ -366235,6 +366289,15 @@ var AgentHelpers = class {
   setEventPublisher(publisher) {
     this.eventPublisher = publisher;
   }
+  /**
+   * Current event publisher (or null). Lets a runtime CHAIN onto the
+   * publisher temporarily — e.g. the plugin runAgentTask hook captures
+   * `say` events for one mesh-invoke session while passing everything
+   * through to the gateway's broadcast unchanged.
+   */
+  getEventPublisher() {
+    return this.eventPublisher;
+  }
   /**
    * Build a temporary history for the action model to make decisions.
    * This includes the last 3 special marker messages and recent execution details.
@@ -368273,6 +368336,11 @@ var AgentService_v2 = class {
   setEventPublisher(publisher) {
     this.helpers.setEventPublisher(publisher);
   }
+  /** Current event publisher (or null) — lets a runtime chain onto it
+   * temporarily (plugin runAgentTask hook) without replacing it. */
+  getEventPublisher() {
+    return this.helpers.getEventPublisher();
+  }
   /** Wire the connection manager so `manage_ssh_connection` can mutate saved
    * connections + notify the UI. Optional; only needed in full runtimes. */
   setConnectionManager(manager) {
@@ -371778,6 +371846,23 @@ ${reminder}`;
       baseMessages = mapStoredMessagesToChatMessages(
         sanitizedStoredMessages.messages
       );
+      const interruptedRun = this.chatHistoryService.getRunMarker(sessionId);
+      if (interruptedRun) {
+        const minutesAgo = Math.max(
+          0,
+          Math.round((Date.now() - (interruptedRun.startedAt || 0)) / 6e4)
+        );
+        baseMessages.push(
+          new SystemMessage(
+            `[INTERRUPTION NOTICE] The previous task on this session was interrupted ${minutesAgo > 0 ? `${minutesAgo} minutes ` : ""}ago (the application stopped before the response completed \u2014 likely a force quit or crash). The last assistant response above may be PARTIAL: it can end mid-sentence, mid-tool-call, or before the task was actually finished. ` + (interruptedRun.inputPreview ? `The interrupted task began with: "${interruptedRun.inputPreview}"
+` : "") + `Do not assume the prior task completed. If the user's next message relates to it, offer to continue or finish the interrupted work rather than starting from scratch.`
+          )
+        );
+        this.chatHistoryService.clearRunMarker(sessionId);
+        console.warn(
+          `[AgentService_v2] Restored session ${sessionId} after an interrupted run (${interruptedRun.runId}); injected interruption notice into context.`
+        );
+      }
     }
     const runExperimentalFlags = resolveRunExperimentalFlags(
       context2,
@@ -371797,6 +371882,11 @@ ${reminder}`;
       execCommandActionModelEnabled: runExperimentalFlags.execCommandActionModelEnabled,
       writeStdinActionModelEnabled: runExperimentalFlags.writeStdinActionModelEnabled
     };
+    this.chatHistoryService.setRunMarker(sessionId, {
+      runId: ledgerRunId,
+      startedAt: Date.now(),
+      inputPreview: ledgerInputPreview.slice(0, 500)
+    });
     try {
       const result = await this.graph.invoke(initialState, {
         recursionLimit,
@@ -371855,6 +371945,7 @@ ${reminder}`;
       this.currentRunIdBySession.delete(sessionId);
       this.agentRunLedger?.finishRun(ledgerRunId, ledgerExitStatus, ledgerExitError);
       void this.recordCompoundingLessons(sessionId, ledgerRunId, ledgerExitStatus, ledgerExitError);
+      this.chatHistoryService.clearRunMarker(sessionId);
       await this.clearCheckpoint(sessionId);
     }
   }
@@ -373426,9 +373517,11 @@ var ChatHistoryService = class {
   saveSession(session) {
     const createdAt = this.store.getChatSessionCreatedAt(session.id);
     const now = Date.now();
+    const storedMeta = this.store.getChatSessionMeta(session.id);
+    const title = storedMeta?.title ?? session.title;
     this.store.saveChatSession({
       id: session.id,
-      title: session.title,
+      title,
       messages: Array.from(session.messages.entries()).map(([id, message]) => ({
         id,
         type: message._getType ? message._getType() : "unknown",
@@ -373448,6 +373541,32 @@ var ChatHistoryService = class {
   getSessionMeta(sessionId) {
     return this.store.getChatSessionMeta(sessionId);
   }
+  // ─── v3.8.9: run interruption markers ─────────────────────────────────────
+  // A marker is SET at run start and CLEARED in the run's finally block.
+  // Only a hard kill (force quit, crash, power loss) skips the finally —
+  // so a leftover marker is a durable, restart-surviving record that the
+  // session's previous run was interrupted. Stored in the history_meta
+  // table (plain SQLite, survives anything short of disk loss).
+  runMarkerKey(sessionId) {
+    return `run-marker:${sessionId}`;
+  }
+  setRunMarker(sessionId, marker) {
+    this.store.setMeta(this.runMarkerKey(sessionId), JSON.stringify(marker));
+  }
+  getRunMarker(sessionId) {
+    const raw = this.store.getMeta(this.runMarkerKey(sessionId));
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.runId === "string") return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  clearRunMarker(sessionId) {
+    this.store.setMeta(this.runMarkerKey(sessionId), "");
+  }
   loadSession(sessionId) {
     const storedSession = this.store.loadChatSession(sessionId);
     if (!storedSession) {
@@ -392163,7 +392282,7 @@ var PluginRegistry = class {
   }
   /** Build the default PluginContext for a record (registers into the record's
    * capability lists; exec/readLedger/log are delegated to the injected fns). */
-  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings) {
+  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings, runAgentTask) {
     return {
       registerTool: (tool2) => {
         record2.tools.push(tool2);
@@ -392184,7 +392303,8 @@ var PluginRegistry = class {
       ...spawnProcess ? { spawnProcess } : {},
       ...getSettings ? { getSettings, get settings() {
         return getSettings();
-      } } : {}
+      } } : {},
+      ...runAgentTask ? { runAgentTask } : {}
     };
   }
 };
@@ -394723,7 +394843,50 @@ function createObservability(deps) {
         });
       },
       // Live settings snapshot for plugins that read config blocks (webIntel, agentspan, …).
-      () => deps.settingsService?.getSettings?.() ?? {}
+      () => deps.settingsService?.getSettings?.() ?? {},
+      // Real agent turns for plugins that serve an inbound `invoke` skill
+      // (reactorpro-bridge): a mesh peer sends a prompt, RTerm runs it as a
+      // genuine agent turn and the answer goes back over the mesh.
+      // Chained onto the agent's event publisher for the duration of the
+      // turn: `say` events for OUR session are captured, everything passes
+      // through to the original (gateway) publisher unchanged, and the
+      // publisher is restored in finally. dispatchTask resolves when the
+      // run completes, so the last captured `say` is the final answer.
+      deps.agentService ? async (prompt, opts) => {
+        const agent = deps.agentService;
+        const sessionId = opts?.sessionId ?? `mesh-invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const timeoutMs = Math.min(Math.max(opts?.timeoutMs ?? 17e4, 5e3), 6e5);
+        const previous = agent.getEventPublisher();
+        const sayParts = [];
+        const chained = (sid, ev) => {
+          if (sid === sessionId && ev?.type === "say" && typeof ev.content === "string" && ev.content) {
+            sayParts.push(ev.content);
+          }
+          if (previous) {
+            try {
+              previous(sid, ev);
+            } catch {
+            }
+          }
+        };
+        agent.setEventPublisher(chained);
+        let timer;
+        try {
+          await Promise.race([
+            deps.gatewayService.dispatchTask(sessionId, prompt, void 0),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error(`agent turn timed out after ${timeoutMs}ms`)), timeoutMs);
+            })
+          ]);
+        } finally {
+          if (timer) clearTimeout(timer);
+          agent.setEventPublisher((sid, ev) => {
+            if (previous) previous(sid, ev);
+          });
+        }
+        const answer = sayParts.join("");
+        return { ok: answer.trim() !== "", answer, sessionId };
+      } : void 0
     ),
     onLog: deps.onLog
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.7",
+  "version": "3.8.9",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",

package/plugins/reactorpro-bridge/index.mjs

@@ -406,7 +406,7 @@ export async function register(ctx) {
     const nc = await connectMesh(ctx)
     const identity = loadOrCreateIdentity(cfg)
     const effCfg = { ...cfg, fingerprint: identity.fingerprint }
-    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt }), identity, getSkills: () => serveCtx.skills }
+    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt, runAgentTask: ctx.runAgentTask }), identity, getSkills: () => serveCtx.skills }
     if (responderStop) responderStop()
     responderStop = await startResponder(nc, effCfg, serveCtx, log)
     if (heartbeatStop) heartbeatStop()
@@ -426,7 +426,7 @@ export async function register(ctx) {
       skills: { type: 'object', description: 'Map of skillId -> async (input, ctx) => output (defaults to ping/describe/status/invoke)', optional: true },
     },
     handler: async (p) => guarded(async () => {
-      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt })
+      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })
       const skills = p?.skills ?? base
       const served = await serveSkills(skills)
       return { serving: true, inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills: served, note: 'RTerm is now a full ReactorPro mesh citizen (responder + heartbeat + registry live)' }
@@ -487,7 +487,7 @@ export async function register(ctx) {
   if (cfg.enabled && cfg.autoServe) {
     setTimeout(() => {
       Promise.race([
-        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt })),
+        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })),
         new Promise((_, reject) => setTimeout(() => reject(new Error('auto-serve connect timeout (5s)')), 5000)),
       ])
         .then((skills) => log(`[reactorpro] auto-started citizen on ${cfg.prefix}.agent.${cfg.agentId}.inbox (skills: ${skills.join(', ')})`))

package/plugins/reactorpro-bridge/reactorpro-bridge.extreme.spec.mts

@@ -29,6 +29,7 @@ import {
   buildManifest,
   buildRespond,
   checkIdentity,
+  defaultServeSkills,
   envelope,
   fingerprintFor,
   mintIdentity,
@@ -267,6 +268,85 @@ function ok(cond: unknown, label: string, note = ''): void {
   }
 }
 
+// ─── A3. Inbound invoke skill (v3.8.8) ───────────────────────────────────────
+// Found live: the manifest ADVERTISED invoke but defaultServeSkills had no
+// handler, so a peer dispatching invoke got SKILL_NOT_FOUND while the
+// manifest promised it. These pin the corrected contract.
+
+{
+  // A3.1 invoke exists in the default skills and routes to runAgentTask.
+  const cfg = { agentId: 'rterm/xcheck/invoke', dispatchTimeout: 180000 }
+  const skills = defaultServeSkills(cfg, {
+    startedAt: Date.now(),
+    runAgentTask: async (prompt: string, opts?: { sessionId?: string; timeoutMs?: number }) => {
+      ok(prompt === 'Reply with exactly one word: PONG',
+        'invoke passes the prompt through to runAgentTask (arguments.prompt)',
+        JSON.stringify({ prompt }))
+      ok(typeof opts?.timeoutMs === 'number' && opts.timeoutMs === 170000,
+        'invoke stays under the mesh dispatch budget (dispatchTimeout - 10s)',
+        JSON.stringify(opts))
+      return { ok: true, answer: 'PONG', sessionId: 'mesh-invoke-test' }
+    },
+  })
+  ok(typeof skills.invoke === 'function', 'defaultServeSkills includes an invoke handler')
+
+  const r1 = await skills.invoke({ arguments: { prompt: 'Reply with exactly one word: PONG' } } as never)
+  ok(r1?.output === 'PONG', 'invoke returns the agent answer as output', JSON.stringify(r1))
+  ok(r1?.conversation_id === 'mesh-invoke-test', 'invoke returns conversation_id for session persistence')
+
+  // A3.2 prompt extraction: text/ prompt/ message all work.
+  const skills2 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (prompt: string) => ({ ok: true, answer: `got:${prompt}`, sessionId: 's' }),
+  })
+  const viaText = await skills2.invoke({ text: 'hello' } as never)
+  ok(viaText?.output === 'got:hello', 'invoke extracts input.text')
+  const viaPrompt = await skills2.invoke({ prompt: 'hi' } as never)
+  ok(viaPrompt?.output === 'got:hi', 'invoke extracts input.prompt')
+  const viaString = await skills2.invoke('plain' as never)
+  ok(viaString?.output === 'got:plain', 'invoke extracts a bare string input')
+
+  // A3.3 conversation_id routes the follow-up to the same agent session.
+  const seenSessions: Array<string | undefined> = []
+  const skills3 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (_p: string, o?: { sessionId?: string }) => {
+      seenSessions.push(o?.sessionId)
+      return { ok: true, answer: 'x', sessionId: o?.sessionId ?? 'new' }
+    },
+  })
+  const first = await skills3.invoke({ text: 'one' } as never)
+  // First call: no conversation_id yet -> the hook generates a session.
+  ok(seenSessions[0] === undefined, 'first invoke has no session yet (the hook mints one)')
+  await skills3.invoke({ text: 'two', conversation_id: first.conversation_id } as never)
+  ok(seenSessions[1] === first.conversation_id && first.conversation_id !== undefined,
+    'conversation_id reuses the same agent session on the follow-up',
+    JSON.stringify({ seenSessions, firstId: first.conversation_id }))
+
+  // A3.4 no runAgentTask hook -> a CLEAR error, not SKILL_NOT_FOUND.
+  const skills4 = defaultServeSkills({ agentId: 'a' }, {})
+  const r4 = await skills4.invoke({ text: 'x' } as never)
+  ok(r4?.error?.code === 3002 && String(r4?.error?.message).includes('INVOKE_UNAVAILABLE'),
+    'invoke without the runAgentTask hook returns INVOKE_UNAVAILABLE (not SKILL_NOT_FOUND)',
+    JSON.stringify(r4))
+
+  // A3.5 empty prompt -> a clear error.
+  const skills5 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: true, answer: 'should not run', sessionId: 's' }),
+  })
+  const r5 = await skills5.invoke({} as never)
+  ok(r5?.error?.code === 3003 && String(r5?.error?.message).includes('INVOKE_NEEDS_PROMPT'),
+    'invoke with no prompt returns INVOKE_NEEDS_PROMPT without running the agent',
+    JSON.stringify(r5))
+
+  // A3.6 a failed agent turn -> a retryable error carrying the reason.
+  const skills6 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: false, answer: '', error: 'model offline', sessionId: 's' }),
+  })
+  const r6 = await skills6.invoke({ text: 'x' } as never)
+  ok(r6?.error?.code === 5001 && String(r6?.error?.message).includes('model offline'),
+    'a failed agent turn surfaces as a retryable error with the reason',
+    JSON.stringify(r6))
+}
+
 // ─── B. Go cross-check against the REAL gateway ──────────────────────────────
 
 const RP_CHECKOUT = process.env.RP_CHECKOUT ?? join(process.env.HOME ?? '', 'work', 'ReactorPro')

package/plugins/reactorpro-bridge/reactorproAgent.mjs

@@ -224,6 +224,39 @@ export function defaultServeSkills(cfg, deps = {}) {
       skills: ['ping', 'describe', 'status', 'invoke'],
       uptime_seconds: Math.floor((Date.now() - (deps.startedAt ?? Date.now())) / 1000),
     }),
+    // `invoke` routes a prompt into a REAL RTerm agent turn (tools, policy,
+    // audit all apply) and returns the final assistant text. Requires the
+    // runAgentTask PluginContext hook — present on the daemon and desktop,
+    // absent in bare test harnesses. When absent, return a clear error
+    // instead of pretending: a peer must know invoke is unavailable here.
+    invoke: async (input = {}) => {
+      const runner = deps.runAgentTask
+      if (typeof runner !== 'function') {
+        return { error: { code: 3002, message: 'INVOKE_UNAVAILABLE: this runtime does not expose agent turns (runAgentTask hook absent)', retryable: false } }
+      }
+      const prompt = input?.arguments?.prompt
+        ?? input?.prompt
+        ?? input?.text
+        ?? input?.message
+        ?? (typeof input === 'string' ? input : '')
+      if (!prompt || !String(prompt).trim()) {
+        return { error: { code: 3003, message: 'INVOKE_NEEDS_PROMPT: pass arguments.prompt (or text)', retryable: false } }
+      }
+      const conversationId = typeof input?.conversation_id === 'string' ? input.conversation_id : undefined
+      const result = await runner(String(prompt), {
+        sessionId: conversationId,
+        // Stay under the mesh dispatch budget (180s default) so the reply
+        // reaches the caller before its own timeout fires.
+        timeoutMs: Math.max(5_000, (cfg.dispatchTimeout ?? 180_000) - 10_000),
+      })
+      if (!result?.ok) {
+        return { error: { code: 5001, message: result?.error || 'agent turn produced no answer', retryable: true } }
+      }
+      return {
+        output: result.answer,
+        conversation_id: result.sessionId,
+      }
+    },
     ...(deps.skills ?? {}),
   }
 }