regent-code 3.0.4 → 3.0.5

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.4 install
+npx -y regent-code@3.0.5 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.4"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.5"],
 }
 ```
 
@@ -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.4` 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.5` 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.4"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.5"],
 }
 ```
 
@@ -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.4` git tag must be pushed
+known worker sessions stays hard-blocked). The `v3.0.5` 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.4 install
+npx -y regent-code@3.0.5 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.4`
+- **Plugin**: `plugins` → `regent-code@3.0.5`
 
 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

@@ -26,6 +26,7 @@ import {
   markEvidenceVerified,
   evidenceForScope,
   redactSecrets,
+  safeErrorMessage,
   isSensitiveFocusPath,
   parseSubagentTextResponse,
   unwrapData,
@@ -285,9 +286,26 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
     );
     const seed = extractGenerationText(unwrapData(result));
 
-    // Collect the final answer: persisted transcript wins, otherwise the
-    // synchronous generation result is the answer.
-    const output = await collectWorkerAnswer(client, session.id, seed);
+    // Collect the final answer once the turn has actually ended (generate
+    // resolves with the first chunk on current service semantics).
+    const output = await collectWorkerAnswer(client, session.id, seed, {
+      timeoutMs: Number(process.env.REGENT_TURN_TIMEOUT_MS) || 120000,
+    });
+    if (!output) {
+      try {
+        await client.session.interrupt({ sessionID: session.id });
+      } catch {
+        /* best effort */
+      }
+      return {
+        status: 'blocked',
+        output:
+          'Subagent error: worker turn ended without producing an answer (stalled or timed out)',
+        concerns: [],
+        files_changed: [],
+        session_id: session.id,
+      };
+    }
     const parsed = parseSubagentTextResponse(output);
     const { status, concerns, filesChanged } = parsed;
 
