@openagents-org/agent-launcher 0.2.115 → 0.2.116

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.115",
+  "version": "0.2.116",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/adapters/claude.js

@@ -128,6 +128,48 @@ class ClaudeAdapter extends BaseAdapter {
     } catch {}
   }
 
+  /**
+   * Build a short transcript of the channel's last chat exchanges, used to
+   * re-seed context when --resume fails and we have to start a fresh
+   * Claude Code session. Returns null when there's nothing useful to add.
+   *
+   * Excludes the user's current message (the for-loop will append it
+   * normally) and any status/thinking events, which are mostly tool-call
+   * noise and inflate the prompt without adding signal.
+   */
+  async _buildChannelRecap(channelName, currentMessage) {
+    const messages = await this.client.getRecentMessages(
+      this.workspaceId, channelName, this.token, 30
+    );
+    if (!messages || messages.length === 0) return null;
+
+    const lines = [];
+    for (const m of messages) {
+      const mt = m.messageType || 'chat';
+      if (mt === 'status' || mt === 'thinking' || mt === 'loading') continue;
+      const text = (m.content || '').trim();
+      if (!text) continue;
+      // Don't echo the user's current message back at them.
+      if (text === currentMessage) continue;
+      const who = m.senderType === 'human'
+        ? (m.senderName || 'user')
+        : (m.senderName || 'agent');
+      // Cap each line so a single huge paste doesn't blow up the prompt.
+      const truncated = text.length > 800 ? text.slice(0, 800) + '…' : text;
+      lines.push(`[${who}] ${truncated}`);
+    }
+    if (lines.length === 0) return null;
+
+    // Keep only the tail; older context has diminishing value and we
+    // don't want to balloon the system prompt.
+    const tail = lines.slice(-15).join('\n');
+    return (
+      'You previously worked in this channel but your prior session is no ' +
+      'longer available, so here is the recent conversation for context:\n\n' +
+      tail
+    );
+  }
+
   async _stopAllProcesses(completionMessage = 'Execution stopped.') {
     const entries = Object.entries(this._channelProcesses);
     if (!entries.length) return;
@@ -449,10 +491,23 @@ class ClaudeAdapter extends BaseAdapter {
 
     // Run up to 2 attempts: first with session resume, then fresh if stale session detected
     let _shouldRetry = false;
+    let effectiveContent = content;
     for (let attempt = 0; attempt < 2; attempt++) {
       if (mcpConfigFile) { try { fs.unlinkSync(mcpConfigFile); } catch {} mcpConfigFile = null; }
+
+      // On the retry pass after a stale --resume, the spawned `claude`
+      // starts a brand-new session with no memory of prior turns. Replay
+      // the channel's recent chat history so the agent at least has a
+      // recap instead of saying "I don't see any previous messages."
+      if (attempt > 0) {
+        try {
+          const recap = await this._buildChannelRecap(msgChannel, content);
+          if (recap) effectiveContent = `${recap}\n\n---\n\n${content}`;
+        } catch {}
+      }
+
       try {
-        const built = this._buildClaudeCmd(content, msgChannel, { skipResume: attempt > 0 });
+        const built = this._buildClaudeCmd(effectiveContent, msgChannel, { skipResume: attempt > 0 });
         cmd = built.cmd;
         mcpConfigFile = built.mcpConfigFile;
       } catch (e) {

package/src/workspace-client.js

@@ -191,6 +191,32 @@ class WorkspaceClient {
     return events.map((e) => this._eventToMessage(e));
   }
 
+  /**
+   * Fetch the most recent N messages in a channel, returned oldest-to-newest.
+   * Used by adapters to rebuild context for a fresh Claude Code session
+   * when --resume of the previous session fails (the channel's chat history
+   * is the only thing that survives a session-storage rotation).
+   */
+  async getRecentMessages(workspaceId, channelName, token, limit = 30) {
+    try {
+      const params = new URLSearchParams({
+        network: workspaceId,
+        channel: channelName,
+        type: 'workspace.message',
+        sort: 'desc',
+        limit: String(limit),
+      });
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      const result = data.data || data;
+      const events = (result && result.events) || [];
+      // Server returned newest-first; reverse so the caller can present them
+      // in chronological order without further fiddling.
+      return events.slice().reverse().map((e) => this._eventToMessage(e));
+    } catch {
+      return [];
+    }
+  }
+
   /**
    * Fetch the latest workspace.message.posted event id (head cursor).
    * Used by adapters to skip past existing events on join in O(1) instead