regent-code 3.0.5 → 3.0.7

package/.opencode/INSTALL.md

@@ -6,7 +6,7 @@ If the package is published to npm, both the plugin and the MCP server install
 with a single command against any existing `opencode.json` / `opencode.jsonc`:
 
 ```bash
-npx -y regent-code@3.0.5 install
+npx -y regent-code@3.0.7 install
 ```
 
 Patches the project config (or the global `~/.config/opencode/` config) to add
@@ -19,7 +19,7 @@ Patches the project config (or the global `~/.config/opencode/` config) to add
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.5"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.7"],
 }
 ```
 
@@ -32,7 +32,7 @@ Patches the project config (or the global `~/.config/opencode/` config) to add
 }
 ```
 
-The pinned version is recommended. Use the unpinned branch only when you intentionally want the latest changes. The `v3.0.5` git tag must be pushed to GitHub before the pinned spec resolves.
+The pinned version is recommended. Use the unpinned branch only when you intentionally want the latest changes. The `v3.0.7` git tag must be pushed to GitHub before the pinned spec resolves.
 
 ## Single-source rule (duplicate plugin ID)
 

package/README.md

@@ -51,7 +51,7 @@ Add Regent to your OpenCode configuration:
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.5"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.7"],
 }
 ```
 
@@ -69,7 +69,7 @@ are read from the persisted transcript when the service stores turns, otherwise
 from the synchronous `session.generate` text; agent catalogs are queried with
 and without an explicit location scope; and the caller-authorization guardrail
 degrades OPEN when the runtime agent API is unresolvable (only recursion from
-known worker sessions stays hard-blocked). The `v3.0.5` git tag must be pushed
+known worker sessions stays hard-blocked). The `v3.0.7` git tag must be pushed
 to GitHub before this pinned spec resolves.
 
 > **Windows dev-machine warning (single-source rule):** when this repository is open as an OpenCode project, its own `.opencode/plugins/regent.js` is auto-loaded as a project plugin. Do NOT also pin regent in `opencode.jsonc` on the same machine — two active sources make host plugin reloads fail with `Duplicate plugin ID: regent`, leaving sessions with a torn tool surface and blocking live skill/plugin edits. Either develop unpinned (project plugin only) or pin the repo file directly: `"plugins": ["file:///Q:/PROJECTS/PERSONAL/regent-code/.opencode/plugins/regent.js"]`. One source of truth, always.
@@ -79,13 +79,13 @@ to GitHub before this pinned spec resolves.
 The fastest way to get **both** the plugin and the MCP server on any machine — no cloning, no manual config edits, no local files:
 
 ```bash
