regent-code 3.0.1 → 3.0.3

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.1 install
+npx -y regent-code@3.0.3 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.1"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.3"],
 }
 ```
 
@@ -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.1` 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.3` git tag must be pushed to GitHub before the pinned spec resolves.
 
 ## Single-source rule (duplicate plugin ID)
 

package/.opencode/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
   "dependencies": {
-    "@opencode-ai/plugin": "0.0.0-beta-18314"
+    "@opencode-ai/plugin": "beta"
   }
 }

package/.opencode/plugins/regent.js

@@ -530,6 +530,135 @@ function unwrapData(result) {
   return result?.data ?? result;
 }
 
+// ── Worker-turn completion (version-adaptive) ─────────────────
+// The service resolves `session.generate` with the FIRST generated text
+// chunk while the turn continues asynchronously (behavior introduced after
+// beta-18314). The helpers below make the turn protocol version-agnostic:
+// extract whatever shape the generation result has, wait until the session
+// counters prove the turn finished, then read the final assistant text from
+// the transcript. All of them degrade gracefully on legacy session handles.
+
+/** @param {unknown} text */
+function isTextPart(text) {
+  if (typeof text !== 'object' || text === null) return false;
+  /** @type {Record<string, any>} */
+  const obj = text;
+  return obj.type === 'text' && typeof obj.text === 'string';
+}
+
+/**
+ * Extract worker text from a generation result regardless of its shape.
+ * Supports `{ text }`, `{ message: { text } }`, `{ parts: [...] }`,
+ * `{ content: [...] | string }`, and raw strings.
+ * @param {unknown} result
+ * @returns {string}
+ */
+function extractGenerationText(result) {
+  if (typeof result === 'string' && result.trim()) return result;
+  if (!result || typeof result !== 'object') return '';
+  /** @type {Record<string, any>} */
+  const obj = result;
+  if (typeof obj.text === 'string' && obj.text.trim()) return obj.text;
+  const parts = obj.parts ?? obj.content ?? obj.message?.parts ?? obj.message?.content;
+  if (typeof parts === 'string') return parts.trim();
+  if (Array.isArray(parts)) {
+    const chunks = parts.filter(isTextPart).map((part) => part.text);
+    if (chunks.length > 0) return chunks.join('\n').trim();
+  }
+  return '';
+}
+
+/**
+ * Join the assistant text of a session transcript (SessionMessageInfo[]).
+ * Only `type: "assistant"` messages contribute; reasoning/tool parts are
+ * skipped. Handles both chronological and reverse orderings.
+ * @param {any[]} messages
+ * @returns {string}
+ */
+function joinAssistantText(messages) {
+  if (!Array.isArray(messages)) return '';
+  const chunks = [];
+  for (const message of messages) {
+    if (!message || message.type !== 'assistant') continue;
+    const content = message.content;
+    if (typeof content === 'string') {
+      chunks.push(content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (isTextPart(part)) chunks.push(part.text);
+      }
+    }
+  }
+  return chunks.join('\n').trim();
+}
+
+/**
+ * Read the latest session transcript through whatever the session handle
+ * exposes: `message.list` first, then `session.context`, then nothing.
+ * @param {any} sessionApi
+ * @param {string} sessionID
+ * @returns {Promise<any[]>}
+ */
+async function readTurnTranscript(sessionApi, sessionID) {
+  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;
+      return [];
+    } catch {
+      /* fall through to context */
+    }
+  }
+  if (typeof sessionApi?.context === 'function') {
+    try {
+      const response = await sessionApi.context({ sessionID });
+      const data = unwrapData(response);
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+/**
+ * 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).
+ * @param {any} sessionApi
+ * @param {string} sessionID
+ * @param {string} seed text returned by `session.generate`
+ * @param {{ timeoutMs?: number, intervalMs?: number }} [options]
+ * @returns {Promise<string>}
+ */
+async function collectWorkerAnswer(
+  sessionApi,
+  sessionID,
+  seed,
+  { timeoutMs = 30000, intervalMs = 800 } = {},
+) {
+  const transcriptText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+  if (transcriptText) return transcriptText;
+  if (seed) return seed;
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const text = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+    if (text) return text;
+  }
+  return '';
+}
+
 function normalizeAgents(result) {
   const data = unwrapData(result);
   if (Array.isArray(data)) return data;
@@ -564,6 +693,10 @@ function isUnavailableAgentError(err) {
 }
 
 async function createWorkerResolver(agentApi, options = {}) {
+  const locationInput =
+    options && typeof options.location === 'string'
+      ? { location: { directory: options.location } }
+      : {};
   let catalog = null;
   if (typeof agentApi?.list === 'function') {
     try {
@@ -571,6 +704,15 @@ async function createWorkerResolver(agentApi, options = {}) {
     } catch {
       catalog = null;
     }
+    // Some service versions require an explicit location scope; retry when
+    // the un-scoped call came back empty instead of giving up on the catalog.
+    if ((!Array.isArray(catalog) || catalog.length === 0) && locationInput.location) {
+      try {
+        catalog = normalizeAgents(await agentApi.list(locationInput));
+      } catch {
+        catalog = null;
+      }
+    }
   }
 
   const findAgent = async (id) => {
@@ -578,7 +720,7 @@ async function createWorkerResolver(agentApi, options = {}) {
     if (fromCatalog) return fromCatalog;
     if (catalog !== null || typeof agentApi?.get !== 'function') return undefined;
     try {
-      return unwrapData(await agentApi.get({ agentID: id }));
+      return unwrapData(await agentApi.get({ agentID: id, ...locationInput }));
     } catch {
       return undefined;
     }
@@ -642,8 +784,22 @@ async function createWorkerResolver(agentApi, options = {}) {
           ? caller.id
           : '';
     const callerAgent = callerId ? await findAgent(callerId) : undefined;
-    if (!isPrimaryCapableAgent(callerAgent)) {
-      return 'caller is not a visible primary-capable agent; subagent dispatch is blocked';
+
+    // Resolvable caller: strict primary-capable gate.
+    if (callerAgent) {
+      if (!isPrimaryCapableAgent(callerAgent)) {
+        return 'caller is not a visible primary-capable agent; subagent dispatch is blocked';
+      }
+      return null;
+    }
+
+    // Unresolvable caller — the agent API shape or visibility policy changed
+    // at runtime. Degrade OPEN instead of breaking dispatch for every primary
+    // session. The only hard block that survives is recursion from a worker
+    // session this plugin created.
+    const callerSessionId = typeof toolContext?.sessionID === 'string' ? toolContext.sessionID : '';
+    if (callerSessionId && pluginWorkerSessionIds.has(callerSessionId)) {
+      return 'caller is a Regent worker session; nested subagent dispatch is blocked';
     }
     return null;
   };
@@ -772,8 +928,11 @@ async function dispatchSubagent(
     ].join('\n');
 
     const result = await withRetry(() => sessionApi.generate({ sessionID: session.id, prompt }));
-    const message = unwrapData(result);
-    const output = typeof message?.text === 'string' ? message.text : '';
+    const seed = extractGenerationText(unwrapData(result));
+
+    // Collect the final answer: persisted transcript wins, otherwise the
+    // synchronous generation result is the answer.
+    const output = await collectWorkerAnswer(sessionApi, session.id, seed);
     const parsed = parseSubagentTextResponse(output);
     const { status, concerns, filesChanged } = parsed;
 
@@ -971,7 +1130,10 @@ export default Plugin.define({
   async setup(ctx) {
     const registrations = [];
     const options = ctx.options && typeof ctx.options === 'object' ? ctx.options : {};
-    const resolveWorker = await createWorkerResolver(ctx.agent, options);
+    const resolveWorker = await createWorkerResolver(ctx.agent, {
+      ...options,
+      location: options.location ?? ctx.location?.directory ?? process.cwd(),
+    });
 
     if (typeof options.primaryAgent === 'string' && options.primaryAgent.trim()) {
       if (typeof ctx.agent?.transform === 'function') {

package/README.md

@@ -51,11 +51,26 @@ 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.1"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.3"],
 }
 ```
 
