@link-assistant/agent 0.18.3 → 0.19.2

package/src/file/watcher.ts

@@ -1,10 +1,10 @@
 import z from 'zod';
 import { Bus } from '../bus';
-import { Flag } from '../flag/flag';
+import { config } from '../config/config';
 import { Instance } from '../project/instance';
 import { Log } from '../util/log';
 import { FileIgnore } from './ignore';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 // @ts-ignore
 import { createWrapper } from '@parcel/watcher/wrapper';
 import { lazy } from '../util/lazy';
@@ -83,7 +83,7 @@ export namespace FileWatcher {
   );
 
   export function init() {
-    if (!Flag.OPENCODE_EXPERIMENTAL_WATCHER) return;
+    if (!config.experimentalWatcher) return;
     state();
   }
 }

package/src/format/index.ts

@@ -5,7 +5,7 @@ import path from 'path';
 import z from 'zod';
 
 import * as Formatter from './formatter';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 import { mergeDeep } from 'remeda';
 import { Instance } from '../project/instance';
 

package/src/index.js

@@ -1,5 +1,11 @@
 #!/usr/bin/env bun
-import { Flag } from './flag/flag.ts';
+import {
+  config,
+  initConfig,
+  isVerbose,
+  setVerbose,
+  getConfigSnapshot,
+} from './config/config.ts';
 import { setProcessName } from './cli/process-name.ts';
 setProcessName('agent');
 import { Server } from './server/server.ts';
@@ -21,7 +27,10 @@ import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
-import { createVerboseFetch } from './util/verbose-fetch.ts';
+import {
+  createVerboseFetch,
+  registerPendingStreamLogExitHandler,
+} from './util/verbose-fetch.ts';
 import {
   runContinuousServerMode,
   runContinuousDirectMode,
@@ -249,7 +258,7 @@ async function runAgentMode(argv, request) {
     workingDirectory: process.cwd(),
     scriptPath: import.meta.path,
   }));