-npx -y regent-code@3.0.5 install
+npx -y regent-code@3.0.7 install
 ```
 
 The installer finds an existing `opencode.json` / `opencode.jsonc` (project config in the current directory first, then the global `~/.config/opencode/` config) and adds both entries:
 
 - **MCP server**: `mcp.servers.regent` → runs `["npx", "-y", "regent-code"]`. That single command spawns the server through the package's `bin` — no absolute paths, no global install, no per-machine shims.
-- **Plugin**: `plugins` → `regent-code@3.0.5`
+- **Plugin**: `plugins` → `regent-code@3.0.7`
 
 It is **idempotent and non-destructive** — it only adds or updates regent entries, preserving comments, trailing commas, and every unrelated setting in the file. Re-run it to upgrade the pinned version. Flags: `--global` forces the user config, `--file <path>` targets an exact file, `--help` explains all options. Restart the OpenCode session afterwards — plugin load and MCP connection happen on config load.
 

package/mcp/index.js

@@ -176,18 +176,28 @@ async function createWorkerResolver(client, options = {}) {
     }
 
     const candidates = [];
+    // Built-in subagents are last-resort fallbacks; project-defined and
+    // third-party child-capable agents are the preferred workers.
+    const BUILTIN_SUBAGENTS = new Set(['general', 'explore']);
     if (isChildCapableAgent(catalog.find((agent) => agent.id === 'regent-general'))) {
       candidates.push('regent-general');
     }
-    const configuredGeneral = catalog.find((agent) => agent.id === 'general');
-    if (!configuredGeneral || isChildCapableAgent(configuredGeneral)) {
-      candidates.push('general');
-    }
     for (const agent of catalog) {
-      if (isChildCapableAgent(agent) && !candidates.includes(agent.id)) {
+      if (
+        isChildCapableAgent(agent) &&
+        !BUILTIN_SUBAGENTS.has(agent.id) &&
+        !candidates.includes(agent.id)
+      ) {
         candidates.push(agent.id);
       }
     }
+    if (isChildCapableAgent(catalog.find((agent) => agent.id === 'explore'))) {
+      candidates.push('explore');
+    }
+    const configuredGeneral = catalog.find((agent) => agent.id === 'general');
+    if (!configuredGeneral || isChildCapableAgent(configuredGeneral)) {
+      candidates.push('general');
+    }
 
     if (candidates.length === 0) {
       return { ok: false, error: 'No visible child-capable worker agent is available' };
@@ -227,7 +237,11 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
   }
 
   const key = 'mcp';
-  const directory = process.cwd();
+  // Worker sessions attach to the service's CURRENT project by default —
+  // explicit foreign locations resolve to unloaded scopes with empty agent
+  // catalogs ("Agent not found"). Override only via REGENT_WORKER_LOCATION.
+  const workerLocation = (process.env.REGENT_WORKER_LOCATION || '').trim();
+  const directory = workerLocation || process.cwd();
   let session;
 
   try {
@@ -243,7 +257,8 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
     for (let index = 0; index < selection.agents.length; index++) {
       const agent = selection.agents[index];
       try {
-        const createInput = { title, agent, location: { directory } };
+        const createInput = { title, agent };
+        if (workerLocation) createInput.location = { directory: workerLocation };
         const sessionResult = await withRetry(() => client.session.create(createInput));
         session = unwrapData(sessionResult);
         if (session?.id) break;
@@ -281,10 +296,18 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
       'If you cannot complete the task, say BLOCKED and explain why.',
     ].join('\n');
 
-    const result = await withRetry(() =>
-      client.session.generate({ sessionID: session.id, prompt }),
-    );
-    const seed = extractGenerationText(unwrapData(result));
+    // Dispatch the turn as a real user message so the agent executes with its
+    // tools and permissions. `session.generate` on current services is a
+    // sessionless text completion (no agent run, zero tokens), so it is only
+    // the fallback for older services that expose generate-only dispatch.
+    let result = null;
+    try {
+      await withRetry(() => client.session.prompt({ sessionID: session.id, text: prompt }));
+    } catch (err) {
+      if (isUnavailableAgentError(err)) throw err;
+      result = await withRetry(() => client.session.generate({ sessionID: session.id, prompt }));
+    }
+    const seed = result ? extractGenerationText(unwrapData(result)) : '';
 
     // Collect the final answer once the turn has actually ended (generate
     // resolves with the first chunk on current service semantics).
@@ -307,7 +330,21 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
       };
     }
     const parsed = parseSubagentTextResponse(output);
-    const { status, concerns, filesChanged } = parsed;
+    let { status, concerns, filesChanged } = parsed;
+
+    // The completion ceremony (- summary/- status lines) is a soft contract:
+    // a wait-verified ended turn with a real answer that skipped it is still
+    // done. NEVER applied to explicit NEEDS_CONTEXT/BLOCKED markers or
+    // concerns; mid-turn fragments never reach here (they return empty and
+    // hit the blocked path above).
+    if (
+      status === 'needs_context' &&
+      concerns.length === 0 &&
+      !/\bNEEDS_CONTEXT\b/i.test(output) &&
+      output.trim()
+    ) {
+      status = 'done';
+    }
 
     if (filesChanged.length > 0) {
       sessionFileChanges.set(session.id, {
@@ -319,6 +356,9 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
       recordEvidence(session.id, filesChanged, directory);
     }
 
+    if (process.env.REGENT_TRACE_TURN === '1') {
+      console.error(`[trace] dispatch returning ${session.id.slice(-8)}`);
+    }
     return { status, output, concerns, files_changed: filesChanged, session_id: session.id };
   } catch (err) {
     const message = redactSecrets(safeErrorMessage(err)).slice(0, 500);
@@ -634,7 +674,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
-            location: process.cwd(),
+            location: process.env.REGENT_WORKER_LOCATION || '',
           });
           const result = await dispatchSubagent(client, resolveWorker, /** @type {any} */ (args));
           return toContent(result);
@@ -659,7 +699,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
-            location: process.cwd(),
+            location: process.env.REGENT_WORKER_LOCATION || '',
           });
           const queue = [...args.tasks];
           const results = [];
@@ -679,6 +719,9 @@ export function createRegentServer() {
           }
           const workerCount = Math.min(queue.length, 10);
           await Promise.all(Array.from({ length: workerCount }, () => worker()));
+          if (process.env.REGENT_TRACE_TURN === '1') {
+            console.error(`[trace] all workers done (${results.length} results)`);
+          }
           const failed = results.filter((r) => r.status === 'blocked').length;
           recordCircuitResult('mcp', results.length > 0 && failed === 0);
           return toContent({
@@ -704,7 +747,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
-            location: process.cwd(),
+            location: process.env.REGENT_WORKER_LOCATION || '',
           });
           const results = await Promise.all(
             args.questions.map(async (q) => {

package/mcp/shared.js

@@ -342,10 +342,23 @@ export function extractGenerationText(result) {
   return '';
 }
 
+/**
+ * A message is still streaming when the service stamps `time.streamed` but
+ * no `time.completed` yet. Mid-stream reads must never be treated as final.
+ * @param {any} message
+ * @returns {boolean}
+ */
+function isStillStreaming(message) {
+  const time = message?.time;
+  if (!time || time.completed != null) return false;
+  return time.streamed != null;
+}
+
 /**
  * Join the assistant text of a session transcript (SessionMessageInfo[]).
- * Only `type: "assistant"` messages contribute; reasoning/tool parts are
- * skipped. Handles both chronological and reverse (desc) orderings.
+ * Only `type: "assistant"` messages that finished streaming contribute;
+ * reasoning/tool parts are skipped. Handles chronological and reverse (desc)
+ * orderings.
  * @param {any[]} messages
  * @returns {string}
  */
@@ -354,6 +367,7 @@ export function joinAssistantText(messages) {
   const chunks = [];
   for (const message of messages) {
     if (!message || message.type !== 'assistant') continue;
+    if (isStillStreaming(message)) continue;
     const content = message.content;
     if (typeof content === 'string') {
       chunks.push(content);
@@ -414,13 +428,15 @@ export async function readTurnTranscript(sessionApi, sessionID) {
   return [];
 }
 
+const COMPLETION_BLOCK = /(?:^|\n)\s*-\s*status\s*[:=]|\bBLOCKED\b|\bsummary\s*[:=]/i;
+
 /**
- * Wait for a dispatched turn to end. The service resolves `session.generate`
- * with the FIRST text chunk while the turn continues asynchronously, so the
- * final answer only becomes read-consistent once the turn settles. Completion
- * is signalled by `session.wait` (blocks until the session is idle) when the
- * client exposes it; otherwise by transcript settlement (two consecutive
- * identical non-empty reads). Bounded by timeoutMs; never hangs.
+ * Wait for a dispatched turn to end by polling the transcript. Session waits
+ * are deliberately NOT used: long-poll `wait` calls accumulating on the
+ * service stalled the server's response path (HTTP/1.1 head-of-line
+ * blocking). Turns complete in seconds; a transcript read that carries the
+ * completion block ends immediately, and two consecutive identical non-empty
+ * reads settle the no-ceremony case. Bounded by timeoutMs; never hangs.
  * @param {any} sessionApi session or client handle
  * @param {string} sessionID
  * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
@@ -429,26 +445,22 @@ export async function readTurnTranscript(sessionApi, sessionID) {
 export async function waitForTurnEnd(
   sessionApi,
   sessionID,
-  { timeoutMs = 120000, intervalMs = 1500 } = {},
+  { timeoutMs = 120000, intervalMs = 1200 } = {},
 ) {
-  if (typeof sessionApi?.session?.wait === 'function') {
-    try {
-      await Promise.race([
-        sessionApi.session.wait({ sessionID }),
-        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
-      ]);
-      return;
-    } catch {
-      /* fall through to transcript settlement */
-    }
-  }
   const deadline = Date.now() + timeoutMs;
   let previous = '';
   let stableReads = 0;
   while (Date.now() < deadline) {
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
     const text = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
-    if (text && text === previous) {
+    if (process.env.REGENT_TRACE_TURN === '1') {
+      console.error(
+        `[turn-trace] ${sessionID.slice(-8)} iter=${stableReads} text=${JSON.stringify(text.slice(0, 60))}`,
+      );
+    }
+    if (!text) continue;
+    if (COMPLETION_BLOCK.test(text)) return;
+    if (text === previous) {
       stableReads += 1;
       if (stableReads >= 2) return;
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regent-code",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "Agent orchestration for OpenCode. From idea to shipped — zero ceremony. Plugin + MCP server.",
   "type": "module",
   "main": ".opencode/plugins/regent.js",