regent-code 3.0.0 → 3.0.2

package/.opencode/INSTALL.md

@@ -1,11 +1,25 @@
 # Installation
 
+## One-command install
+
+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
+```
+
+Patches the project config (or the global `~/.config/opencode/` config) to add
+`mcp.servers.regent` and the `plugins` entry. Idempotent and non-destructive;
+`--global` forces the user config, `--file <path>` targets an exact file,
+`--help` for options. Restart the OpenCode session afterwards.
+
 ## Add to opencode.jsonc
 
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v2.7.1"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.1"],
 }
 ```
 
@@ -18,7 +32,7 @@
 }
 ```
 
-The pinned version is recommended. Use the unpinned branch only when you intentionally want the latest changes. The `v2.7.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.1` 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": "^0.0.0-beta-18414"
   }
 }

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,14 +51,46 @@ Add Regent to your OpenCode configuration:
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v2.7.1"],
+  "plugins": ["regent-code@git+https://github.com/nathwn12/regent-code.git#v3.0.2"],
 }
 ```
 
-This release targets the OpenCode v2 beta plugin API (`@opencode-ai/plugin@0.0.0-beta-18155`); the beta API may change. The `v2.7.1` git tag must be pushed to GitHub before this pinned spec resolves.
+### Version compatibility (dynamic, not pinned)
+
+Since v3.0.2 regent-code does **not** pin a specific OpenCode beta. Both the
+plugin and the MCP server depend on `@opencode-ai/client` and
+`@opencode-ai/plugin` through a floating beta range
+(`>=0.0.0-beta-18314 <0.0.0-beta-99999`) that resolves the newest beta on every
+install — matching whatever service version that machine runs, no manual pin
+updates. 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). If the beta track ever renumbers
+(e.g. `0.1.0`), raise the range's upper bound in `package.json` and
+`.opencode/package.json`.
+The `v3.0.2` 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.
 
+## One-command install
+
+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.2 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.2"]`
+- **Plugin**: `plugins` → `regent-code@3.0.2`
+
+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.
+
+> 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
 
 Since v3.0.0, regent-code ships a second distribution alongside the plugin: a Model Context Protocol (MCP) server that exposes the same six tools (`delegate`, `delegate_many`, `research`, `explore`, `changed-files`, `verify`) plus the Regent command and skill corpus as MCP prompts. It is out-of-process and works from any MCP client (Claude Desktop, Cursor, or OpenCode).
@@ -91,7 +123,7 @@ Configure it in OpenCode by adding a local MCP server:
     "servers": {
       "regent": {
         "type": "local",
-        "command": ["npx", "-y", "regent-code@3.0.0"]
+        "command": ["npx", "-y", "regent-code@3.0.2"]
       }
     }
   }

package/mcp/cli.js

@@ -1,9 +1,83 @@
-// Launch the Regent MCP server. Used as the package `bin` entry so that
-// `npx -y regent-code` starts the server over stdio without needing a local
-// clone. Keep this file dependency-free and side-effect-only by design.
+// Regent CLI entry (package `bin`).
+//   no arguments  -> run the MCP server over stdio (that is what a local
+//                    `mcp.servers` entry in OpenCode invokes)
+//   install       -> patch an existing opencode.json / opencode.jsonc to
+//                    register the Regent MCP server AND plugin; idempotent and
+//                    non-destructive, can create the config when missing
+//   anything else -> usage error
 import { main } from './index.js';
+import { install, InstallError, PLUGIN_SPEC, SERVER_NAME } from './install.js';
 