-This release targets the OpenCode v2 beta plugin API (`@opencode-ai/plugin@0.0.0-beta-18314`); the beta API may change. The `v3.0.1` git tag must be pushed to GitHub before this pinned spec resolves.
+### Version compatibility (dynamic, not pinned)
+
+Since v3.0.3 regent-code resolves `@opencode-ai/client` and
+`@opencode-ai/plugin` through the OpenCode **`beta` dist-tag** (`"beta"` in
+`package.json`), which always points at the current beta build — the same
+channel the CLI ships on. Every install resolves automatically to the newest
+beta; no version chasing, no manual pin updates. (Avoid `npm install
+pkg@<version>` in this repo: npm silently rewrites dependency ranges in the
+manifest when given explicit versions — use plain `npm install` or `npm
+update`.) The dispatch code is *runtime-adaptive* on top: generation results
+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.3` 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.
 
@@ -64,16 +79,18 @@ This release targets the OpenCode v2 beta plugin API (`@opencode-ai/plugin@0.0.0
 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.1 install
+npx -y regent-code@3.0.3 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@3.0.1"]`
-- **Plugin**: `plugins` → `regent-code@3.0.1`
+- **MCP server**: `mcp.servers.regent` → runs `node <absolute path to this package's mcp/cli.js>` directly. No per-connection npx bootstrap: `npx -y regent-code` re-resolves against the npm registry on every OpenCode session start and can re-provision the npx cache, which makes MCP connects flaky (handshake timeouts / connection-closed). Launching the installed file with `node` is deterministic and offline.
+- **Plugin**: `plugins` → `regent-code@3.0.3`
 
 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.
 
