@link-assistant/agent 0.8.7 → 0.8.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.8.7",
+  "version": "0.8.10",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/cli/cmd/export.ts

@@ -18,7 +18,7 @@ export const ExportCommand = cmd({
   handler: async (args) => {
     await bootstrap(process.cwd(), async () => {
       let sessionID = args.sessionID;
-      process.stderr.write(`Exporting session: ${sessionID ?? 'latest'}`);
+      process.stdout.write(`Exporting session: ${sessionID ?? 'latest'}`);
 
       if (!sessionID) {
         UI.empty();

package/src/cli/continuous-mode.js

@@ -11,6 +11,8 @@ import { SessionPrompt } from '../session/prompt.ts';
 import { createEventHandler } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
 import { Log } from '../util/log.ts';
+import { Flag } from '../flag/flag.ts';
+import { outputStatus, outputError, outputInput } from './output.ts';
 
 // Shared error tracking
 let hasError = false;
@@ -31,17 +33,8 @@ export function getHasError() {
   return hasError;
 }
 
-/**
- * Output JSON status message to stderr
- * @param {object} status - Status object to output
- * @param {boolean} compact - If true, output compact JSON (single line)
- */
-function outputStatus(status, compact = false) {
-  const json = compact
-    ? JSON.stringify(status)
-    : JSON.stringify(status, null, 2);
-  console.error(json);
-}
+// outputStatus is now imported from './output.ts'
+// It outputs to stdout for non-error messages, stderr for errors
 
 // Logger for resume operations
 const log = Log.create({ service: 'resume' });
@@ -84,9 +77,8 @@ export async function resolveResumeSession(argv, compactJson) {
     }
 
     if (!mostRecentSession) {
-      outputStatus(
+      outputError(
         {
-          type: 'error',
           errorType: 'SessionNotFound',
           message:
             'No existing sessions found to continue. Start a new session first.',
@@ -110,9 +102,8 @@ export async function resolveResumeSession(argv, compactJson) {
     existingSession = await Session.get(targetSessionID);
   } catch (_error) {
     // Session.get throws an error when the session doesn't exist
-    outputStatus(
+    outputError(
       {
-        type: 'error',
         errorType: 'SessionNotFound',
         message: `Session not found: ${targetSessionID}`,
       },
@@ -122,9 +113,8 @@ export async function resolveResumeSession(argv, compactJson) {
   }
 
   if (!existingSession) {
-    outputStatus(
+    outputError(
       {
-        type: 'error',
         errorType: 'SessionNotFound',
         message: `Session not found: ${targetSessionID}`,
       },
@@ -204,7 +194,8 @@ export async function runContinuousServerMode(
   appendSystemMessage,
   jsonStandard
 ) {
-  const compactJson = argv['compact-json'] === true;
+  // Check both CLI flag and environment variable for compact JSON mode
+  const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
   const isInteractive = argv.interactive !== false;
   const autoMerge = argv['auto-merge-queued-messages'] !== false;
 
@@ -255,6 +246,17 @@ export async function runContinuousServerMode(
       }
 
       isProcessing = true;
+
+      // Output input confirmation in JSON format
+      outputInput(
+        {
+          raw: message.raw || message.message,
+          parsed: message,
+          format: message.format || 'text',
+        },
+        compactJson
+      );
+
       const messageText = message.message || 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
@@ -339,7 +341,7 @@ export async function runContinuousServerMode(
           });
         }
 
-        if (part.type === 'tool' && part.state.status === 'completed') {
+        if (part.type === 'tool') {
           eventHandler.output({
             type: 'tool_use',
             timestamp: Date.now(),
@@ -427,7 +429,8 @@ export async function runContinuousDirectMode(
   appendSystemMessage,
   jsonStandard
 ) {
-  const compactJson = argv['compact-json'] === true;
+  // Check both CLI flag and environment variable for compact JSON mode
+  const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
   const isInteractive = argv.interactive !== false;
   const autoMerge = argv['auto-merge-queued-messages'] !== false;
 
@@ -466,6 +469,17 @@ export async function runContinuousDirectMode(
       }
 
       isProcessing = true;
+
+      // Output input confirmation in JSON format
+      outputInput(
+        {
+          raw: message.raw || message.message,
+          parsed: message,
+          format: message.format || 'text',
+        },
+        compactJson
+      );
+
       const messageText = message.message || 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
@@ -544,7 +558,7 @@ export async function runContinuousDirectMode(
           });
         }
 
-        if (part.type === 'tool' && part.state.status === 'completed') {
+        if (part.type === 'tool') {
           eventHandler.output({
             type: 'tool_use',
             timestamp: Date.now(),

package/src/cli/event-handler.js

@@ -61,13 +61,23 @@ export function createBusEventSubscription({
         });
       }
 
-      if (part.type === 'tool' && part.state.status === 'completed') {
+      if (part.type === 'tool') {
         eventHandler.output({
           type: 'tool_use',
           timestamp: Date.now(),
           sessionID,
           part,
         });
+
+        // If tool failed, also output an error event
+        if (part.state?.status === 'failed') {
+          eventHandler.output({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: part.state.error || 'Tool execution failed',
+          });
+        }
       }
     }
 

package/src/cli/output.ts

@@ -0,0 +1,203 @@
+/**
+ * CLI Output Module
+ *
+ * Centralized output handling for the Agent CLI.
+ * Ensures consistent JSON formatting and proper stream routing:
+ * - stdout: Normal output (status, events, data, logs, warnings)
+ * - stderr: Errors only
+ *
+ * All output includes a `type` field for easy parsing.
+ */
+
+import { EOL } from 'os';
+import { Flag } from '../flag/flag';
+
+/**
+ * Output types for JSON messages
+ */
+export type OutputType =
+  | 'status'
+  | 'error'
+  | 'warning'
+  | 'log'
+  | 'step_start'
+  | 'step_finish'
+  | 'text'
+  | 'tool_use'
+  | 'result'
+  | 'init'
+  | 'message'
+  | 'tool_result'
+  | 'input';
+
+/**
+ * Base interface for all output messages
+ */
+export interface OutputMessage {
+  type: OutputType;
+  [key: string]: unknown;
+}
+
+/**
+ * Global compact JSON setting (can be set once at startup)
+ * Initialized lazily from Flag.COMPACT_JSON() which checks AGENT_CLI_COMPACT env var
+ */
+let globalCompactJson: boolean | null = null;
+
+/**
+ * Set the global compact JSON setting
+ */
+export function setCompactJson(compact: boolean): void {
+  globalCompactJson = compact;
+  // Also update the Flag so other modules stay in sync
+  Flag.setCompactJson(compact);
+}
+
+/**
+ * Get the current compact JSON setting
+ */
+export function isCompactJson(): boolean {
+  if (globalCompactJson !== null) return globalCompactJson;
+  return Flag.COMPACT_JSON();
+}
+
+/**
+ * Format a message as JSON string
+ * @param message - The message object to format
+ * @param compact - Override the global compact setting
+ */
+export function formatJson(message: OutputMessage, compact?: boolean): string {
+  // Check local, global, and Flag settings for compact mode
+  const useCompact = compact ?? isCompactJson();
+  return useCompact
+    ? JSON.stringify(message)
+    : JSON.stringify(message, null, 2);
+}
+
+/**
+ * Write a message to stdout (for normal output)
+ * @param message - The message object to output
+ * @param compact - Override the global compact setting
+ */
+export function writeStdout(message: OutputMessage, compact?: boolean): void {
+  const json = formatJson(message, compact);
+  process.stdout.write(json + EOL);
+}
+
+/**
+ * Write a message to stderr (for errors only)
+ * @param message - The message object to output
+ * @param compact - Override the global compact setting
+ */
+export function writeStderr(message: OutputMessage, compact?: boolean): void {
+  const json = formatJson(message, compact);
+  process.stderr.write(json + EOL);
+}
+
+/**
+ * Output a message to stdout (for normal output)
+ * - stdout: All output except errors (status, events, data, logs, warnings)
+ *
+ * @param message - The message object to output
+ * @param compact - Override the global compact setting
+ */
+export function output(message: OutputMessage, compact?: boolean): void {
+  writeStdout(message, compact);
+}
+
+/**
+ * Output a status message to stdout
+ */
+export function outputStatus(
+  status: Omit<OutputMessage, 'type'> & {
+    type?: 'status' | 'error' | 'warning';
+  },
+  compact?: boolean
+): void {
+  const message: OutputMessage = {
+    type: status.type || 'status',
+    ...status,
+  };
+  output(message, compact);
+}
+
+/**
+ * Output an error message to stderr
+ */
+export function outputError(
+  error: {
+    errorType?: string;
+    message: string;
+    hint?: string;
+    stack?: string;
+    [key: string]: unknown;
+  },
+  compact?: boolean
+): void {
+  const message: OutputMessage = {
+    type: 'error',
+    ...error,
+  };
+  writeStderr(message, compact);
+}
+
+/**
+ * Output a warning message to stdout
+ */
+export function outputWarning(
+  warning: {
+    message: string;
+    hint?: string;
+    [key: string]: unknown;
+  },
+  compact?: boolean
+): void {
+  const message: OutputMessage = {
+    type: 'warning',
+    ...warning,
+  };
+  writeStdout(message, compact);
+}
+
+/**
+ * Output a log message to stdout
+ * This uses the flattened format: { "type": "log", "level": "...", ... }
+ */
+export function outputLog(
+  log: {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message?: string;
+    timestamp?: string;
+    [key: string]: unknown;
+  },
+  compact?: boolean
+): void {
+  const message: OutputMessage = {
+    type: 'log',
+    ...log,
+  };
+  writeStdout(message, compact);
+}
+
+/**
+ * Output user input confirmation to stdout
+ */
+export function outputInput(
+  input: {
+    raw: string;
+    parsed?: unknown;
+    format?: 'json' | 'text';
+    [key: string]: unknown;
+  },
+  compact?: boolean
+): void {
+  const message: OutputMessage = {
+    type: 'input',
+    timestamp: new Date().toISOString(),
+    ...input,
+  };
+  writeStdout(message, compact);
+}
+
+// Re-export for backward compatibility
+export { output as write };

package/src/cli/ui.ts

@@ -23,31 +23,31 @@ export namespace UI {
 
   // Print an empty line
   export function empty() {
-    process.stderr.write('\n');
+    process.stdout.write('\n');
   }
 
   // Print a line with optional formatting
   export function println(...args: string[]) {
-    process.stderr.write(args.join('') + Style.TEXT_NORMAL + '\n');
+    process.stdout.write(args.join('') + Style.TEXT_NORMAL + '\n');
   }
 
   // Print an error message
   export function error(message: string) {
-    process.stderr.write(
+    process.stdout.write(
       Style.TEXT_DANGER_BOLD + 'Error: ' + Style.TEXT_NORMAL + message + '\n'
     );
   }
 
   // Print a success message
   export function success(message: string) {
-    process.stderr.write(
+    process.stdout.write(
       Style.TEXT_SUCCESS_BOLD + 'Success: ' + Style.TEXT_NORMAL + message + '\n'
     );
   }
 
   // Print an info message
   export function info(message: string) {
-    process.stderr.write(
+    process.stdout.write(
       Style.TEXT_INFO_BOLD + 'Info: ' + Style.TEXT_NORMAL + message + '\n'
     );
   }

package/src/flag/flag.ts

@@ -63,6 +63,19 @@ export namespace Flag {
     'OPENCODE_DRY_RUN'
   );
 
+  // Compact JSON mode - output JSON on single lines (NDJSON format)
+  // Enabled by AGENT_CLI_COMPACT env var or --compact-json flag
+  // Uses getter to check env var at runtime for tests
+  let _compactJson: boolean | null = null;
+
+  export function COMPACT_JSON(): boolean {
+    if (_compactJson !== null) return _compactJson;
+    return (
+      truthy('AGENT_CLI_COMPACT') ||
+      truthyCompat('LINK_ASSISTANT_AGENT_COMPACT_JSON', 'OPENCODE_COMPACT_JSON')
+    );
+  }
+
   // Allow setting verbose mode programmatically (e.g., from CLI --verbose flag)
   export function setVerbose(value: boolean) {
     OPENCODE_VERBOSE = value;
@@ -73,6 +86,11 @@ export namespace Flag {
     OPENCODE_DRY_RUN = value;
   }
 
+  // Allow setting compact JSON mode programmatically (e.g., from CLI --compact-json flag)
+  export function setCompactJson(value: boolean) {
+    _compactJson = value;
+  }
+
   function truthy(key: string) {
     const value = process.env[key]?.toLowerCase();
     return value === 'true' || value === '1';

package/src/index.js

@@ -24,6 +24,12 @@ import {
   resolveResumeSession,
 } from './cli/continuous-mode.js';
 import { createBusEventSubscription } from './cli/event-handler.js';
+import {
+  outputStatus,
+  outputError,
+  setCompactJson,
+  outputInput,
+} from './cli/output.ts';
 import { createRequire } from 'module';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -47,35 +53,21 @@ let hasError = false;
 // Install global error handlers to ensure non-zero exit codes
 process.on('uncaughtException', (error) => {
   hasError = true;
-  console.error(
-    JSON.stringify(
-      {
-        type: 'error',
-        errorType: error.name || 'UncaughtException',
-        message: error.message,
-        stack: error.stack,
-      },
-      null,
-      2
-    )
-  );
+  outputError({
+    errorType: error.name || 'UncaughtException',
+    message: error.message,
+    stack: error.stack,
+  });
   process.exit(1);
 });
 
 process.on('unhandledRejection', (reason, _promise) => {
   hasError = true;
-  console.error(
-    JSON.stringify(
-      {
-        type: 'error',
-        errorType: 'UnhandledRejection',
-        message: reason?.message || String(reason),
-        stack: reason?.stack,
-      },
-      null,
-      2
-    )
-  );
+  outputError({
+    errorType: 'UnhandledRejection',
+    message: reason?.message || String(reason),
+    stack: reason?.stack,
+  });
   process.exit(1);
 });
 
@@ -134,18 +126,8 @@ function readStdinWithTimeout(timeout = null) {
   });
 }
 
-/**
- * Output JSON status message to stderr
- * This prevents the status message from interfering with JSON output parsing
- * @param {object} status - Status object to output
- * @param {boolean} compact - If true, output compact JSON (single line)
- */
-function outputStatus(status, compact = false) {
-  const json = compact
-    ? JSON.stringify(status)
-    : JSON.stringify(status, null, 2);
-  console.error(json);
-}
+// outputStatus is now imported from './cli/output.ts'
+// It outputs to stdout for non-error messages, stderr for errors
 
 /**
  * Parse model configuration from argv
@@ -168,9 +150,8 @@ async function parseModelConfig(argv) {
 
     if (!creds?.accessToken) {
       const compactJson = argv['compact-json'] === true;
-      outputStatus(
+      outputError(
         {
-          type: 'error',
           errorType: 'AuthenticationError',
           message:
             'No Claude OAuth credentials found in ~/.claude/.credentials.json. Either authenticate with Claude Code CLI first, or use: agent auth login (select Anthropic > Claude Pro/Max)',
@@ -221,9 +202,10 @@ async function readSystemMessages(argv) {
     );
     const file = Bun.file(resolvedPath);
     if (!(await file.exists())) {
-      console.error(
-        `System message file not found: ${argv['system-message-file']}`
-      );
+      outputError({
+        errorType: 'FileNotFound',
+        message: `System message file not found: ${argv['system-message-file']}`,
+      });
       process.exit(1);
     }
     systemMessage = await file.text();
@@ -236,9 +218,10 @@ async function readSystemMessages(argv) {
     );
     const file = Bun.file(resolvedPath);
     if (!(await file.exists())) {
-      console.error(
-        `Append system message file not found: ${argv['append-system-message-file']}`
-      );
+      outputError({
+        errorType: 'FileNotFound',
+        message: `Append system message file not found: ${argv['append-system-message-file']}`,
+      });
       process.exit(1);
     }
     appendSystemMessage = await file.text();
@@ -692,7 +675,9 @@ async function main() {
               default: false,
             }),
         handler: async (argv) => {
-          const compactJson = argv['compact-json'] === true;
+          // Check both CLI flag and environment variable for compact JSON mode
+          const compactJson =
+            argv['compact-json'] === true || Flag.COMPACT_JSON();
 
           // Check if --prompt flag was provided
           if (argv.prompt) {
@@ -705,9 +690,9 @@ async function main() {
           // Check if --disable-stdin was set without --prompt
           if (argv['disable-stdin']) {
             // Output a helpful message suggesting to use --prompt
-            outputStatus(
+            outputError(
               {
-                type: 'error',
+                errorType: 'ValidationError',
                 message:
                   'No prompt provided. Use -p/--prompt to specify a message, or remove --disable-stdin to read from stdin.',
                 hint: 'Example: agent -p "Hello, how are you?"',
@@ -726,9 +711,9 @@ async function main() {
 
             // Exit if --no-always-accept-stdin is set (single message mode not supported in TTY)
             if (!alwaysAcceptStdin) {
-              outputStatus(
+              outputError(
                 {
-                  type: 'error',
+                  errorType: 'ValidationError',
                   message:
                     'Single message mode (--no-always-accept-stdin) is not supported in interactive terminal mode.',
                   hint: 'Use piped input or --prompt for single messages.',
@@ -820,9 +805,9 @@ async function main() {
             // Not JSON
             if (!isInteractive) {
               // In non-interactive mode, only accept JSON
-              outputStatus(
+              outputError(
                 {
-                  type: 'error',
+                  errorType: 'ValidationError',
                   message:
                     'Invalid JSON input. In non-interactive mode (--no-interactive), only JSON input is accepted.',
                   hint: 'Use --interactive to accept plain text, or provide valid JSON: {"message": "your text"}',
@@ -837,6 +822,16 @@ async function main() {
             };
           }
 
+          // Output input confirmation in JSON format
+          outputInput(
+            {
+              raw: trimmedInput,
+              parsed: request,
+              format: isInteractive ? 'text' : 'json',
+            },
+            compactJson
+          );
+
           // Run agent mode
           await runAgentMode(argv, request);
         },
@@ -844,6 +839,12 @@ async function main() {
       // Initialize logging early for all CLI commands
       // This prevents debug output from appearing in CLI unless --verbose is used
       .middleware(async (argv) => {
+        // Set global compact JSON setting (CLI flag or environment variable)
+        const isCompact = argv['compact-json'] === true || Flag.COMPACT_JSON();
+        if (isCompact) {
+          setCompactJson(true);
+        }
+
         // Set verbose flag if requested
         if (argv.verbose) {
           Flag.setVerbose(true);
@@ -855,11 +856,12 @@ async function main() {
         }
 
         // Initialize logging system
-        // - If verbose: print logs to stderr for debugging in JSON format
-        // - Otherwise: write logs to file to keep CLI output clean
+        // - Print logs to stdout only when verbose for clean CLI output
+        // - Use verbose flag to enable DEBUG level logging
         await Log.init({
-          print: Flag.OPENCODE_VERBOSE,
+          print: Flag.OPENCODE_VERBOSE, // Output logs only when verbose for clean CLI output
           level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',
+          compactJson: isCompact,
         });
       })
       .fail((msg, err, yargs) => {
@@ -874,18 +876,27 @@ async function main() {
           // Format other errors using FormatError
           const formatted = FormatError(err);
           if (formatted) {
-            console.error(formatted);
+            outputError({
+              errorType: err.name || 'Error',
+              message: formatted,
+            });
           } else {
             // Fallback to default error formatting
-            console.error(err.message || err);
+            outputError({
+              errorType: err.name || 'Error',
+              message: err.message || String(err),
+            });
           }
           process.exit(1);
         }
 
         // Handle validation errors (msg without err)
         if (msg) {
-          console.error(msg);
-          console.error(`\n${yargs.help()}`);
+          outputError({
+            errorType: 'ValidationError',
+            message: msg,
+            hint: yargs.help(),
+          });
           process.exit(1);
         }
       })
@@ -895,19 +906,12 @@ async function main() {
     await yargsInstance.argv;
   } catch (error) {
     hasError = true;
-    console.error(
-      JSON.stringify(
-        {
-          type: 'error',
-          timestamp: Date.now(),
-          errorType: error instanceof Error ? error.name : 'Error',
-          message: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : undefined,
-        },
-        null,
-        2
-      )
-    );
+    outputError({
+      timestamp: Date.now(),
+      errorType: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     process.exit(1);
   }
 }

package/src/json-standard/index.ts

@@ -2,11 +2,15 @@
  * JSON Standard Format Handlers
  *
  * Provides adapters for different JSON output formats:
- * - opencode: OpenCode format (default) - pretty-printed JSON events
+ * - opencode: OpenCode format (default) - configurable JSON formatting
  * - claude: Claude CLI stream-json format - NDJSON (newline-delimited JSON)
+ *
+ * Output goes to stdout for normal messages, stderr for errors.
+ * Use AGENT_CLI_COMPACT env var or --compact-json flag for NDJSON output.
  */
 
 import { EOL } from 'os';
+import { Flag } from '../flag/flag';
 
 export type JsonStandard = 'opencode' | 'claude';
 
@@ -46,16 +50,20 @@ export interface ClaudeEvent {
 
 /**
  * Serialize JSON output based on the selected standard
+ * Respects AGENT_CLI_COMPACT env var for OpenCode format
  */
 export function serializeOutput(
   event: OpenCodeEvent | ClaudeEvent,
   standard: JsonStandard
 ): string {
   if (standard === 'claude') {
-    // NDJSON format - compact, one line
+    // NDJSON format - always compact, one line
+    return JSON.stringify(event) + EOL;
+  }
+  // OpenCode format - compact if AGENT_CLI_COMPACT is set
+  if (Flag.COMPACT_JSON()) {
     return JSON.stringify(event) + EOL;
   }
-  // OpenCode format - pretty-printed
   return JSON.stringify(event, null, 2) + EOL;
 }
 
@@ -146,13 +154,15 @@ export function createEventHandler(standard: JsonStandard, sessionID: string) {
      * Format and output an event
      */
     output(event: OpenCodeEvent): void {
+      const outputStream =
+        event.type === 'error' ? process.stderr : process.stdout;
       if (standard === 'claude') {
         const claudeEvent = convertOpenCodeToClaude(event, startTime);
         if (claudeEvent) {
-          process.stdout.write(serializeOutput(claudeEvent, standard));
+          outputStream.write(serializeOutput(claudeEvent, standard));
         }
       } else {
-        process.stdout.write(serializeOutput(event, standard));
+        outputStream.write(serializeOutput(event, standard));
       }
     },
 

package/src/session/agent.js

@@ -3,6 +3,7 @@
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/provider/provider.ts
 
 import { ToolRegistry } from '../tool/registry.ts';
+import { outputError } from '../cli/output.ts';
 
 export class Agent {
   constructor() {
@@ -96,22 +97,17 @@ export class Agent {
             const errorTime = Date.now();
             const callID = `call_${Math.floor(Math.random() * 100000000)}`;
 
-            // Log full error to stderr for debugging in JSON format
-            console.error(
-              JSON.stringify({
-                log: {
-                  level: 'error',
-                  timestamp: new Date().toISOString(),
-                  message: 'Tool execution error',
-                  tool: tool.name,
-                  error: {
-                    name: error.name,
-                    message: error.message,
-                    stack: error.stack,
-                  },
-                },
-              })
-            );
+            // Log full error to stderr in flattened JSON format
+            outputError({
+              errorType: 'ToolExecutionError',
+              message: 'Tool execution error',
+              tool: tool.name,
+              error: {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+              },
+            });
 
             // Emit tool_use event with error
             this.emitEvent('tool_use', {
@@ -217,8 +213,8 @@ export class Agent {
     // Pretty-print JSON for human readability, compact for programmatic use
     // Use AGENT_CLI_COMPACT=1 for compact output (tests, automation)
     const compact = process.env.AGENT_CLI_COMPACT === '1';
-    console.log(
-      compact ? JSON.stringify(event) : JSON.stringify(event, null, 2)
+    process.stdout.write(
+      `${compact ? JSON.stringify(event) : JSON.stringify(event, null, 2)}\n`
     );
   }
 }

package/src/session/index.ts

@@ -547,6 +547,18 @@ export namespace Session {
         return obj.reason;
       }
 
+      // Handle AI SDK unified/raw format: {unified: "tool-calls", raw: "tool_calls"}
+      // See: https://github.com/link-assistant/agent/issues/129
+      if (typeof obj.unified === 'string') {
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toFinishReason extracted unified from object',
+            result: obj.unified,
+          }));
+        }
+        return obj.unified;
+      }
+
       // If we can't extract a specific field, return JSON representation
       if (Flag.OPENCODE_VERBOSE) {
         log.debug(() => ({

package/src/session/processor.ts

@@ -188,7 +188,7 @@ export namespace SessionProcessor {
                     await Session.updatePart({
                       ...match,
                       state: {
-                        status: 'error',
+                        status: 'failed',
                         input: value.input,
                         error: (value.error as any).toString(),
                         metadata: undefined,
@@ -367,13 +367,13 @@ export namespace SessionProcessor {
             if (
               part.type === 'tool' &&
               part.state.status !== 'completed' &&
-              part.state.status !== 'error'
+              part.state.status !== 'failed'
             ) {
               await Session.updatePart({
                 ...part,
                 state: {
                   ...part.state,
-                  status: 'error',
+                  status: 'failed',
                   error: 'Tool execution aborted',
                   time: {
                     start: Date.now(),

package/src/tool/read.ts

@@ -29,7 +29,7 @@ export const ReadTool = Tool.define('read', {
   async execute(params, ctx) {
     let filepath = params.filePath;
     if (!path.isAbsolute(filepath)) {
-      filepath = path.join(process.cwd(), filepath);
+      filepath = path.join(Instance.worktree, filepath);
     }
     const title = path.relative(Instance.worktree, filepath);
 
@@ -70,14 +70,13 @@ export const ReadTool = Tool.define('read', {
       return model.info.modalities?.input?.includes('image') ?? false;
     })();
     if (isImage) {
-      if (!supportsImages) {
+      // Image format validation (can be disabled via environment variable)
+      const verifyImages = process.env.VERIFY_IMAGES_AT_READ_TOOL !== 'false';
+      if (verifyImages && !supportsImages) {
         throw new Error(
           `Failed to read image: ${filepath}, model may not be able to read images`
         );
       }
-
-      // Image format validation (can be disabled via environment variable)
-      const verifyImages = process.env.VERIFY_IMAGES_AT_READ_TOOL !== 'false';
       if (verifyImages) {
         const bytes = new Uint8Array(await file.arrayBuffer());
 

package/src/util/log-lazy.ts

@@ -1,16 +1,17 @@
 import makeLog, { levels, LogLevel } from 'log-lazy';
-import { Flag } from '../flag/flag.ts';
+import { Flag } from '../flag/flag';
 
 /**
  * JSON Lazy Logger
  *
  * Implements lazy logging pattern using log-lazy library.
- * All log output is JSON formatted and wrapped in { log: { ... } } structure
- * for easy parsing alongside regular JSON output.
+ * All log output is JSON formatted with { "type": "log", "level": "...", ... } structure
+ * for consistent parsing with other CLI JSON output.
  *
  * Key features:
  * - Lazy evaluation: log arguments are only computed if logging is enabled
- * - JSON output: all logs are parsable JSON in { log: { ... } } format
+ * - JSON output: all logs are parsable JSON with `type: "log"` field
+ * - Stdout output: logs go to stdout (not stderr) following Unix conventions
  * - Level control: logs respect --verbose flag and LINK_ASSISTANT_AGENT_VERBOSE env
  * - Type-safe: full TypeScript support
  *
@@ -52,8 +53,21 @@ const LEVEL_PRESETS = {
 
 type LevelPreset = keyof typeof LEVEL_PRESETS;
 
+import { Flag } from '../flag/flag';
+
+// Compact JSON mode (can be set at runtime, initialized from Flag)
+let compactJsonMode = Flag.COMPACT_JSON();
+
+/**
+ * Set compact JSON output mode
+ */
+export function setCompactJson(compact: boolean): void {
+  compactJsonMode = compact;
+}
+
 /**
- * Format a log entry as JSON object wrapped in { log: { ... } }
+ * Format a log entry as JSON object with { "type": "log", "level": "...", ... } structure
+ * This flattened format is consistent with other CLI JSON output.
  */
 function formatLogEntry(
   level: string,
@@ -62,6 +76,7 @@ function formatLogEntry(
 ): string {
   const timestamp = new Date().toISOString();
   const logEntry: Record<string, unknown> = {
+    type: 'log',
     level,
     timestamp,
     ...tags,
@@ -84,11 +99,16 @@ function formatLogEntry(
     logEntry.message = String(data);
   }
 
-  return JSON.stringify({ log: logEntry });
+  // Check both local setting and global Flag
+  const useCompact = compactJsonMode || Flag.COMPACT_JSON();
+  return useCompact
+    ? JSON.stringify(logEntry)
+    : JSON.stringify(logEntry, null, 2);
 }
 
 /**
- * Create the output function that writes to stderr
+ * Create the output function that writes to stdout
+ * Using stdout follows Unix conventions (stdout for data, stderr for errors)
  */
 function createOutput(
   level: string,
@@ -96,8 +116,8 @@ function createOutput(
 ): (data: unknown) => void {
   return (data: unknown) => {
     const json = formatLogEntry(level, data, tags);
-    // Use stderr to avoid interfering with stdout JSON output
-    process.stderr.write(json + '\n');
+    // Use stdout following Unix conventions
+    process.stdout.write(json + '\n');
   };
 }
 

package/src/util/log.ts

@@ -3,18 +3,19 @@ import fs from 'fs/promises';
 import { Global } from '../global';
 import z from 'zod';
 import makeLog, { levels } from 'log-lazy';
-import { Flag } from '../flag/flag.ts';
+import { Flag } from '../flag/flag';
 
 /**
  * Logging module with JSON output and lazy evaluation support.
  *
  * Features:
- * - JSON formatted output: All logs are wrapped in { log: { ... } } structure
+ * - JSON formatted output: All logs use { "type": "log", "level": "...", ... } structure
  * - Lazy evaluation: Use lazy() methods to defer expensive computations
  * - Level control: Respects --verbose flag and log level settings
  * - File logging: Writes to file when not in verbose/print mode
+ * - Stdout by default: Logs go to stdout for JSON output consistency
  *
- * The JSON format ensures all output is parsable, separating logs from regular output.
+ * The JSON format with `type` field ensures all output is consistent with other CLI output.
  */
 export namespace Log {
   export const Level = z
@@ -31,6 +32,7 @@ export namespace Log {
 
   let level: Level = 'INFO';
   let jsonOutput = false; // Whether to output JSON format (enabled in verbose mode)
+  let compactJsonOutput = Flag.COMPACT_JSON(); // Whether to use compact JSON (single line)
 
   function shouldLog(input: Level): boolean {
     return levelPriority[input] >= levelPriority[level];
@@ -84,19 +86,24 @@ export namespace Log {
     print: boolean;
     dev?: boolean;
     level?: Level;
+    compactJson?: boolean;
   }
 
   let logpath = '';
   export function file() {
     return logpath;
   }
-  let write = (msg: any) => Bun.stderr.write(msg);
+  // Default to file for log output (to keep CLI output clean)
+  let write = (msg: any) => {}; // Placeholder, set in init
+  let fileWrite = (msg: any) => {}; // Placeholder, set in init
 
   // Initialize log-lazy for controlling lazy log execution
   let lazyLogInstance = makeLog({ level: 0 }); // Start disabled
 
   export async function init(options: Options) {
     if (options.level) level = options.level;
+    if (options.compactJson !== undefined)
+      compactJsonOutput = options.compactJson;
     cleanup(Global.Path.log);
 
     // Always use JSON output format for logs
@@ -109,30 +116,36 @@ export namespace Log {
         level: levels.debug | levels.info | levels.warn | levels.error,
       });
     } else {
-      // Disable lazy logging when not verbose
-      lazyLogInstance = makeLog({ level: 0 });
+      // Enable info, warn, error by default for JSON output consistency
+      lazyLogInstance = makeLog({
+        level: levels.info | levels.warn | levels.error,
+      });
     }
 
-    if (options.print) {
-      // In print mode, output to stderr
-      // No file logging needed
-    } else {
-      // In normal mode, write to file
-      logpath = path.join(
-        Global.Path.log,
-        options.dev
-          ? 'dev.log'
-          : new Date().toISOString().split('.')[0].replace(/:/g, '') + '.log'
-      );
-      const logfile = Bun.file(logpath);
-      await fs.truncate(logpath).catch(() => {});
-      const writer = logfile.writer();
-      write = async (msg: any) => {
-        const num = writer.write(msg);
-        writer.flush();
-        return num;
-      };
-    }
+    // Output logs to stdout by default for JSON formatting consistency
+    // Also write to file for debugging purposes
+    logpath = path.join(
+      Global.Path.log,
+      options.dev
+        ? 'dev.log'
+        : new Date().toISOString().split('.')[0].replace(/:/g, '') + '.log'
+    );
+    const logfile = Bun.file(logpath);
+    await fs.truncate(logpath).catch(() => {});
+    const writer = logfile.writer();
+    // Write to file
+    fileWrite = async (msg: any) => {
+      const num = writer.write(msg);
+      writer.flush();
+      return num;
+    };
+
+    // Always write to stdout for JSON output consistency
+    // Also write to file for debugging purposes
+    write = async (msg: any) => {
+      process.stdout.write(msg);
+      fileWrite(msg);
+    };
   }
 
   async function cleanup(dir: string) {
@@ -159,7 +172,8 @@ export namespace Log {
   }
 
   /**
-   * Format log entry as JSON object wrapped in { log: { ... } }
+   * Format log entry as JSON object with { "type": "log", "level": "...", ... } structure
+   * This flattened format is consistent with other CLI JSON output.
    */
   function formatJson(
     logLevel: Level,
@@ -169,6 +183,7 @@ export namespace Log {
   ): string {
     const timestamp = new Date().toISOString();
     const logEntry: Record<string, any> = {
+      type: 'log',
       level: logLevel.toLowerCase(),
       timestamp,
       ...tags,
@@ -192,7 +207,12 @@ export namespace Log {
       }
     }
 
-    return JSON.stringify({ log: logEntry });
+    // Use compact or pretty format based on configuration
+    // Check both local setting and global Flag
+    const useCompact = compactJsonOutput || Flag.COMPACT_JSON();
+    return useCompact
+      ? JSON.stringify(logEntry)
+      : JSON.stringify(logEntry, null, 2);
   }
 
   let last = Date.now();
@@ -239,7 +259,9 @@ export namespace Log {
     ) {
       if (jsonOutput) {
         // Use our custom JSON formatting for { log: { ... } } format
-        write(formatJson(logLevel, message, tags || {}, extra) + '\n');
+        const jsonMsg = formatJson(logLevel, message, tags || {}, extra) + '\n';
+        // All logs go to stdout for consistency with other JSON output
+        write(jsonMsg);
       } else {
         write(logLevel.padEnd(5) + ' ' + buildLegacy(message, extra));
       }
@@ -354,6 +376,8 @@ export namespace Log {
   export function syncWithVerboseFlag(): void {
     if (Flag.OPENCODE_VERBOSE) {
       jsonOutput = true;
+      // Use stdout for verbose output (following Unix conventions)
+      write = (msg: any) => process.stdout.write(msg);
       lazyLogInstance = makeLog({
         level: levels.debug | levels.info | levels.warn | levels.error,
       });
@@ -361,4 +385,18 @@ export namespace Log {
       lazyLogInstance = makeLog({ level: 0 });
     }
   }
+
+  /**
+   * Set compact JSON output mode
+   */
+  export function setCompactJson(compact: boolean): void {
+    compactJsonOutput = compact;
+  }
+
+  /**
+   * Check if compact JSON output mode is enabled
+   */
+  export function isCompactJson(): boolean {
+    return compactJsonOutput;
+  }
 }