@yeaft/webchat-agent 1.0.206 → 1.0.207

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.206"}
+{"version":"1.0.207"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.206",
+  "version": "1.0.207",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/cli.js

@@ -24,6 +24,9 @@
  */
 
 import { createInterface } from 'readline';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { join } from 'path';
 import { loadConfig } from './config.js';
 import { DebugTrace } from './debug-trace.js';
@@ -33,10 +36,13 @@ import { buildSystemPrompt } from './prompts.js';
 import { searchMessages } from './conversation/search.js';
 import { ConversationStore } from './conversation/persist.js';
 import { snapshotSessions } from './sessions/session-crud.js';
+import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
+import { validateSessionId } from './sessions/ids.js';
+import { createJsonlWriter, JsonlInput, runStreamTurn } from './stdio-protocol.js';
 
 // ─── Argument parsing ──────────────────────────────────────────
 
-function parseArgs(argv) {
+export function parseArgs(argv) {
   const args = {
     debug: false,
     interactive: false,
@@ -51,6 +57,12 @@ function parseArgs(argv) {
     compactOrphans: false,
     compactOrphansDry: false,
     deleteSession: null,
+    sessionId: null,
+    workDir: null,
+    modelEffort: null,
+    inputFormat: 'text',
+    outputFormat: 'text',
+    print: false,
     prompt: null,
   };
 
@@ -75,6 +87,28 @@ function parseArgs(argv) {
       case '--model':
         args.model = rest[++i] || null;
         break;
+      case '--effort':
+      case '--model-effort':
+        args.modelEffort = rest[++i] || null;
+        break;
+      case '--session-id':
+      case '--resume':
+        args.sessionId = rest[++i] || null;
+        break;
+      case '--cwd':
+      case '--work-dir':
+        args.workDir = rest[++i] || null;
+        break;
+      case '--input-format':
+        args.inputFormat = rest[++i] || 'text';
+        break;
+      case '--output-format':
+        args.outputFormat = rest[++i] || 'text';
+        break;
+      case '-p':
+      case '--print':
+        args.print = true;
+        break;
       case '--language':
         args.language = rest[++i] || null;
         break;
@@ -693,6 +727,107 @@ async function runREPL(config, args) {
   });
 }
 
+// ─── Structured stdio handler ──────────────────────────────────
+
+async function runStreamJson(config, args) {
+  const sessionId = args.sessionId || `session_cli_${randomUUID()}`;
+  const validation = validateSessionId(sessionId);
+  if (!validation.ok) {
+    throw new Error(`Invalid --session-id (${validation.reason})`);
+  }
+  const workDir = resolve(args.workDir || process.cwd());
+  const persisted = args.sessionId ? loadSessionConfig(config.dir, sessionId) : {};
+  const effectiveConfig = resolveSessionConfig(config, persisted);
+  if (args.model) {
+    effectiveConfig.model = args.model;
+    effectiveConfig.primaryModel = args.model;
+  }
+  if (args.modelEffort) effectiveConfig.modelEffort = args.modelEffort;
+
+  const write = createJsonlWriter(process.stdout);
+  const input = args.inputFormat === 'stream-json' ? new JsonlInput(process.stdin) : null;
+  const originalConsole = { log: console.log, info: console.info, debug: console.debug };
+  const writeDiagnostic = (...values) => console.error(...values);
+  console.log = writeDiagnostic;
+  console.info = writeDiagnostic;
+  console.debug = writeDiagnostic;
+
+  const loaded = await loadSession({
+    dir: config.dir,
+    workDir,
+    model: effectiveConfig.model,
+    language: args.language || effectiveConfig.language,
+    debug: args.debug || effectiveConfig.debug,
+    skipMCP: args.skipMCP,
+    skipSkills: args.skipSkills,
+    configOverrides: {
+      ...effectiveConfig,
+      ...(effectiveConfig.modelEffort ? { modelEffort: effectiveConfig.modelEffort } : {}),
+    },
+  });
+  const { engine, conversationStore, skillManager, toolRegistry } = loaded;
+  const todoState = { value: [] };
+
+  write({
+    type: 'system',
+    subtype: 'init',
+    session_id: sessionId,
+    model: loaded.config.model,
+    model_effort: loaded.config.modelEffort || null,
+    cwd: workDir,
+    tools: toolRegistry.names,
+    skills: skillManager.list(),
+    input_format: args.inputFormat,
+    output_format: 'stream-json',
+  });
+
+  const runPrompt = async (prompt) => {
+    const priorMessages = conversationStore.loadRecentBySession(sessionId, 20).map(message => ({
+      role: message.role,
+      content: message.content,
+      ...(message.toolCallId && { toolCallId: message.toolCallId }),
+      ...(message.toolCalls && { toolCalls: message.toolCalls }),
+    }));
+    return runStreamTurn({
+      engine,
+      prompt,
+      messages: priorMessages,
+      sessionId,
+      workDir,
+      model: loaded.config.model,
+      modelEffort: loaded.config.modelEffort || null,
+      input,
+      write,
+      getCurrentTodos: () => todoState.value.slice(),
+      setCurrentTodos: todos => { todoState.value = Array.isArray(todos) ? todos.slice() : []; },
+    });
+  };
+
+  let lastResult = null;
+  try {
+    if (args.prompt) {
+      lastResult = await runPrompt(args.prompt);
+    } else if (input) {
+      for (;;) {
+        const item = await input.nextPrompt();
+        if (!item) break;
+        lastResult = await runPrompt(item.prompt);
+      }
+    } else {
+      let prompt = '';
+      for await (const chunk of process.stdin) prompt += chunk;
+      if (prompt.trim()) lastResult = await runPrompt(prompt.trim());
+    }
+  } finally {
+    input?.close();
+    await loaded.shutdown();
+    console.log = originalConsole.log;
+    console.info = originalConsole.info;
+    console.debug = originalConsole.debug;
+  }
+  if (lastResult?.is_error) process.exitCode = 1;
+}
+
 // ─── One-shot handler ──────────────────────────────────────────
 
 async function runOnce(config, args) {
@@ -819,6 +954,20 @@ async function main() {
     return;
   }
 
+  if (args.outputFormat === 'stream-json') {
+    if (args.inputFormat !== 'text' && args.inputFormat !== 'stream-json') {
+      throw new Error('--input-format must be text or stream-json');
+    }
+    if (!args.prompt && args.inputFormat !== 'stream-json' && process.stdin.isTTY) {
+      throw new Error('stream-json output requires a prompt, piped stdin, or --input-format stream-json');
+    }
+    await runStreamJson(config, args);
+    return;
+  }
+  if (args.inputFormat === 'stream-json') {
+    throw new Error('--input-format stream-json requires --output-format stream-json');
+  }
+
   // Handle prompt (from args or stdin)
   if (args.prompt) {
     await runOnce(config, args);
@@ -856,15 +1005,24 @@ async function main() {
   console.log('  -d, --debug           Enable debug tracing');
   console.log('  -i, --interactive     Start REPL');
   console.log('  -v, --verbose         Verbose output');
-  console.log('  --model <name>        Override model');
-  console.log('  --language <code>     Language: en, zh (default: en)');
+  console.log('  -p, --print           Run a non-interactive query');
+  console.log('  --session-id <id>     Persist and resume a Yeaft Session');
+  console.log('  --cwd <dir>           Set the working directory');
+  console.log('  --model <name>         Override model');
+  console.log('  --effort <level>       Override model effort');
+  console.log('  --input-format <fmt>   text or stream-json');
+  console.log('  --output-format <fmt>  text or stream-json');
+  console.log('  --language <code>      Language: en, zh (default: en)');
   console.log('  --trace <cmd>         Query debug trace');
   console.log('  --dry-run             Show prompt without calling LLM');
   console.log('  --skip-mcp            Skip MCP server connections');
   console.log('  --skip-skills         Skip skill loading');
 }
 
-main().catch(err => {
-  console.error(err);
-  process.exit(1);
-});
+const isDirectRun = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isDirectRun) {
+  main().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/yeaft/engine.js

@@ -1086,12 +1086,12 @@ export class Engine {
    * @param {string} [args.explicitSkillName] — leading /skill:<name> command, if present
    * @returns {string}
    */
-  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, workCenterInstructions, projectDoc, taskCtx, activeTasks, explicitSkillName } = {}) {
-    // Get relevant skill content if SkillManager is wired. A leading
-    // /skill:<name> is explicit, not relevance matching: load that skill by
-    // name or inject a visible prompt warning when the command is unknown.
-    let skillContent = '';
-    if (this.#skillManager) {
+  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, workCenterInstructions, projectDoc, taskCtx, activeTasks, explicitSkillName, resolvedSkillContent = null } = {}) {
+    // Skill selection is normally resolved once by #runQuery so the prompt and
+    // emitted protocol events describe the exact same skills. Keep the local
+    // fallback for internal callers that do not need selection events.
+    let skillContent = typeof resolvedSkillContent === 'string' ? resolvedSkillContent : '';
+    if (resolvedSkillContent === null && this.#skillManager) {
       if (explicitSkillName) {
         skillContent = this.#skillManager.getPromptContent(explicitSkillName)
           || `## Skill command error\n\nRequested skill "${explicitSkillName}" was not found. Continue without that skill and tell the user it is unavailable.`;
@@ -2004,6 +2004,32 @@ export class Engine {
     const activeTasks = this.#taskManager
       ? this.#taskManager.renderActiveTasksForPrompt(runtimeSessionId)
       : '';
+    let resolvedSkillContent = '';
+    let resolvedSkills = [];
+    let skillResolutionError = null;
+    if (this.#skillManager) {
+      if (explicitSkillName) {
+        resolvedSkillContent = this.#skillManager.getPromptContent(explicitSkillName);
+        const skill = this.#skillManager.list?.().find(item => item.name === explicitSkillName)
+          || (resolvedSkillContent ? { name: explicitSkillName } : null);
+        if (resolvedSkillContent && skill) {
+          resolvedSkills = [{ ...skill, explicit: true }];
+        } else {
+          skillResolutionError = `Requested skill "${explicitSkillName}" was not found.`;
+          resolvedSkillContent = `## Skill command error\n\n${skillResolutionError} Continue without that skill and tell the user it is unavailable.`;
+        }
+      } else if (prompt && typeof this.#skillManager.findRelevant === 'function') {
+        resolvedSkills = this.#skillManager.findRelevant(prompt).map(skill => ({
+          name: skill.name,
+          description: skill.description || '',
+          trigger: skill.trigger || '',
+          category: skill.category,
+          tier: skill._tier,
+          explicit: false,
+        }));
+        resolvedSkillContent = resolvedSkills.map(skill => this.#skillManager.getPromptContent(skill.name)).join('\n\n');
+      }
+    }
 
     const systemPrompt = this.#buildSystemPrompt({
       prompt,
@@ -2015,6 +2041,7 @@ export class Engine {
       projectDoc,
       activeTasks,
       explicitSkillName,
+      resolvedSkillContent,
     });
 
     // ─── HARD INVARIANT: Compact ≠ Dream (read DESIGN-COMPACT-VS-DREAM.md) ─
@@ -2184,6 +2211,12 @@ export class Engine {
       sessionId: sessionId || null,
       at: queryStartedAt,
     };
+    for (const skill of resolvedSkills) {
+      yield { type: 'skill_loaded', turnId: queryTurnId, skill };
+    }
+    if (skillResolutionError) {
+      yield { type: 'skill_error', turnId: queryTurnId, skillName: explicitSkillName, message: skillResolutionError };
+    }
 
     // Surface memory recall to the debug panel right after turn_open.
     // recallResult was loaded above; emit a structured `memory_used`

package/yeaft/sessions/ids.js

@@ -49,6 +49,17 @@ export function nextSessionId(slug = 'default') {
   return `session_${safe}_${randEncoded(8)}`;
 }
 
+const SESSION_ID_RE = /^session_[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SESSION_ID_MAX_LEN = 128;
+
+/** Validate an external Session ID before it reaches any filesystem-backed subsystem. */
+export function validateSessionId(id) {
+  if (!id || typeof id !== 'string') return { ok: false, reason: 'empty_or_non_string' };
+  if (id.length > SESSION_ID_MAX_LEN) return { ok: false, reason: 'too_long' };
+  if (!SESSION_ID_RE.test(id)) return { ok: false, reason: 'invalid_shape' };
+  return { ok: true };
+}
+
 /**
  * Reserved vpIds that must never be used as actual VP identifiers — they
  * collide with coordinator-level sentinels (`@all` broadcast, `user`/`system`

package/yeaft/stdio-protocol.js

@@ -0,0 +1,299 @@
+import { createInterface } from 'node:readline';
+import { randomUUID } from 'node:crypto';
+
+const TERMINAL_STOP_REASONS = new Set(['end_turn', 'max_tokens', 'stop_sequence', 'aborted', 'error']);
+
+function snakeUsage(usage) {
+  const inputTokens = usage.inputTokens || 0;
+  const outputTokens = usage.outputTokens || 0;
+  const cacheReadTokens = usage.cacheReadTokens || 0;
+  const cacheWriteTokens = usage.cacheWriteTokens || 0;
+  const cacheDelta = usage.cacheTokensAreIncludedInInput ? 0 : cacheReadTokens + cacheWriteTokens;
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    cache_read_input_tokens: cacheReadTokens,
+    cache_creation_input_tokens: cacheWriteTokens,
+    total_input_tokens: inputTokens + cacheDelta,
+    total_tokens: inputTokens + cacheDelta + outputTokens,
+  };
+}
+
+export function extractPrompt(message) {
+  if (!message || typeof message !== 'object') return '';
+  if (typeof message.prompt === 'string') return message.prompt;
+  if (typeof message.text === 'string') return message.text;
+  const content = message.message?.content ?? message.content;
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(block => block?.type === 'text' && typeof block.text === 'string')
+    .map(block => block.text)
+    .join('');
+}
+
+export function createJsonlWriter(output = process.stdout) {
+  return (event) => {
+    output.write(`${JSON.stringify(event)}\n`);
+  };
+}
+
+export class JsonlInput {
+  #rl;
+  #prompts = [];
+  #promptWaiters = [];
+  #answers = new Map();
+  #answerWaiters = new Map();
+  #answerRequestIds = new Set();
+  #closed = false;
+  #error = null;
+
+  constructor(input = process.stdin) {
+    this.#rl = createInterface({ input, crlfDelay: Infinity, terminal: false });
+    this.#rl.on('line', line => this.#acceptLine(line));
+    this.#rl.on('close', () => this.#close());
+  }
+
+  #acceptLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch (err) {
+      this.#error = new Error(`Invalid stream-json input: ${err.message}`);
+      this.#close();
+      return;
+    }
+    const type = message.type || '';
+    if (type === 'ask_user_response' || type === 'user_response') {
+      const requestId = message.request_id || message.requestId;
+      if (!requestId) return;
+      const value = message.answers ?? message.answer ?? message.response ?? {};
+      const waiter = this.#answerWaiters.get(requestId);
+      if (waiter) {
+        this.#answerWaiters.delete(requestId);
+        waiter.resolve(value);
+      } else if (this.#answerRequestIds.has(requestId)) {
+        this.#error = new Error(`Duplicate AskUser response request_id: ${requestId}`);
+        this.#close();
+      } else {
+        this.#answerRequestIds.add(requestId);
+        this.#answers.set(requestId, value);
+      }
+      return;
+    }
+    if (type === 'user' || type === 'prompt' || message.prompt !== undefined) {
+      const prompt = extractPrompt(message);
+      if (!prompt) return;
+      const item = { prompt, message };
+      const waiter = this.#promptWaiters.shift();
+      if (waiter) waiter.resolve(item);
+      else this.#prompts.push(item);
+    }
+  }
+
+  #close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    for (const waiter of this.#promptWaiters.splice(0)) {
+      if (this.#error) waiter.reject(this.#error);
+      else waiter.resolve(null);
+    }
+    for (const waiter of this.#answerWaiters.values()) {
+      waiter.reject(this.#error || new Error('stdin closed before AskUser response'));
+    }
+    this.#answerWaiters.clear();
+  }
+
+  async nextPrompt() {
+    if (this.#prompts.length) return this.#prompts.shift();
+    if (this.#error) throw this.#error;
+    if (this.#closed) return null;
+    return new Promise((resolve, reject) => this.#promptWaiters.push({ resolve, reject }));
+  }
+
+  async waitForAnswer(requestId) {
+    if (!requestId || typeof requestId !== 'string') {
+      throw new Error('AskUser request_id must be a non-empty string');
+    }
+    if (this.#error) throw this.#error;
+    if (this.#answers.has(requestId)) {
+      const value = this.#answers.get(requestId);
+      this.#answers.delete(requestId);
+      return value;
+    }
+    if (this.#answerRequestIds.has(requestId)) {
+      throw new Error(`Duplicate AskUser request_id: ${requestId}`);
+    }
+    if (this.#error) throw this.#error;
+    if (this.#closed) throw new Error('stdin closed before AskUser response');
+    this.#answerRequestIds.add(requestId);
+    return new Promise((resolve, reject) => this.#answerWaiters.set(requestId, { resolve, reject }));
+  }
+
+  close() {
+    this.#rl.close();
+  }
+}
+
+export async function runStreamTurn({
+  engine,
+  prompt,
+  messages = [],
+  sessionId = null,
+  workDir = process.cwd(),
+  model = null,
+  modelEffort = null,
+  input = null,
+  write,
+  getCurrentTodos = null,
+  setCurrentTodos = null,
+}) {
+  const clientTurnId = randomUUID();
+  let engineTurnId = null;
+  let resultText = '';
+  let stopReason = 'end_turn';
+  let failed = null;
+  const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheInputDeltaTokens: 0 };
+
+  const askUser = async ({ question, options }) => {
+    const requestId = randomUUID();
+    write({
+      type: 'ask_user',
+      subtype: 'request',
+      request_id: requestId,
+      session_id: sessionId,
+      turn_id: engineTurnId || clientTurnId,
+      question,
+      options: Array.isArray(options) ? options : [],
+    });
+    if (!input) throw new Error('AskUser requires --input-format stream-json');
+    const answers = await input.waitForAnswer(requestId);
+    write({
+      type: 'ask_user',
+      subtype: 'response',
+      request_id: requestId,
+      session_id: sessionId,
+      turn_id: engineTurnId || clientTurnId,
+      answers,
+    });
+    return answers;
+  };
+
+  try {
+    for await (const event of engine.query({
+      prompt,
+      messages,
+      sessionId,
+      workDir,
+      userEffort: modelEffort,
+      askUser,
+      getCurrentTodos,
+      setCurrentTodos,
+    })) {
+      if (event.type === 'turn_open') engineTurnId = event.turnId;
+      const turnId = engineTurnId || clientTurnId;
+      switch (event.type) {
+        case 'turn_open':
+          write({ ...event, type: 'turn', subtype: 'start', session_id: sessionId, turn_id: event.turnId, model, model_effort: modelEffort, cwd: workDir });
+          break;
+        case 'text_delta':
+          resultText += event.text || '';
+          write({ type: 'assistant', subtype: 'text_delta', session_id: sessionId, turn_id: turnId, delta: { type: 'text_delta', text: event.text || '' } });
+          break;
+        case 'thinking_delta':
+          write({ type: 'assistant', subtype: 'thinking_delta', session_id: sessionId, turn_id: turnId, delta: { type: 'thinking_delta', thinking: event.text || '' } });
+          break;
+        case 'skill_loaded':
+          write({ type: 'skill', subtype: 'loaded', session_id: sessionId, turn_id: turnId, skill: event.skill });
+          break;
+        case 'skill_error':
+          write({ type: 'skill', subtype: 'error', session_id: sessionId, turn_id: turnId, skill_name: event.skillName, error: event.message });
+          break;
+        case 'tool_call':
+          write({ type: 'assistant', subtype: 'tool_use', session_id: sessionId, turn_id: turnId, content: [{ type: 'tool_use', id: event.id, name: event.name, input: event.input }] });
+          if (event.name === 'TodoWrite') {
+            write({ type: 'todo', subtype: 'update', session_id: sessionId, turn_id: turnId, tool_use_id: event.id, todos: event.input?.todos || [] });
+          }
+          break;
+        case 'tool_start':
+          write({ type: 'tool', subtype: 'start', session_id: sessionId, turn_id: turnId, tool_use_id: event.id, name: event.name, input: event.input });
+          break;
+        case 'tool_end':
+          write({
+            type: 'tool',
+            subtype: 'result',
+            session_id: sessionId,
+            turn_id: turnId,
+            tool_use_id: event.id,
+            name: event.name,
+            content: event.output,
+            is_error: !!event.isError,
+            ...(Array.isArray(event.displayImages) && event.displayImages.length > 0
+              ? { display_images: event.displayImages }
+              : {}),
+          });
+          break;
+        case 'usage': {
+          const cacheDelta = event.cacheTokensAreIncludedInInput ? 0 : (event.cacheReadTokens || 0) + (event.cacheWriteTokens || 0);
+          usage.inputTokens += event.inputTokens || 0;
+          usage.outputTokens += event.outputTokens || 0;
+          usage.cacheReadTokens += event.cacheReadTokens || 0;
+          usage.cacheWriteTokens += event.cacheWriteTokens || 0;
+          usage.cacheInputDeltaTokens += cacheDelta;
+          write({ type: 'usage', session_id: sessionId, turn_id: turnId, usage: snakeUsage(event) });
+          break;
+        }
+        case 'stop':
+          if (event.stopReason) stopReason = event.stopReason;
+          break;
+        case 'turn_end':
+          if (event.stopReason && TERMINAL_STOP_REASONS.has(event.stopReason)) stopReason = event.stopReason;
+          break;
+        case 'turn_close':
+          write({ type: 'turn', subtype: 'stop', session_id: sessionId, turn_id: turnId, duration_ms: event.totalMs, loop_count: event.loopCount, total_tokens: event.totalTokens });
+          break;
+        case 'error':
+          failed = event.error instanceof Error ? event.error : new Error(event.error?.message || String(event.error || 'Unknown error'));
+          write({ type: 'error', session_id: sessionId, turn_id: turnId, error: { name: failed.name, message: failed.message }, retryable: !!event.retryable });
+          break;
+        case 'fallback':
+        case 'llm_retry':
+        case 'memory_used':
+        case 'recall':
+        case 'consolidate':
+        case 'reflection':
+          write({ ...event, session_id: sessionId, turn_id: turnId });
+          break;
+      }
+    }
+  } catch (err) {
+    failed = err;
+    write({ type: 'error', session_id: sessionId, turn_id: engineTurnId || clientTurnId, error: { name: err.name || 'Error', message: err.message || String(err) } });
+  }
+
+  const finalUsage = {
+    input_tokens: usage.inputTokens,
+    output_tokens: usage.outputTokens,
+    cache_read_input_tokens: usage.cacheReadTokens,
+    cache_creation_input_tokens: usage.cacheWriteTokens,
+    total_input_tokens: usage.inputTokens + usage.cacheInputDeltaTokens,
+    total_tokens: usage.inputTokens + usage.cacheInputDeltaTokens + usage.outputTokens,
+  };
+  const result = {
+    type: 'result',
+    subtype: failed ? 'error' : 'success',
+    session_id: sessionId,
+    turn_id: engineTurnId || clientTurnId,
+    model,
+    model_effort: modelEffort,
+    stop_reason: failed ? 'error' : stopReason,
+    is_error: !!failed,
+    result: resultText,
+    usage: finalUsage,
+    ...(failed ? { error: failed.message || String(failed) } : {}),
+  };
+  write(result);
+  return result;
+}