-main().catch((err) => {
-  console.error(err);
+const USAGE = `Usage: npx -y ${PLUGIN_SPEC} install [--global] [--file <path>] [--help]
+
+Patches an existing opencode.json / opencode.jsonc (V2 OpenCode config) to
+register:
+  - MCP server "${SERVER_NAME}" running ${PLUGIN_SPEC}
+  - plugin ${PLUGIN_SPEC}
+
+Without flags: patches ./opencode.json(c) or ./.opencode/opencode.json(c) when
+present, otherwise the global ~/.config/opencode config, creating it if needed.
+
+  --global  patch (or create) the user-global config instead
+  --file P  patch the exact file path (wins over --global)
+  --help    show this help
+
+Non-destructive and idempotent: only adds or updates regent entries, leaving
+comments, formatting, and unrelated settings untouched. Restart the OpenCode
+session afterwards — plugin load and MCP connection happen on config load.`;
+
+function runInstaller(args) {
+  const options = { cwd: process.cwd() };
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--global':
+        options.global = true;
+        break;
+      case '--file':
+        if (!args[i + 1]) throw new InstallError('--file requires a path argument');
+        options.file = args[++i];
+        break;
+      case '--help':
+        console.log(USAGE);
+        process.exit(0);
+        break;
+      default:
+        throw new InstallError(`unknown argument: ${args[i]}\n\n${USAGE}`);
+    }
+  }
+
+  const report = install(options);
+  const lines = [
+    `Installed into: ${report.path} (${report.scope}${report.created ? ', created' : ''})`,
+    `  MCP server "${SERVER_NAME}": ${report.mcp}`,
+    `  Plugin ${PLUGIN_SPEC}:        ${report.plugin}`,
+    '',
+    ...report.warnings.map((warning) => `  warning: ${warning}`),
+    '',
+    'Restart your OpenCode session — the plugin registers on load and the',
+    'MCP server connects on the next config load.',
+  ];
+  console.log(lines.join('\n'));
+}
+
+const args = process.argv.slice(2);
+
+if (args[0] === 'install') {
+  try {
+    runInstaller(args.slice(1));
+  } catch (err) {
+    if (err instanceof InstallError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+} else if (args.length === 0) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+} else {
+  console.error(`Unknown arguments: ${args.join(' ')}\n\n${USAGE}`);
   process.exit(1);
-});
+}

package/mcp/index.js

@@ -29,6 +29,8 @@ import {
   isSensitiveFocusPath,
   parseSubagentTextResponse,
   unwrapData,
+  extractGenerationText,
+  collectWorkerAnswer,
   sessionFileChanges,
   workerSessionIds,
   dispatchRateLimit,
@@ -41,7 +43,7 @@ import {
 
 import { readPackagePrompts, renderPrompt } from './prompts.js';
 
-const version = '3.0.0';
+const version = '3.0.1';
 
 // ── OpenCode client (lazy singleton) ─────────────────────────
 let clientPromise = null;
@@ -104,23 +106,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 +284,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 +613,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 +638,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 +683,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

@@ -9,13 +9,7 @@ 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 {
-  parseTree,
-  findNodeAtLocation,
-  getNodeValue,
-  modify,
-  applyEdits,
-} from 'jsonc-parser';
+import { parseTree, findNodeAtLocation, getNodeValue, modify, applyEdits } from 'jsonc-parser';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -58,10 +52,20 @@ function findExisting(candidates) {
   return null;
 }
 
+/**
+ * @typedef {Object} InstallOptions
+ * @property {string} [cwd] Working directory for resolving relative paths and project configs.
+ * @property {string} [file] Explicit config path (wins over every other mode).
+ * @property {boolean} [global] Force the user-global config.
+ */
+
 // Decide which file to patch. Never writes; the installer writes after
 // resolving. Explicit --file wins, then forced global, then: an existing
 // project config in cwd, else an existing global config, else the global
 // location (created on demand).
+/**
+ * @param {InstallOptions} [options]
+ */
 export function resolveTarget({ cwd = process.cwd(), file, global = false } = {}) {
   if (file) return { path: resolve(cwd, file), scope: 'explicit' };
   if (global) {
@@ -91,7 +95,9 @@ export function patchText(
   { pluginSpec = PLUGIN_SPEC, serverName = SERVER_NAME, serverConfig = SERVER_CONFIG } = {},
 ) {
   const errors = [];
-  const root = parseTree(text, errors);
+  // JSONC by contract: comments are allowed by default, trailing commas must
+  // be opted into — both are common in real opencode.json(c) files.
+  const root = parseTree(text, errors, { allowTrailingComma: true });
   if (!root || errors.length) {
     throw new InstallError(`invalid JSONC: ${errors[0]?.error ?? 'could not parse'}`);
   }
@@ -101,8 +107,17 @@ export function patchText(
 
   const eol = detectEol(text);
   const formattingOptions = { insertSpaces: true, tabSize: 2, eol };
+  /** @type {{ mcp: string, plugin: string, warnings: string[] }} */
   const report = { mcp: 'unchanged', plugin: 'unchanged', warnings: [] };
-  let edits = [];
+
+  // Apply each edit batch against the CURRENT text, never the original:
+  // two insertions at the same location (e.g. missing mcp + missing plugins,
+  // both inserted before the closing brace) overlap when computed against one
+  // shared base text and make jsonc-parser throw "Overlapping edit".
+  let current = text;
+  const apply = (edits) => {
+    if (edits.length) current = applyEdits(current, edits);
+  };
 
   // ---- MCP server entry ----
   const mcpNode = findNodeAtLocation(root, ['mcp']);
@@ -115,24 +130,18 @@ export function patchText(
       if (deepEqual(existing, serverConfig)) {
         report.mcp = 'unchanged';
       } else {
-        edits = edits.concat(
-          modify(text, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }),
-        );
+        apply(modify(current, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }));
         report.mcp = 'updated';
       }
     } else {
-      report.warnings.push(
-        `mcp.servers.${serverName} exists but is not an object; left untouched`,
-      );
+      report.warnings.push(`mcp.servers.${serverName} exists but is not an object; left untouched`);
     }
   } else if (mcpNode && mcpNode.type !== 'object') {
     report.warnings.push('existing "mcp" key is not an object; left untouched');
   } else if (serversNode && serversNode.type !== 'object') {
     report.warnings.push('existing "mcp.servers" is not an object; left untouched');
   } else {
-    edits = edits.concat(
-      modify(text, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }),
-    );
+    apply(modify(current, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }));
     report.mcp = 'added';
   }
 
@@ -150,12 +159,11 @@ export function patchText(
         (entry) => /^file:/.test(entry) && entry.toLowerCase().includes('regent'),
       );
       const hasNpmPin =
-        entries.some((entry) => entry.startsWith('regent-code@') && !/^regent-code@git/.test(entry)) ||
-        entries.includes('regent-code');
+        entries.some(
+          (entry) => entry.startsWith('regent-code@') && !/^regent-code@git/.test(entry),
+        ) || entries.includes('regent-code');
 
-      const next = entries
-        .filter((entry) => !gitEntries.includes(entry))
-        .concat(nonString);
+      const next = entries.filter((entry) => !gitEntries.includes(entry)).concat(nonString);
       let reportPlugin;
       if (hasNpmPin && gitEntries.length === 0) {
         reportPlugin = 'unchanged';
@@ -164,31 +172,32 @@ export function patchText(
       }
       if (!hasNpmPin) next.push(pluginSpec);
       if (filePin) {
-        report.warnings.push(
-          'regent plugin pinned via file:// (dev loop); entry left untouched',
-        );
+        report.warnings.push('regent plugin pinned via file:// (dev loop); entry left untouched');
       }
       if (!deepEqual(next, existing)) {
-        edits = edits.concat(modify(text, ['plugins'], next, { formattingOptions }));
+        apply(modify(current, ['plugins'], next, { formattingOptions }));
         report.plugin = reportPlugin;
       }
     }
   } else {
-    edits = edits.concat(modify(text, ['plugins'], [pluginSpec], { formattingOptions }));
+    apply(modify(current, ['plugins'], [pluginSpec], { formattingOptions }));
     report.plugin = 'added';
   }
 