@@ -303,7 +321,7 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
 
     return { status, output, concerns, files_changed: filesChanged, session_id: session.id };
   } catch (err) {
-    const message = redactSecrets(err instanceof Error ? err.message : String(err)).slice(0, 500);
+    const message = redactSecrets(safeErrorMessage(err)).slice(0, 500);
     return {
       status: 'blocked',
       output: `Subagent error: ${message}`,
@@ -360,8 +378,11 @@ function runExplore(query, focus) {
   if (focus) {
     const worktreeRoot = path.resolve(worktree);
     const focusPath = path.resolve(worktree, focus);
+    const absoluteFocus = path.isAbsolute(focus);
+    // Absolute focus paths may point outside the project (e.g. another repo);
+    // the sensitive-path guards still apply to every segment of the path.
     const lexicalInside =
-      focusPath.startsWith(worktreeRoot + path.sep) || focusPath === worktreeRoot;
+      absoluteFocus || focusPath.startsWith(worktreeRoot + path.sep) || focusPath === worktreeRoot;
     if (!lexicalInside) {
       result += `\n## Focus: ${focus}\n(path outside project directory)\n`;
     } else if (isSensitiveFocusPath(focusPath, worktreeRoot)) {
@@ -376,8 +397,9 @@ function runExplore(query, focus) {
         /* fall back to lexical paths */
       }
       const inside =
-        (realFocus.startsWith(realRoot + path.sep) || realFocus === realRoot) &&
-        (focusPath.startsWith(worktreeRoot + path.sep) || focusPath === worktreeRoot);
+        absoluteFocus ||
+        ((realFocus.startsWith(realRoot + path.sep) || realFocus === realRoot) &&
+          (focusPath.startsWith(worktreeRoot + path.sep) || focusPath === worktreeRoot));
       if (!inside) {
         result += `\n## Focus: ${focus}\n(path outside project directory)\n`;
       } else if (isSensitiveFocusPath(realFocus, realRoot)) {

package/mcp/shared.js

@@ -1,6 +1,18 @@
 import fs from 'fs';
 import path from 'path';
 
+// ── Error helpers ──
+/** @param {unknown} err @returns {string} */
+export function safeErrorMessage(err) {
+  const value = err instanceof Error ? err.message : err;
+  if (typeof value === 'string' && value.trim()) return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
 // ── Dispatch safety limits ──
 export const MAX_DISPATCH_ITEMS = 10;
 export const MAX_STRING_LENGTH = 8000;
@@ -234,26 +246,46 @@ export function isSensitiveFocusPath(focusPath, worktreeRoot) {
 }
 
 // ── Subagent text-response parsing ──
+const STATUS_WORDS = new Set(['done', 'blocked', 'needs_context', 'done_with_concerns']);
+
 /**
+ * Parse a worker's final answer. A status line the worker was asked to emit
+ * (`- status: <word>`) wins; legacy ALL-CAPS tokens are fallbacks. `done` is
+ * only claimed when the answer has completion shape (`summary` or an explicit
+ * status line) — a bare fragment such as a mid-turn first chunk parses as
+ * needs_context, never as a false done. Empty output parses as blocked.
  * @param {string} text
  * @returns {{ status: string, concerns: string[], filesChanged: string[] }}
  */
 export function parseSubagentTextResponse(text) {
-  let status = 'done';
-  let concerns = [];
+  const trimmed = String(text || '').trim();
+  if (!trimmed) {
+    return { status: 'blocked', concerns: ['worker returned no output'], filesChanged: [] };
+  }
 
-  if (text.includes('BLOCKED')) {
+  const explicit = trimmed.match(/(?:^|\n)\s*-\s*status\s*[:=]\s*([a-z_]+)/i);
+  const statusWord = explicit ? explicit[1].toLowerCase() : '';
+  let status;
+  if (STATUS_WORDS.has(statusWord)) {
+    status = statusWord;
+  } else if (trimmed.includes('BLOCKED')) {
     status = 'blocked';
-  } else if (text.includes('NEEDS_CONTEXT')) {
+  } else if (trimmed.includes('NEEDS_CONTEXT')) {
     status = 'needs_context';
-  } else if (text.includes('CONCERN:')) {
+  } else if (trimmed.includes('CONCERN:')) {
     status = 'done_with_concerns';
-    concerns = text.match(/CONCERN:.*$/gm)?.map((c) => c.replace('CONCERN:', '').trim()) || [];
+  } else if (/\bsummary\s*[:=]/i.test(trimmed)) {
+    status = 'done';
+  } else {
+    status = 'needs_context';
   }
 
+  const concerns =
+    trimmed.match(/CONCERN:.*$/gm)?.map((c) => c.replace('CONCERN:', '').trim()) || [];
+
   const pathPattern =
     /(?:^|\n)(?:[\w./\\-]+\.[a-zA-Z0-9]+|[\w.-]+(?:[\\/][\w.-]+)+(?:\.[a-zA-Z0-9]+)?|^[A-Za-z][\w-]+\.[\w-]+|^[A-Za-z][\w-]+(?:\.[\w-]+)*$(?!\.))/gm;
-  const matches = text.match(pathPattern);
+  const matches = trimmed.match(pathPattern);
   const filesChanged = (matches || [])
     .map((f) => f.trim())
     .filter(
@@ -338,19 +370,33 @@ export function joinAssistantText(messages) {
 
 /**
  * Read the latest session transcript through whatever API the session handle
- * exposes: `message.list` (client) first, then `session.context` (plugin
- * domain), then nothing.
+ * exposes, newest contract first: `session.context` (promised client) and
+ * `message.list` (returns { data: SessionMessageInfo[], cursor }), then the
+ * legacy `session.context` plugin domain.
  * @param {any} sessionApi session or client handle
  * @param {string} sessionID
  * @returns {Promise<any[]>}
  */
 export async function readTurnTranscript(sessionApi, sessionID) {
+  if (typeof sessionApi?.session?.context === 'function') {
+    try {
+      const response = await sessionApi.session.context({ sessionID });
+      const data = unwrapData(response);
+      if (Array.isArray(data)) return data;
+      if (Array.isArray(data?.data)) return data.data;
+      if (Array.isArray(data?.messages)) return data.messages;
+      return [];
+    } catch {
+      /* fall through to message.list */
+    }
+  }
   if (typeof sessionApi?.message?.list === 'function') {
     try {
       const response = await sessionApi.message.list({ sessionID });
       const data = unwrapData(response);
       if (Array.isArray(data)) return data;
       if (Array.isArray(data?.data)) return data.data;
+      if (Array.isArray(data?.messages)) return data.messages;
       return [];
     } catch {
       /* fall through to context */
@@ -369,36 +415,72 @@ export async function readTurnTranscript(sessionApi, sessionID) {
 }
 
 /**
- * Collect the final worker answer for a dispatched turn. Version-adaptive:
- * 1. A persisted transcript (message.list / session.context) wins when the
- *    service stores turns.
- * 2. Otherwise the generation result ("seed") is the answer — current
- *    service semantics are synchronous: `generate` blocks until the turn ends
- *    and returns the full assistant text in `{text}`, persisting nothing.
- * 3. With neither available yet, wait briefly for async persistence, then
- *    give up with whatever exists (bounded, never hangs).
+ * 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.
  * @param {any} sessionApi session or client handle
  * @param {string} sessionID
- * @param {string} seed text returned by `session.generate`
  * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
- * @returns {Promise<string>}
+ * @returns {Promise<void>}
  */
-export async function collectWorkerAnswer(
+export async function waitForTurnEnd(
   sessionApi,
   sessionID,
-  seed,
-  { timeoutMs = 30000, intervalMs = 800 } = {},
+  { timeoutMs = 120000, intervalMs = 1500 } = {},
 ) {
-  const transcriptText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
-  if (transcriptText) return transcriptText;
-  if (seed) return seed;
-
+  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) return text;
+    if (text && text === previous) {
+      stableReads += 1;
+      if (stableReads >= 2) return;
+    } else {
+      stableReads = 0;
+      previous = text;
+    }
   }
+}
+
+/**
+ * Collect the final worker answer for a dispatched turn. Waits for the turn
+ * to end first: the seed from `session.generate` is only the first chunk on
+ * current service semantics, so the transcript after settlement wins. The
+ * seed is used only as a last resort when it already carries the completion
+ * block. Empty returns mean the turn produced nothing (caller reports a
+ * bounded failure instead of a false done).
+ * @param {any} sessionApi session or client handle
+ * @param {string} sessionID
+ * @param {string} seed text returned by `session.generate`
+ * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
+ * @returns {Promise<string>}
+ */
+export async function collectWorkerAnswer(
+  sessionApi,
+  sessionID,
+  seed,
+  { timeoutMs = 120000, intervalMs = 800 } = {},
+) {
+  await waitForTurnEnd(sessionApi, sessionID, { timeoutMs, intervalMs });
+  const finalText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+  if (finalText) return finalText;
+  if (seed && /(?:^|\n)\s*-\s*status\s*[:=]|BLOCKED|NEEDS_CONTEXT/.test(seed)) return seed;
   return '';
 }
 

package/package.json

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