@openagents-org/agent-launcher 0.2.193 → 0.2.194

package/src/adapters/claude.js

@@ -22,7 +22,7 @@ const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle, redactSecrets } = require('./utils');
-const { buildClaudeSystemPrompt, buildClaudeSkillMd, workspaceSkillName } = require('./workspace-prompt');
+const { buildClaudeSystemPrompt, buildClaudeSkillMd, buildPinnedSections, workspaceSkillName } = require('./workspace-prompt');
 const { pinnedFingerprint, sampleRecap } = require('./decision-log');
 const { defaultAgentWorkdir, whichBinary, whereBinary } = require('../paths');
 
@@ -657,7 +657,12 @@ class ClaudeAdapter extends BaseAdapter {
           type: 'stdio',
           command: mcpCommand,
           args: mcpFinalArgs,
-          env: { OA_WORKSPACE_TOKEN: this.token },
+          env: {
+            OA_WORKSPACE_TOKEN: this.token,
+            // v1.1: who asked, so escalation tools can address the owner.
+            ...(this.requesterEmailFor && this.requesterEmailFor(channelName)
+              ? { OPENAGENTS_REQUESTER_EMAIL: this.requesterEmailFor(channelName) } : {}),
+          },
         },
       },
     };
@@ -822,6 +827,11 @@ class ClaudeAdapter extends BaseAdapter {
       watchdogTimer: null,
       awaitingToolResult: false,
       userStopped: false,
+      // Background tasks (run_in_background Bash, background sub-agents) the
+      // CLI reports as still running, from its `background_tasks_changed`
+      // events. Killing the process kills them too, and a plan nudge sent
+      // while they run makes the agent re-announce work it is waiting on.
+      backgroundTasks: 0,
     };
 
     if (proc.stderr) {
@@ -928,10 +938,19 @@ class ClaudeAdapter extends BaseAdapter {
             try { await this.sendResponse(pp.msgChannel, trailing); } catch {}
           }
           pp.lastResponseText.length = 0;
+          // The plan nudge was held back while background work ran (see
+          // _queueTodoNudge); once the last task has reported, pick it up.
+          if (!event.is_error && pp.backgroundTasks === 0) {
+            await this._resumePlanAfterBackground(pp.msgChannel);
+          }
         }
       } else if (eventType === 'system') {
         const subtype = event.subtype || '';
         const message = event.message || '';
+        if (subtype === 'background_tasks_changed') {
+          pp.backgroundTasks = Array.isArray(event.tasks) ? event.tasks.length : 0;
+          return;
+        }
         if (subtype.includes('compact') || String(message).toLowerCase().includes('compact')) {
           await this.sendStatus(pp.msgChannel, String(message) || 'Compacting conversation...');
         }
@@ -1122,22 +1141,109 @@ class ClaudeAdapter extends BaseAdapter {
   /** Queue a reminder about unfinished todos (skipped when this turn IS one). */
   async _queueTodoNudge(msgChannel, msg) {
     if (msg._todoNudge) return;
+    const nudge = await this._buildTodoNudge(msgChannel);
+    if (!nudge) return;
+    if (!this._channelQueues[msgChannel]) this._channelQueues[msgChannel] = [];
+    if (this._channelQueues[msgChannel].some((m) => m._todoNudge)) return;
+    this._channelQueues[msgChannel].push(nudge);
+  }
+
+  /**
+   * The "you have N remaining tasks" message, or null when there is nothing
+   * to nudge: no unfinished todos, a stop in progress, or background work
+   * still running in this channel's process (the agent has said it is waiting
+   * on it; nudging made it re-announce the plan — and, combined with a
+   * restart, re-launch work that had been killed). The nudge is picked up
+   * again once the background tasks report (_resumePlanAfterBackground).
+   */
+  async _buildTodoNudge(msgChannel) {
     // A stop ends the plan, it does not pause it. When the stop lands while
     // this turn is finishing, nudging here is what handed the agent its own
     // "please continue" right after it announced it had stopped.
-    if (this._stoppingChannels.has(msgChannel)) return;
+    if (this._stoppingChannels.has(msgChannel)) return null;
+    const pp = this._persistentProcs[msgChannel];
+    if (pp && pp.alive && pp.backgroundTasks > 0) {
+      this._log(`Holding the plan nudge for ${msgChannel} — ${pp.backgroundTasks} background task(s) still running`);
+      return null;
+    }
     try {
       const remaining = await this.getRemainingTodos(msgChannel);
-      if (remaining.length > 0) {
-        const items = remaining.map((t) => `- ${t.content}`).join('\n');
-        const nudge = `You have ${remaining.length} remaining task(s) from your plan:\n${items}\n\nPlease continue working on them.`;
-        if (!this._channelQueues[msgChannel]) this._channelQueues[msgChannel] = [];
-        this._channelQueues[msgChannel].push({
-          content: nudge, senderType: 'system', senderName: 'system:todos',
-          sessionId: msgChannel, messageType: 'chat', _todoNudge: true,
-        });
-      }
-    } catch {}
+      if (remaining.length === 0) return null;
+      const items = remaining.map((t) => `- ${t.content}`).join('\n');
+      return {
+        content: `You have ${remaining.length} remaining task(s) from your plan:\n${items}\n\nPlease continue working on them.`,
+        senderType: 'system', senderName: 'system:todos',
+        sessionId: msgChannel, messageType: 'chat', _todoNudge: true,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Background work finished and the CLI wrapped it up on its own. If the
+   * plan still has open items, continue it now — queued behind a running
+   * turn, or as its own turn when the channel is idle.
+   */
+  async _resumePlanAfterBackground(msgChannel) {
+    const nudge = await this._buildTodoNudge(msgChannel);
+    if (!nudge) return;
+    if (this._channelBusy.has(msgChannel)) {
+      if (!this._channelQueues[msgChannel]) this._channelQueues[msgChannel] = [];
+      if (!this._channelQueues[msgChannel].some((m) => m._todoNudge)) this._channelQueues[msgChannel].push(nudge);
+      return;
+    }
+    this._channelWorker(msgChannel, nudge);
+  }
+
+  /**
+   * The pinned decision log / glossary, rendered exactly as in the system
+   * prompt, framed as replacing the copy the running session started with.
+   * Returns '' when nothing is pinned.
+   */
+  _pinnedUpdatePreamble(msgChannel, decisionLog, glossary) {
+    const sections = buildPinnedSections({
+      toolMode: this.toolMode,
+      channelName: msgChannel,
+      mode: this._mode,
+      decisionLog,
+      glossary,
+    }).join('').trim();
+    if (!sections) return '';
+    return '[Pinned knowledge was updated since this session started. The ' +
+      'sections below replace the earlier versions in your instructions — ' +
+      'treat them as current.]\n\n' + sections;
+  }
+
+  /**
+   * Wait for the next `result` on an already-addressed process without
+   * writing anything to it. If the process stays completely silent for
+   * `quietMs` there is no second turn coming; resolve with { quiet: true } so
+   * the caller falls back to the ordinary empty-outcome handling. Once output
+   * starts, the regular watchdog takes over.
+   */
+  _awaitNextTurn(pp, quietMs = 20_000) {
+    const startedAt = Date.now();
+    return new Promise((resolve) => {
+      let quietTimer = null;
+      const finish = (r) => {
+        if (quietTimer) { clearInterval(quietTimer); quietTimer = null; }
+        this._stopWatchdog(pp);
+        resolve(r);
+      };
+      pp.messageResolve = finish;
+      quietTimer = setInterval(() => {
+        if (pp.lastStdoutTime > startedAt) {
+          clearInterval(quietTimer);
+          quietTimer = null;
+          this._startWatchdog(pp);
+        } else if (Date.now() - startedAt >= quietMs) {
+          pp.messageResolve = null;
+          finish({ quiet: true });
+        }
+      }, 500);
+      if (quietTimer.unref) quietTimer.unref();
+    });
   }
 
   async _handleMessage(msg) {
@@ -1217,22 +1323,34 @@ class ClaudeAdapter extends BaseAdapter {
       const modeStale = existingPP.spawnMode !== this._mode;
       const pinnedStale = pinnedHash !== null && existingPP.pinnedHash !== pinnedHash;
       const modelStale = (existingPP.spawnModel || null) !== (this.workspaceModel || null);
-      if (modeStale || pinnedStale || modelStale) {
+      if (modeStale || modelStale) {
         // Kill it and fall through to a fresh spawn: --resume keeps the
         // conversation (it lives in the CLI transcript), while the new spawn
-        // carries the current mode and re-pins the current knowledge.
+        // carries the current mode / model flags (and the current pins).
         this._log(modeStale
           ? `Mode changed to ${this._mode} for ${msgChannel} — respawning with resume`
-          : modelStale
-            ? `Model changed to ${this.workspaceModel || '(default)'} for ${msgChannel} — respawning with resume`
-            : `Pinned knowledge changed for ${msgChannel} — respawning with resume to re-pin it`);
+          : `Model changed to ${this.workspaceModel || '(default)'} for ${msgChannel} — respawning with resume`);
         await this._killPersistentProc(msgChannel);
       } else {
-        this._log(`Reusing persistent process for ${msgChannel}`);
+        // A pinned-knowledge change no longer restarts the process. Agents
+        // edit the decision log themselves on nearly every decision, and the
+        // restart killed whatever they had running in the background (a
+        // sub-agent mid-build) and replayed into a false "agent hit an error".
+        // The new version rides in with this message instead and supersedes
+        // the copy baked into the system prompt.
+        let turnContent = content;
+        if (pinnedStale) {
+          const update = this._pinnedUpdatePreamble(msgChannel, decisionLogOpt, glossaryOpt);
+          if (update) turnContent = `${update}\n\n---\n\n${content}`;
+          existingPP.pinnedHash = pinnedHash;
+          this._log(`Pinned knowledge changed for ${msgChannel} — passing the update to the running session`);
+        } else {
+          this._log(`Reusing persistent process for ${msgChannel}`);
+        }
         if (await this._bailOnStopDuringTurn(msgChannel)) return;
         this._resetIdleTimer(msgChannel);
         existingPP.msgChannel = msgChannel;
-        const result = await this._sendToPersistentProc(existingPP, content);
+        const result = await this._sendToPersistentProc(existingPP, turnContent);
         if (existingPP.userStopped) {
           await this._finishUserStop(msgChannel);
           return;
@@ -1314,9 +1432,22 @@ class ClaudeAdapter extends BaseAdapter {
         ]);
         pp.spawnMode = this._mode;
         pp.spawnModel = this.workspaceModel || null;
+        const resumed = attempt === 0 && !!this._channelSessions[msgChannel];
         this._log(`Spawned persistent process for ${msgChannel} (attempt ${attempt + 1})`);
 
-        const result = await this._sendToPersistentProc(pp, effectiveContent);
+        let result = await this._sendToPersistentProc(pp, effectiveContent);
+
+        // A resumed session can first report something left over from before
+        // the restart — typically a background task that died with the old
+        // process — as a turn with no text and no error. That is not this
+        // message's answer: wait for the real turn instead of posting "the
+        // agent hit an error" and throwing the session away.
+        if (resumed && result.resultEvent && !pp.userStopped
+            && !pp.everPostedAnything && !pp.lastErrorText
+            && !this._composeFinalResponse(pp)) {
+          this._log(`Empty leftover result after resume for ${msgChannel} — waiting for the real turn`);
+          result = await this._awaitNextTurn(pp);
+        }
 
         if (pp.userStopped) {
           await this._finishUserStop(msgChannel);

package/src/adapters/codex.js

@@ -79,10 +79,27 @@ class CodexAdapter extends BaseAdapter {
     const isOpenAiNative = !this._directBaseUrl ||
       this._directBaseUrl.includes('api.openai.com');
 
-    if (this._codexBin && (isOpenAiNative || !this._directApiKey)) {
-      // CLI mode: either OpenAI native API or subscription auth (no API key)
+    // A third-party endpoint that speaks the Responses API can drive the
+    // real CLI (tools, sandbox, resume) instead of the tool-less direct
+    // mode. Opt in with CODEX_WIRE_API=responses; the provider is passed to
+    // codex as `-c` overrides, so nothing is written to ~/.codex/config.toml.
+    this._customProvider = null;
+    if (this._codexBin && !isOpenAiNative && this._directApiKey &&
+        String(env.CODEX_WIRE_API || '').toLowerCase() === 'responses') {
+      this._customProvider = {
+        baseUrl: this._directBaseUrl,
+        reasoningEffort: String(env.CODEX_REASONING_EFFORT || '').toLowerCase() || null,
+      };
+    }
+
+    if (this._codexBin && (isOpenAiNative || !this._directApiKey || this._customProvider)) {
+      // CLI mode: OpenAI native API, subscription auth (no API key), or a
+      // Responses-compatible custom provider.
       this._useCliMode = true;
-      this._log(`CLI mode: ${this._codexBin}${!this._directApiKey ? ' (subscription auth)' : ''}`);
+      const how = this._customProvider
+        ? ` (custom Responses provider ${this._customProvider.baseUrl})`
+        : (!this._directApiKey ? ' (subscription auth)' : '');
+      this._log(`CLI mode: ${this._codexBin}${how}`);
     } else if (this._directApiKey && this._directBaseUrl) {
       this._directMode = true;
       if (this._codexBin) {
@@ -319,6 +336,23 @@ class CodexAdapter extends BaseAdapter {
         cmd.push('-m', effectiveModel);
       }
 
+      // Custom Responses-API provider (see constructor). TOML values for
+      // `-c` must be quoted; the key itself travels in env (env_key), never
+      // on the command line.
+      if (this._customProvider) {
+        const q = (v) => JSON.stringify(String(v));
+        cmd.push(
+          '-c', 'model_provider=openagents',
+          '-c', `model_providers.openagents.name=${q('openagents')}`,
+          '-c', `model_providers.openagents.base_url=${q(this._customProvider.baseUrl)}`,
+          '-c', `model_providers.openagents.env_key=${q('OPENAI_API_KEY')}`,
+          '-c', `model_providers.openagents.wire_api=${q('responses')}`,
+        );
+        if (this._customProvider.reasoningEffort) {
+          cmd.push('-c', `model_reasoning_effort=${q(this._customProvider.reasoningEffort)}`);
+        }
+      }
+
       // Working directory
       if (this.workingDir) {
         cmd.push('-C', this.workingDir);

package/src/adapters/cursor-node-entry.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Where Cursor's Windows launcher keeps the node it runs. Shared by the
+ * adapter (to start a turn) and the installer (to ask `cursor-agent status`),
+ * so neither goes through cmd.exe and PowerShell.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/** A Cursor version directory: YYYY.MM.DD-commit, or YYYY.MM.DD-HH-MM-SS-commit. */
+const CURSOR_VERSION_DIR = /^(\d{4})\.(\d{1,2})\.(\d{1,2})(-\d{2}-\d{2}-\d{2})?-[a-f0-9]+$/;
+
+/** The node.exe + index.js pair in one install root (beside it, or its newest version). */
+function entryUnder(dir) {
+  const pair = (d) => {
+    const node = path.join(d, 'node.exe');
+    const entry = path.join(d, 'index.js');
+    return fs.existsSync(node) && fs.existsSync(entry) ? [node, entry] : null;
+  };
+  const beside = pair(dir);
+  if (beside) return beside;
+
+  let names;
+  try { names = fs.readdirSync(path.join(dir, 'versions')); } catch { return null; }
+  const day = (name) => {
+    const m = name.match(CURSOR_VERSION_DIR);
+    return Number(m[1] + m[2].padStart(2, '0') + m[3].padStart(2, '0'));
+  };
+  const newestFirst = names
+    .filter((name) => CURSOR_VERSION_DIR.test(name))
+    .sort((a, b) => day(b) - day(a) || (a < b ? 1 : -1));
+  for (const name of newestFirst) {
+    const found = pair(path.join(dir, 'versions', name));
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * The `node.exe` + `index.js` pair behind Cursor's Windows launcher, or null.
+ *
+ * The Windows install is not an npm shim. cursor-agent.cmd hands its arguments
+ * to PowerShell, and cursor-agent.ps1 runs the node.exe shipped in the newest
+ * `versions\<version>` directory (or beside the script) on that directory's
+ * index.js. This is the same lookup, so the caller can start node itself.
+ *
+ * The launcher found on PATH is not always inside the install (a copy or link
+ * in ~/.local/bin, say), so the installer's default root,
+ * %LOCALAPPDATA%\cursor-agent, is tried next.
+ */
+function resolveCursorNodeEntry(binPath, env = process.env) {
+  const dir = path.dirname(path.resolve(binPath));
+  const found = entryUnder(dir);
+  if (found) return found;
+  const localAppData = env && env.LOCALAPPDATA;
+  if (!localAppData) return null;
+  const root = path.join(localAppData, 'cursor-agent');
+  if (path.resolve(root) === dir) return null;
+  return entryUnder(root);
+}
+
+module.exports = { resolveCursorNodeEntry, CURSOR_VERSION_DIR };

package/src/adapters/cursor.js

@@ -22,6 +22,7 @@ const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
 const { buildCursorSkillMd, workspaceSkillName } = require('./workspace-prompt');
 const { defaultAgentWorkdir, whichBinary, whereBinary } = require('../paths');
+const { resolveCursorNodeEntry } = require('./cursor-node-entry');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -267,6 +268,18 @@ class CursorAdapter extends BaseAdapter {
   }
 
   _resolveToNodeCmd(binPath) {
+    // Cursor's own launcher first. Left to the `cmd.exe /c` fallback below, the
+    // prompt goes through cmd.exe and PowerShell before it reaches node, and
+    // cmd.exe stops reading a command line at its first newline. Every prompt
+    // carries one (the identity header ends in a blank line), so the message
+    // itself and every flag after it — --output-format, --trust, --force,
+    // --model, --workspace, --resume — were dropped. The CLI then ran the
+    // header alone, untrusted, and exited with "Workspace Trust Required",
+    // which reached the chat as "No response generated".
+    if (IS_WINDOWS) {
+      const own = resolveCursorNodeEntry(binPath);
+      if (own) return own;
+    }
     const nodeBin = this._findNodeBin();
     if (IS_WINDOWS && binPath.toLowerCase().endsWith('.cmd')) {
       const cmdDir = path.dirname(path.resolve(binPath));
@@ -440,14 +453,30 @@ class CursorAdapter extends BaseAdapter {
     if (this._stoppedBeforeStart(msgChannel)) return;
 
     try {
-      const resolved = this._resolveToNodeCmd(cmd[0]);
+      const launcher = cmd[0];
+      const resolved = this._resolveToNodeCmd(launcher);
       if (resolved) {
         cmd = [...resolved, ...cmd.slice(1)];
       } else if (IS_WINDOWS && cmd[0].toLowerCase().endsWith('.cmd')) {
+        if (cmd.some((a) => typeof a === 'string' && a.includes('\n'))) {
+          this._log(
+            `Could not find Cursor's node.exe for ${launcher}; starting it through cmd.exe, `
+            + 'which stops reading at the first newline, so the prompt and the flags after it may be truncated',
+            'warn',
+          );
+        }
         cmd = ['cmd.exe', '/c', ...cmd];
       }
 
       const cleanEnv = { ...(this.agentEnv || process.env) };
+      // Starting node directly skips Cursor's launcher script, so set what the
+      // script would have: its own name, and node's compile cache.
+      if (IS_WINDOWS && resolved) {
+        if (!cleanEnv.CURSOR_INVOKED_AS) cleanEnv.CURSOR_INVOKED_AS = path.basename(launcher);
+        if (!cleanEnv.NODE_COMPILE_CACHE && cleanEnv.LOCALAPPDATA) {
+          cleanEnv.NODE_COMPILE_CACHE = path.join(cleanEnv.LOCALAPPDATA, 'cursor-compile-cache');
+        }
+      }
 
       const proc = spawn(cmd[0], cmd.slice(1), {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -680,3 +709,4 @@ function _extractToolDetail(tc) {
 }
 
 module.exports = CursorAdapter;
+module.exports.resolveCursorNodeEntry = resolveCursorNodeEntry;