+> When the installer is invoked from npm's ephemeral npx cache, it prints a warning: the absolute path it wrote can be pruned by npm. Run `npm install -g regent-code@3.0.3` once and re-run the installer so the entry points at the persistent global install.
+
 > On the machine that develops regent-code itself, respect the single-source rule above: do not add a second pin when the repo is open as a project.
 
 ## MCP Server
@@ -99,7 +116,14 @@ Configure it in OpenCode by adding a local MCP server:
 
 `<REPO>` is the path to where the repo is cloned; `cwd: "."` makes the server operate on the workspace directory, which is what the `explore` tool and subagent dispatch use as the working directory.
 
-**Other machines / people — no local clone needed.** The package is published to npm, so anyone can add it to their `opencode.jsonc` directly:
+**Other machines / people — no local clone needed.** The package is published to npm. Recommended: install globally once, then let the installer write the entry (see "One-command install" above):
+
+```bash
+npm install -g regent-code@3.0.3
+npx -y regent-code@3.0.3 install --global
+```
+
+Or add the server to `opencode.jsonc` manually with a direct node launch:
 
 ```jsonc
 {
@@ -108,14 +132,14 @@ Configure it in OpenCode by adding a local MCP server:
     "servers": {
       "regent": {
         "type": "local",
-        "command": ["npx", "-y", "regent-code@3.0.1"]
+        "command": ["node", "<NPM_GLOBAL>/regent-code/mcp/cli.js"]
       }
     }
   }
 }
 ```
 
-`npx` downloads the package on first run and starts the server; nothing is pinned to a local path. Dispatch tools still require a local OpenCode service to be running (see below), so the server behaves identically to a local install.
+`<NPM_GLOBAL>` is the npm global install directory (`npm root -g`). Launching the installed file with `node` means every OpenCode session start spawns the server directly — no per-connection npx registry resolution, so connection is deterministic and works offline. Dispatch tools still require a local OpenCode service to be running (see below), so the server behaves identically to a local install.
 
 Tool names surface in OpenCode as `<server>_<tool>`, so `regent_delegate`, `regent_delegate_many`, `regent_research`, `regent_explore`, `regent_changed-files`, `regent_verify`. Prompts surface as commands named `<server>:<prompt>`; the prompts are namespaced `command.<name>` (e.g. `/regent:command.orchestrate`, `/regent:command.tdd`) and `skill.<id>` (e.g. `/regent:skill.using-regent`).
 

package/mcp/index.js