-  if (Flag.OPENCODE_DRY_RUN) {
+  if (config.dryRun) {
     Log.Default.info(() => ({
       message: 'Dry run mode enabled',
       mode: 'dry-run',
@@ -336,7 +345,7 @@ async function runContinuousAgentMode(argv) {
     workingDirectory: process.cwd(),
     scriptPath: import.meta.path,
   }));
-  if (Flag.OPENCODE_DRY_RUN) {
+  if (config.dryRun) {
     Log.Default.info(() => ({
       message: 'Dry run mode enabled',
       mode: 'dry-run',
@@ -608,7 +617,7 @@ async function main() {
         handler: async (argv) => {
           // Check both CLI flag and environment variable for compact JSON mode
           const compactJson =
-            argv['compact-json'] === true || Flag.COMPACT_JSON();
+            argv['compact-json'] === true || config.compactJson;
 
           // Check if --prompt flag was provided
           if (argv.prompt) {
@@ -767,54 +776,57 @@ async function main() {
           await runAgentMode(argv, request);
         },
       })
-      // Initialize logging and flags early for all CLI commands
+      // Initialize centralized config and flags from CLI args + env vars + .lenv.
+      // Uses lino-arguments getenv() for env var resolution (case-insensitive,
+      // type-preserving, .lenv support).
+      // See: https://github.com/link-foundation/lino-arguments
+      // See: https://github.com/link-assistant/agent/issues/227
       .middleware(async (argv) => {
-        const isCompact = argv['compact-json'] === true || Flag.COMPACT_JSON();
+        // Initialize global config using makeConfig from lino-arguments.
+        // Resolves CLI args + env vars + .lenv files in one place.
+        // After this call, the global `config` variable is fully resolved.
+        // See: https://github.com/link-foundation/lino-arguments
+        initConfig();
+
+        // Override compact-json from argv if explicitly set.
+        if (argv['compact-json'] === true) {
+          config.compactJson = true;
+        }
+        const isCompact = config.compactJson;
         if (isCompact) {
           setCompactJson(true);
         }
-        if (argv.verbose) {
-          Flag.setVerbose(true);
-        }
-        if (argv['dry-run']) {
-          Flag.setDryRun(true);
-        }
-        if (argv['generate-title'] === true) {
-          Flag.setGenerateTitle(true);
-        }
-        // output-response-model is enabled by default, only set if explicitly disabled
-        if (argv['output-response-model'] === false) {
-          Flag.setOutputResponseModel(false);
-        }
-        // summarize-session is enabled by default, only set if explicitly disabled
-        if (argv['summarize-session'] === false) {
-          Flag.setSummarizeSession(false);
-        } else {
-          Flag.setSummarizeSession(true);
-        }
-        // retry-on-rate-limits is enabled by default, only set if explicitly disabled
-        if (argv['retry-on-rate-limits'] === false) {
-          Flag.setRetryOnRateLimits(false);
+
+        // Sync verbose to env var for subprocess resilience.
+        if (config.verbose) {
+          setVerbose(true);
         }
+
+        // Initialize logging.
         await Log.init({
-          print: Flag.OPENCODE_VERBOSE,
-          level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',
+          print: isVerbose(),
+          level: isVerbose() ? 'DEBUG' : 'INFO',
           compactJson: isCompact,
         });
 
+        // Always log the resolved configuration as JSON.
+        // This is critical for debugging — shows exactly what config was resolved
+        // from CLI args, env vars, and .lenv files combined.
+        Log.Default.info(() => ({
+          type: 'config',
+          message: 'Agent configuration resolved',
+          source: 'lino-arguments (CLI args > env vars > .lenv > defaults)',
+          config: getConfigSnapshot(),
+        }));
+
         // Global fetch monkey-patch for verbose HTTP logging (#221).
-        // This catches any HTTP calls that go through globalThis.fetch directly,
-        // including non-provider calls (auth, config, tools) that may not have
-        // their own createVerboseFetch wrapper. The provider-level wrapper in
-        // provider.ts getSDK() also logs independently — both mechanisms are
-        // kept active to maximize HTTP observability in --verbose mode.
-        // See: https://github.com/link-assistant/agent/issues/221
-        // See: https://github.com/link-assistant/agent/issues/217
         if (!globalThis.__agentVerboseFetchInstalled) {
           globalThis.fetch = createVerboseFetch(globalThis.fetch, {
             caller: 'global',
           });
           globalThis.__agentVerboseFetchInstalled = true;
+          // Register handler to warn about pending stream logs at process exit (#231)
+          registerPendingStreamLogExitHandler();
         }
       })
       .fail((msg, err, yargs) => {

package/src/json-standard/index.ts

@@ -6,11 +6,11 @@
  * - 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.
+ * Use LINK_ASSISTANT_AGENT_COMPACT_JSON env var or --compact-json flag for NDJSON output.
  */
 
 import { EOL } from 'os';
-import { Flag } from '../flag/flag';
+import { config } from '../config/config';
 
 export type JsonStandard = 'opencode' | 'claude';
 
@@ -50,7 +50,7 @@ export interface ClaudeEvent {
 
 /**
  * Serialize JSON output based on the selected standard
- * Respects AGENT_CLI_COMPACT env var for OpenCode format
+ * Respects LINK_ASSISTANT_AGENT_COMPACT_JSON env var for OpenCode format
  */
 export function serializeOutput(
   event: OpenCodeEvent | ClaudeEvent,
@@ -60,8 +60,8 @@ export function serializeOutput(
     // NDJSON format - always compact, one line
     return JSON.stringify(event) + EOL;
   }
-  // OpenCode format - compact if AGENT_CLI_COMPACT is set
-  if (Flag.COMPACT_JSON()) {
+  // OpenCode format - compact if LINK_ASSISTANT_AGENT_COMPACT_JSON is set
+  if (config.compactJson) {
     return JSON.stringify(event) + EOL;
   }
   return JSON.stringify(event, null, 2) + EOL;

package/src/mcp/index.ts

@@ -3,7 +3,8 @@ import { type Tool } from 'ai';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
+import { config } from '../config/config';
 import { Log } from '../util/log';
 import { NamedError } from '../util/error';
 import z from 'zod/v4';
@@ -89,23 +90,15 @@ export namespace MCP {
       const status: Record<string, Status> = {};
       const timeoutConfigs: Record<string, TimeoutConfig> = {};
 
-      // Determine global timeout defaults from config and environment variables
-      const envDefaultTimeout = process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT
-        ? parseInt(process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT, 10)
-        : undefined;
-      const envMaxTimeout = process.env.MCP_MAX_TOOL_CALL_TIMEOUT
-        ? parseInt(process.env.MCP_MAX_TOOL_CALL_TIMEOUT, 10)
-        : undefined;
-
+      // Determine global timeout defaults from config and environment variables.
+      // Uses config.mcp*() which reads from centralized AgentConfig (lino-arguments).
       const globalDefaults: GlobalTimeoutDefaults = {
         defaultTimeout:
           cfg.mcp_defaults?.tool_call_timeout ??
-          envDefaultTimeout ??
-          BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT,
+          config.mcpDefaultToolCallTimeout,
         maxTimeout:
           cfg.mcp_defaults?.max_tool_call_timeout ??
-          envMaxTimeout ??
-          BUILTIN_MAX_TOOL_CALL_TIMEOUT,
+          config.mcpMaxToolCallTimeout,
       };
 
       await Promise.all(

package/src/project/bootstrap.ts

@@ -1,7 +1,6 @@
 import { Format } from '../format';
 import { FileWatcher } from '../file/watcher';
 import { File } from '../file';
-import { Flag } from '../flag/flag';
 import { Project } from './project';
 import { Bus } from '../bus';
 import { Command } from '../command';

package/src/project/project.ts

@@ -4,7 +4,6 @@ import path from 'path';
 import { $ } from 'bun';
 import { Storage } from '../storage/storage';
 import { Log } from '../util/log';
-import { Flag } from '../flag/flag';
 
 export namespace Project {
   const log = Log.create({ service: 'project' });

package/src/provider/provider.ts

@@ -1,6 +1,6 @@
 import z from 'zod';
 import path from 'path';
-import { Config } from '../config/config';
+import { Config } from '../config/file-config';
 import { mergeDeep, sortBy } from 'remeda';
 import { NoSuchModelError, type LanguageModel, type Provider as SDK } from 'ai';
 import { Log } from '../util/log';
@@ -12,7 +12,7 @@ import { ClaudeOAuth } from '../auth/claude-oauth';
 import { AuthPlugins } from '../auth/plugins';
 import { Instance } from '../project/instance';
 import { Global } from '../global';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 import { iife } from '../util/iife';
 import { createEchoModel } from './echo';
 import { createCacheModel } from './cache';
@@ -647,7 +647,7 @@ export namespace Provider {
     'link-assistant': async () => {
       // Echo provider is always available - no external dependencies needed
       return {
-        autoload: Flag.OPENCODE_DRY_RUN, // Auto-load only in dry-run mode
+        autoload: config.dryRun, // Auto-load only in dry-run mode
         async getModel(_sdk: any, modelID: string) {
           // Return our custom echo model that implements LanguageModelV1
           return createEchoModel(modelID);
@@ -1124,7 +1124,7 @@ export namespace Provider {
           .filter(
             ([, model]) =>
               ((!model.experimental && model.status !== 'alpha') ||
-                Flag.OPENCODE_ENABLE_EXPERIMENTAL_MODELS) &&
+                config.enableExperimentalModels) &&
               model.status !== 'deprecated'
           )
       );
@@ -1220,7 +1220,7 @@ export namespace Provider {
           pkg,
           globalVerboseFetchInstalled:
             !!globalThis.__agentVerboseFetchInstalled,
-          verboseAtCreation: Flag.OPENCODE_VERBOSE,
+          verboseAtCreation: isVerbose(),
         });
 
         options['fetch'] = async (
@@ -1228,9 +1228,11 @@ export namespace Provider {
           init?: RequestInit
         ): Promise<Response> => {
           // Check verbose flag at call time — not at SDK creation time.
-          // This ensures --verbose works even when the flag is set after SDK creation.
+          // Uses isVerbose() with env var fallback for resilience against
+          // flag state loss in subprocess/module-reload scenarios.
           // See: https://github.com/link-assistant/agent/issues/206
-          if (!Flag.OPENCODE_VERBOSE) {
+          // See: https://github.com/link-assistant/agent/issues/227
+          if (!isVerbose()) {
             return innerFetch(input, init);
           }
 
@@ -1621,35 +1623,30 @@ export namespace Provider {
     }
 
     if (!isSyntheticProvider && !info) {
-      // Still not found after refresh - create fallback info and try anyway
-      // Provider may support unlisted models
+      // Model not found even after cache refresh — fail with a clear error (#231)
+      // Previously this created synthetic fallback info, which allowed the API call
+      // to proceed with the wrong model (e.g., kimi-k2.5-free routed to minimax-m2.5-free)
       const availableInProvider = Object.keys(provider.info.models).slice(
         0,
         10
       );
-      log.warn(() => ({
+      log.error(() => ({
         message:
-          'model not in provider catalog after refresh - attempting anyway (may be unlisted)',
+          'model not found in provider catalog after refresh — refusing to proceed',
         providerID,
         modelID,
         availableModels: availableInProvider,
         totalModels: Object.keys(provider.info.models).length,
       }));
 
-      // Create a minimal fallback model info so SDK loading can proceed
-      // Use sensible defaults - the provider will reject if the model truly doesn't exist
-      info = {
-        id: modelID,
-        name: modelID,
-        release_date: '',
-        attachment: false,
-        reasoning: false,
-        temperature: true,
-        tool_call: true,
-        cost: { input: 0, output: 0 },
-        limit: { context: 128000, output: 16384 },
-        options: {},
-      } as ModelsDev.Model;
+      throw new ModelNotFoundError({
+        providerID,
+        modelID,
+        suggestion:
+          `Model "${modelID}" not found in provider "${providerID}" (checked ${Object.keys(provider.info.models).length} models). ` +
+          `Available models include: ${availableInProvider.join(', ')}. ` +
+          `Use --model ${providerID}/<model-id> with a valid model.`,
+      });
     }
 
     try {
@@ -1787,7 +1784,7 @@ export namespace Provider {
     // In dry-run mode, use the echo provider by default
     // This allows testing round-trips and multi-turn conversations without API costs
     // @see https://github.com/link-assistant/agent/issues/89
-    if (Flag.OPENCODE_DRY_RUN) {
+    if (config.dryRun) {
       log.info('dry-run mode enabled, using echo provider as default');
       return {
         providerID: 'link-assistant',

package/src/provider/retry-fetch.ts

@@ -1,24 +1,27 @@
 import { Log } from '../util/log';
-import { Flag } from '../flag/flag';
+import { config } from '../config/config';
 
 /**
- * Custom fetch wrapper that handles rate limits (HTTP 429) using time-based retry logic.
+ * Custom fetch wrapper that handles rate limits (HTTP 429) and server errors (HTTP 5xx)
+ * using time-based retry logic.
  *
- * This wrapper intercepts 429 responses at the HTTP level before the AI SDK's internal
- * retry mechanism can interfere. It respects:
+ * This wrapper intercepts 429 and 5xx responses at the HTTP level before the AI SDK's
+ * internal retry mechanism can interfere. It respects:
  * - retry-after headers (both seconds and HTTP date formats)
  * - retry-after-ms header for millisecond precision
- * - AGENT_RETRY_TIMEOUT for global time-based retry limit
- * - AGENT_MAX_RETRY_DELAY for maximum single retry wait time
+ * - LINK_ASSISTANT_AGENT_RETRY_TIMEOUT for global time-based retry limit
+ * - LINK_ASSISTANT_AGENT_MAX_RETRY_DELAY for maximum single retry wait time
  *
  * Problem solved:
  * The AI SDK's internal retry uses a fixed count (default 3 attempts) and ignores
  * retry-after headers. When providers return long retry-after values (e.g., 64 minutes),
  * the SDK exhausts its retries before the agent can properly wait.
+ * Additionally, server errors (500, 502, 503) from providers like OpenCode API were not
+ * retried, causing compaction cycles to be lost silently.
  *
  * Solution:
- * By wrapping fetch, we handle rate limits at the HTTP layer with time-based retries,
- * ensuring the agent's 7-week global timeout is respected.
+ * By wrapping fetch, we handle rate limits and server errors at the HTTP layer with
+ * time-based retries, ensuring the agent's 7-week global timeout is respected.
  *
  * Important: Rate limit waits use ISOLATED AbortControllers that are NOT subject to
  * provider/stream timeouts. This prevents long rate limit waits (e.g., 15 hours) from
@@ -26,6 +29,7 @@ import { Flag } from '../flag/flag';
  *
  * @see https://github.com/link-assistant/agent/issues/167
  * @see https://github.com/link-assistant/agent/issues/183
+ * @see https://github.com/link-assistant/agent/issues/231
  * @see https://github.com/vercel/ai/issues/12585
  */
 
@@ -37,10 +41,24 @@ export namespace RetryFetch {
   const RETRY_BACKOFF_FACTOR = 2;
   const RETRY_MAX_DELAY_NO_HEADERS = 30_000;
 
+  // Maximum number of retries for server errors (5xx) — unlike rate limits (429)
+  // which retry indefinitely within the global timeout, server errors use a fixed
+  // retry count to avoid retrying permanently broken endpoints (#231)
+  const SERVER_ERROR_MAX_RETRIES = 3;
+
+  /**
+   * Check if an HTTP status code is a retryable server error.
+   * Retries on 500 (Internal Server Error), 502 (Bad Gateway), and 503 (Service Unavailable).
+   * @see https://github.com/link-assistant/agent/issues/231
+   */
+  function isRetryableServerError(status: number): boolean {
+    return status === 500 || status === 502 || status === 503;
+  }
+
   // Minimum retry interval to prevent rapid retries (default: 30 seconds)
   // Can be configured via AGENT_MIN_RETRY_INTERVAL env var
   function getMinRetryInterval(): number {
-    return Flag.MIN_RETRY_INTERVAL();
+    return config.minRetryInterval * 1000;
   }
 
   /**
@@ -194,7 +212,7 @@ export namespace RetryFetch {
    *
    * This controller is NOT connected to the request's AbortSignal, so it won't be
    * affected by provider timeouts (default 5 minutes) or stream timeouts.
-   * It only respects the global AGENT_RETRY_TIMEOUT.
+   * It only respects the global LINK_ASSISTANT_AGENT_RETRY_TIMEOUT.
    *
    * However, it DOES check the user's abort signal periodically (every 10 seconds)
    * to allow user cancellation during long rate limit waits.
@@ -217,7 +235,7 @@ export namespace RetryFetch {
     const controller = new AbortController();
     const timers: NodeJS.Timeout[] = [];
 
-    // Set a timeout based on the global AGENT_RETRY_TIMEOUT (not provider timeout)
+    // Set a timeout based on the global LINK_ASSISTANT_AGENT_RETRY_TIMEOUT (not provider timeout)
     const globalTimeoutId = setTimeout(() => {
       controller.abort(
         new DOMException(
@@ -298,19 +316,20 @@ export namespace RetryFetch {
   };
 
   /**
-   * Create a fetch function that handles rate limits with time-based retry logic.
+   * Create a fetch function that handles rate limits and server errors with retry logic.
    *
    * This wrapper:
-   * 1. Intercepts HTTP 429 responses
-   * 2. Parses retry-after headers
-   * 3. Waits for the specified duration (respecting global timeout)
-   * 4. Retries the request
+   * 1. Intercepts HTTP 429 (rate limit) responses — retries with retry-after headers
+   * 2. Intercepts HTTP 500/502/503 (server error) responses — retries up to SERVER_ERROR_MAX_RETRIES
+   * 3. Parses retry-after headers for 429 responses
+   * 4. Uses exponential backoff for server errors and network errors
+   * 5. Respects global LINK_ASSISTANT_AGENT_RETRY_TIMEOUT for all retries
    *
-   * If retry-after exceeds AGENT_RETRY_TIMEOUT, the original 429 response is returned
+   * If retry-after exceeds LINK_ASSISTANT_AGENT_RETRY_TIMEOUT, the original 429 response is returned
    * to let higher-level error handling take over.
    *
    * @param options Configuration options
-   * @returns A fetch function with rate limit retry handling
+   * @returns A fetch function with rate limit and server error retry handling
    */
   export function create(options: RetryFetchOptions = {}): typeof fetch {
     const baseFetch = options.baseFetch ?? fetch;
@@ -322,8 +341,8 @@ export namespace RetryFetch {
     ): Promise<Response> {
       let attempt = 0;
       const startTime = Date.now();
-      const maxRetryTimeout = Flag.RETRY_TIMEOUT() * 1000;
-      const maxBackoffDelay = Flag.MAX_RETRY_DELAY();
+      const maxRetryTimeout = config.retryTimeout * 1000;
+      const maxBackoffDelay = config.maxRetryDelay * 1000;
 
       while (true) {
         attempt++;
@@ -365,13 +384,80 @@ export namespace RetryFetch {
           throw error;
         }
 
-        // Only handle rate limit errors (429)
+        // Handle retryable server errors (500, 502, 503) with limited retries (#231)
+        // Unlike rate limits (429) which retry indefinitely within timeout,
+        // server errors use a fixed count to avoid retrying broken endpoints.
+        if (isRetryableServerError(response.status)) {
+          if (attempt > SERVER_ERROR_MAX_RETRIES) {
+            // Read response body for diagnostics before returning (#231)
+            // This ensures the actual server error is visible in logs,
+            // preventing misleading downstream errors like "input_tokens undefined"
+            let errorBody = '';
+            try {
+              errorBody = await response.clone().text();
+            } catch {
+              errorBody = '<failed to read response body>';
+            }
+            log.warn(() => ({
+              message:
+                'server error max retries exceeded, returning error response',
+              sessionID,
+              status: response.status,
+              attempt,
+              maxRetries: SERVER_ERROR_MAX_RETRIES,
+              responseBody: errorBody.slice(0, 500),
+            }));
+            return response;
+          }
+
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= maxRetryTimeout) {
+            let errorBody = '';
+            try {
+              errorBody = await response.clone().text();
+            } catch {
+              errorBody = '<failed to read response body>';
+            }
+            log.warn(() => ({
+              message:
+                'retry timeout exceeded for server error, returning error response',
+              sessionID,
+              status: response.status,
+              elapsedMs: elapsed,
+              maxRetryTimeoutMs: maxRetryTimeout,
+              responseBody: errorBody.slice(0, 500),
+            }));
+            return response;
+          }
+
+          // Use exponential backoff for server errors (no retry-after expected)
+          const delay = addJitter(
+            Math.min(
+              RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
+              Math.min(maxBackoffDelay, RETRY_MAX_DELAY_NO_HEADERS)
+            )
+          );
+
+          log.info(() => ({
+            message: 'server error, will retry',
+            sessionID,
+            status: response.status,
+            attempt,
+            maxRetries: SERVER_ERROR_MAX_RETRIES,
+            delayMs: delay,
+          }));
+
+          await sleep(delay, init?.signal ?? undefined);
+          continue;
+        }
+
+        // Only handle rate limit errors (429) beyond this point
         if (response.status !== 429) {
           return response;
         }
 
         // If retry on rate limits is disabled, return 429 immediately
-        if (!Flag.RETRY_ON_RATE_LIMITS) {
+        if (!config.retryOnRateLimits) {
           log.info(() => ({
             message:
               'rate limit retry disabled (--no-retry-on-rate-limits), returning 429',
@@ -442,7 +528,7 @@ export namespace RetryFetch {
         // Wait before retrying using ISOLATED signal
         // This is critical for issue #183: Rate limit waits can be hours long (e.g., 15 hours),
         // but provider timeouts are typically 5 minutes. By using an isolated AbortController
-        // that only respects AGENT_RETRY_TIMEOUT, we prevent the provider timeout from
+        // that only respects LINK_ASSISTANT_AGENT_RETRY_TIMEOUT, we prevent the provider timeout from
         // aborting long rate limit waits.
         //
         // The isolated signal periodically checks the user's abort signal (every 10 seconds)

package/src/session/agent.js

@@ -211,8 +211,10 @@ export class Agent {
       ...data,
     };
     // 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';
+    // Use LINK_ASSISTANT_AGENT_COMPACT_JSON=1 for compact output (tests, automation)
+    const compact =
+      process.env.LINK_ASSISTANT_AGENT_COMPACT_JSON === 'true' ||
+      process.env.LINK_ASSISTANT_AGENT_COMPACT_JSON === '1';
     process.stdout.write(
       `${compact ? JSON.stringify(event) : JSON.stringify(event, null, 2)}\n`
     );

package/src/session/compaction.ts

@@ -9,7 +9,7 @@ import { Bus } from '../bus';
 import z from 'zod';
 import type { ModelsDev } from '../provider/models';
 import { SessionPrompt } from './prompt';
-import { Flag } from '../flag/flag';
+import { config, isVerbose } from '../config/config';
 import { Token } from '../util/token';
 import { Log } from '../util/log';
 import { ProviderTransform } from '../provider/transform';
@@ -98,7 +98,7 @@ export namespace SessionCompaction {
     compactionModel?: CompactionModelConfig;
     compactionModelContextLimit?: number;
   }) {
-    if (Flag.OPENCODE_DISABLE_AUTOCOMPACT) return false;
+    if (config.disableAutocompact) return false;
     const baseModelContextLimit = input.model.limit.context;
     if (baseModelContextLimit === 0) return false;
     const count =
@@ -180,7 +180,7 @@ export namespace SessionCompaction {
   // calls. then erases output of previous tool calls. idea is to throw away old
   // tool calls that are no longer relevant.
   export async function prune(input: { sessionID: string }) {
-    if (Flag.OPENCODE_DISABLE_PRUNE) return;
+    if (config.disablePrune) return;
     log.info(() => ({ message: 'pruning' }));
     const msgs = await Session.messages({ sessionID: input.sessionID });
     let total = 0;
@@ -240,7 +240,7 @@ export namespace SessionCompaction {
       input.model.providerID,
       input.model.modelID
     );
-    if (Flag.OPENCODE_VERBOSE) {
+    if (isVerbose()) {
       log.info(() => ({
         message: 'compaction model loaded',
         providerID: model.providerID,
@@ -303,7 +303,7 @@ export namespace SessionCompaction {
     // Defensive check: ensure modelMessages is iterable (AI SDK 6.0.1 compatibility fix)
     const safeModelMessages = Array.isArray(modelMessages) ? modelMessages : [];
 
-    if (Flag.OPENCODE_VERBOSE) {
+    if (isVerbose()) {
       log.info(() => ({
         message: 'compaction streamText call',
         providerID: model.providerID,