-  return { text: applyEdits(text, edits), report };
+  return { text: current, report };
 }
 
 // Full install against the filesystem: resolves the target config, patches it
 // (creating the file with only the regent entries when none exists), and
 // returns the report plus target info.
+/**
+ * @param {InstallOptions} [options]
+ */
 export function install(options = {}) {
   const target = resolveTarget(options);
   const existingText = existsSync(target.path) ? readFileSync(target.path, 'utf8') : null;
   const base = existingText ?? `{\n}\n`;
-  const { text, report } = patchText(base, options);
+  const { text, report } = patchText(base);
 
   if (text !== existingText) {
     mkdirSync(dirname(target.path), { recursive: true });
@@ -201,4 +210,4 @@ export function install(options = {}) {
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regent-code",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "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": "^0.0.0-beta-18414",
+    "@opencode-ai/plugin": "^0.0.0-beta-18414",
     "jsonc-parser": "3.3.1"
   },
   "repository": {
@@ -30,7 +30,7 @@
     "format": "prettier --write .opencode/plugins/ skills/ mcp/ --no-error-on-unmatched-pattern",
     "format:check": "prettier --check .opencode/plugins/ skills/ mcp/ --no-error-on-unmatched-pattern",
     "typecheck": "tsc --noEmit",
-    "test": "node --test .opencode/tests/regent.test.js .opencode/tests/regent.live-test.js .opencode/tests/regent.v2.test.js .opencode/tests/regent.hybrid.v2.6.1.test.js .opencode/tests/regent.runtime.v2.6.1.test.js mcp/tests/mcp.test.js",
+    "test": "node --test .opencode/tests/regent.test.js .opencode/tests/regent.live-test.js .opencode/tests/regent.v2.test.js .opencode/tests/regent.hybrid.v2.6.1.test.js .opencode/tests/regent.runtime.v2.6.1.test.js mcp/tests/mcp.test.js mcp/tests/install.test.js",
     "verify": "npm run format:check && npm run lint && npm run typecheck && npm test"
   },
   "devDependencies": {