@@ -29,6 +29,8 @@ import {
   isSensitiveFocusPath,
   parseSubagentTextResponse,
   unwrapData,
+  extractGenerationText,
+  collectWorkerAnswer,
   sessionFileChanges,
   workerSessionIds,
   dispatchRateLimit,
@@ -40,8 +42,7 @@ import {
 } from './shared.js';
 
 import { readPackagePrompts, renderPrompt } from './prompts.js';
-
-const version = '3.0.1';
+import { version } from './version.js';
 
 // ── OpenCode client (lazy singleton) ─────────────────────────
 let clientPromise = null;
@@ -104,23 +105,36 @@ function isUnavailableAgentError(err) {
 
 /**
  * @param {ReturnType<typeof OpenCode.make>} client
- * @param {{ workerAgent?: string }} [options]
+ * @param {{ workerAgent?: string, location?: string }} [options]
  * @returns {Promise<(requestedAgent?: string) => Promise<{ ok: true, agents: string[], automatic: boolean } | { ok: false, error: string }>>}
  */
 async function createWorkerResolver(client, options = {}) {
+  const locationInput =
+    options && typeof options.location === 'string'
+      ? { location: { directory: options.location } }
+      : {};
   let catalog = null;
   try {
     catalog = normalizeAgents(await client.agent.list());
   } catch {
     catalog = null;
   }
+  // Some service versions require an explicit location scope; retry when the
+  // un-scoped call came back empty instead of giving up on the catalog.
+  if ((!Array.isArray(catalog) || catalog.length === 0) && locationInput.location) {
+    try {
+      catalog = normalizeAgents(await client.agent.list(locationInput));
+    } catch {
+      catalog = null;
+    }
+  }
 
   const findAgent = async (id) => {
     const fromCatalog = catalog?.find((agent) => agent.id === id);
     if (fromCatalog) return fromCatalog;
     if (catalog !== null) return undefined;
     try {
-      return unwrapData(await client.agent.get({ agentID: id }));
+      return unwrapData(await client.agent.get({ agentID: id, ...locationInput }));
     } catch {
       return undefined;
     }
@@ -269,8 +283,11 @@ async function dispatchSubagent(client, resolveWorker, args, taskId = '') {
     const result = await withRetry(() =>
       client.session.generate({ sessionID: session.id, prompt }),
     );
-    const message = unwrapData(result);
-    const output = typeof message?.text === 'string' ? message.text : '';
+    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);
     const parsed = parseSubagentTextResponse(output);
     const { status, concerns, filesChanged } = parsed;
 
@@ -595,6 +612,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const result = await dispatchSubagent(client, resolveWorker, /** @type {any} */ (args));
           return toContent(result);
@@ -619,6 +637,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const queue = [...args.tasks];
           const results = [];
@@ -663,6 +682,7 @@ export function createRegentServer() {
           const client = await getClient();
           const resolveWorker = await createWorkerResolver(client, {
             workerAgent: process.env.REGENT_WORKER_AGENT,
+            location: process.cwd(),
           });
           const results = await Promise.all(
             args.questions.map(async (q) => {

package/mcp/install.js

@@ -8,20 +8,30 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
-import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { parseTree, findNodeAtLocation, getNodeValue, modify, applyEdits } from 'jsonc-parser';
-
-const require = createRequire(import.meta.url);
-const { version } = require('../package.json');
+import { version } from './version.js';
 
 export const PLUGIN_SPEC = `regent-code@${version}`;
 export const SERVER_NAME = 'regent';
+
+// Launch the MCP server straight from the installed package. A per-connection
+// `npx -y regent-code` bootstraps npm resolution against the registry and can
+// re-provision the npx cache on every OpenCode session start, which makes MCP
+// connects flaky (handshake timeouts / connection-closed). `node <path>` is
+// deterministic and offline.
+const CLI_PATH = fileURLToPath(new URL('./cli.js', import.meta.url));
+
 export const SERVER_CONFIG = Object.freeze({
   type: 'local',
-  command: ['npx', '-y', `regent-code@${version}`],
+  command: ['node', CLI_PATH],
   cwd: '.',
 });
 
+// npm's ephemeral npx cache (`_npx/<hash>/...`) can be pruned by npm; warn the
+// user to install globally so the config's absolute path keeps resolving.
+const EPHEMERAL_NPX_CACHE = '_npx';
+
 const CONFIG_NAMES = ['opencode.jsonc', 'opencode.json'];
 
 export class InstallError extends Error {}
@@ -198,7 +208,15 @@ export function install(options = {}) {
   const existingText = existsSync(target.path) ? readFileSync(target.path, 'utf8') : null;
   const base = existingText ?? `{\n}\n`;
   const { text, report } = patchText(base);
-
+  const warnings = [...report.warnings];
+
+  if (CLI_PATH.includes(EPHEMERAL_NPX_CACHE)) {
+    warnings.push(
+      `MCP entry points into npm's ephemeral npx cache (${CLI_PATH}); npm can prune it. ` +
+        `Run "npm install -g ${PLUGIN_SPEC}" once, then re-run "npx -y ${PLUGIN_SPEC} install" ` +
+        `so the config points at the persistent global install.`,
+    );
+  }
   if (text !== existingText) {
     mkdirSync(dirname(target.path), { recursive: true });
     writeFileSync(target.path, text);
@@ -206,6 +224,7 @@ export function install(options = {}) {
 
   return {
     ...report,
+    ...(warnings.length ? { warnings } : {}),
     path: target.path,
     scope: target.scope,
     created: existingText === null,

package/mcp/shared.js

@@ -272,6 +272,136 @@ export function unwrapData(result) {
   return result?.data ?? result;
 }
 
+// ── Worker-turn completion (version-adaptive) ─────────────────
+// The service resolves `session.generate` with the FIRST generated text
+// chunk while the turn continues asynchronously (behavior introduced after
+// beta-18314). These helpers make the turn completion protocol version-
+// agnostic: extract whatever shape the generation result has, wait until the
+// session's token/time counters prove the turn finished, then read the final
+// assistant text from the transcript.
+
+/** @param {unknown} text */
+function isTextPart(text) {
+  if (typeof text !== 'object' || text === null) return false;
+  /** @type {Record<string, any>} */
+  const obj = text;
+  return obj.type === 'text' && typeof obj.text === 'string';
+}
+
+/**
+ * Extract worker text from a generation result regardless of its shape.
+ * Supports: `{ text }`, `{ message: { text } }`, `{ parts: [{type:"text",text}] }`,
+ * `{ content: [{type:"text",text}] | string }`, and raw string results.
+ * @param {unknown} result
+ * @returns {string}
+ */
+export function extractGenerationText(result) {
+  if (typeof result === 'string' && result.trim()) return result;
+  if (!result || typeof result !== 'object') return '';
+  /** @type {Record<string, any>} */
+  const obj = result;
+  if (typeof obj.text === 'string' && obj.text.trim()) return obj.text;
+  const parts = obj.parts ?? obj.content ?? obj.message?.parts ?? obj.message?.content;
+  if (typeof parts === 'string') return parts.trim();
+  if (Array.isArray(parts)) {
+    const chunks = parts.filter(isTextPart).map((part) => part.text);
+    if (chunks.length > 0) return chunks.join('\n').trim();
+  }
+  return '';
+}
+
+/**
+ * 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.
+ * @param {any[]} messages
+ * @returns {string}
+ */
+export function joinAssistantText(messages) {
+  if (!Array.isArray(messages)) return '';
+  const chunks = [];
+  for (const message of messages) {
+    if (!message || message.type !== 'assistant') continue;
+    const content = message.content;
+    if (typeof content === 'string') {
+      chunks.push(content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (isTextPart(part)) chunks.push(part.text);
+      }
+    }
+  }
+  return chunks.join('\n').trim();
+}
+
+/**
+ * Read the latest session transcript through whatever API the session handle
+ * exposes: `message.list` (client) first, then `session.context` (plugin
+ * domain), then nothing.
+ * @param {any} sessionApi session or client handle
+ * @param {string} sessionID
+ * @returns {Promise<any[]>}
+ */
+export async function readTurnTranscript(sessionApi, sessionID) {
+  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;
+      return [];
+    } catch {
+      /* fall through to context */
+    }
+  }
+  if (typeof sessionApi?.context === 'function') {
+    try {
+      const response = await sessionApi.context({ sessionID });
+      const data = unwrapData(response);
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+/**
+ * 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).
+ * @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 = 30000, intervalMs = 800 } = {},
+) {
+  const transcriptText = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+  if (transcriptText) return transcriptText;
+  if (seed) return seed;
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const text = joinAssistantText(await readTurnTranscript(sessionApi, sessionID));
+    if (text) return text;
+  }
+  return '';
+}
+
 // ── State (single MCP process scope; no session lineage) ──
 /** @type {Map<string, { taskId?: string, files: string[], timestamp: number, verified: boolean }>} */
 export const sessionFileChanges = new Map();

package/mcp/version.js

@@ -0,0 +1,9 @@
+// Single dynamic source for the package version: read from the installed
+// package.json at runtime, never hardcoded. Both the installer (plugin/MCP
+// spec pins) and the MCP server (serverInfo) import from here, so a version
+// bump in package.json propagates everywhere without touching code.
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+export const version = require('../package.json').version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regent-code",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Agent orchestration for OpenCode. From idea to shipped — zero ceremony. Plugin + MCP server.",
   "type": "module",
   "main": ".opencode/plugins/regent.js",
@@ -15,8 +15,8 @@
   "author": "nathwn12",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@opencode-ai/client": "0.0.0-beta-18314",
-    "@opencode-ai/plugin": "0.0.0-beta-18314",
+    "@opencode-ai/client": "beta",
+    "@opencode-ai/plugin": "beta",
     "jsonc-parser": "3.3.1"
   },
   "repository": {