@link-assistant/agent 0.17.0 → 0.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "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/argv.ts

@@ -4,30 +4,68 @@
  */
 
 /**
- * Extract model argument directly from process.argv
- * This is a safeguard against yargs caching issues (#192)
- * @returns The model argument from CLI or null if not found
+ * Extract a named argument directly from process.argv.
+ * Supports --name=value, --name value, and optional short aliases (-x=value, -x value).
+ * @returns The argument value from CLI or null if not found
  */
-export function getModelFromProcessArgv(): string | null {
+function getArgFromProcessArgv(
+  longFlag: string,
+  shortFlag?: string
+): string | null {
   const args = process.argv;
+  const longPrefix = `--${longFlag}=`;
+  const shortPrefix = shortFlag ? `-${shortFlag}=` : null;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    // Handle --model=value format
-    if (arg.startsWith('--model=')) {
-      return arg.substring('--model='.length);
+    // Handle --flag=value format
+    if (arg.startsWith(longPrefix)) {
+      return arg.substring(longPrefix.length);
     }
-    // Handle --model value format
-    if (arg === '--model' && i + 1 < args.length) {
+    // Handle --flag value format
+    if (arg === `--${longFlag}` && i + 1 < args.length) {
       return args[i + 1];
     }
-    // Handle -m=value format
-    if (arg.startsWith('-m=')) {
-      return arg.substring('-m='.length);
-    }
-    // Handle -m value format (but not if it looks like another flag)
-    if (arg === '-m' && i + 1 < args.length && !args[i + 1].startsWith('-')) {
-      return args[i + 1];
+    if (shortPrefix) {
+      // Handle -x=value format
+      if (arg.startsWith(shortPrefix)) {
+        return arg.substring(shortPrefix.length);
+      }
+      // Handle -x value format (but not if it looks like another flag)
+      if (
+        arg === `-${shortFlag}` &&
+        i + 1 < args.length &&
+        !args[i + 1].startsWith('-')
+      ) {
+        return args[i + 1];
+      }
     }
   }
   return null;
 }
+
+/**
+ * Extract model argument directly from process.argv
+ * This is a safeguard against yargs caching issues (#192)
+ * @returns The model argument from CLI or null if not found
+ */
+export function getModelFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('model', 'm');
+}
+
+/**
+ * Extract --compaction-model argument directly from process.argv
+ * @returns The compaction model argument from CLI or null if not found
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export function getCompactionModelFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('compaction-model');
+}
+
+/**
+ * Extract --compaction-safety-margin argument directly from process.argv
+ * @returns The compaction safety margin (%) from CLI or null if not found
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export function getCompactionSafetyMarginFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('compaction-safety-margin');
+}

package/src/cli/continuous-mode.js

@@ -193,7 +193,8 @@ export async function runContinuousServerMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
@@ -286,6 +287,7 @@ export async function runContinuousServerMode(
           body: JSON.stringify({
             parts,
             model: { providerID, modelID },
+            compactionModel,
             system: systemMessage,
             appendSystem: appendSystemMessage,
           }),
@@ -443,7 +445,8 @@ export async function runContinuousDirectMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
@@ -517,6 +520,7 @@ export async function runContinuousDirectMode(
         sessionID,
         parts,
         model: { providerID, modelID },
+        compactionModel,
         system: systemMessage,
         appendSystem: appendSystemMessage,
       }).catch((error) => {

package/src/cli/defaults.ts

@@ -13,3 +13,21 @@ export const DEFAULT_PROVIDER_ID = DEFAULT_MODEL.split('/')[0];
 
 /** Default model ID extracted from DEFAULT_MODEL. */
 export const DEFAULT_MODEL_ID = DEFAULT_MODEL.split('/').slice(1).join('/');
+
+/**
+ * Default compaction model used when no `--compaction-model` CLI argument is provided.
+ * gpt-5-nano has a 400K context window, larger than most free base models (~200K),
+ * which allows compacting 100% of the base model's context without a safety margin.
+ * The special value "same" means use the same model as `--model`.
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export const DEFAULT_COMPACTION_MODEL = 'opencode/gpt-5-nano';
+
+/**
+ * Default compaction safety margin as a percentage of usable context window.
+ * Applied only when the compaction model has a context window equal to or smaller
+ * than the base model. When the compaction model has a larger context, the margin
+ * is automatically set to 0 (allowing 100% context usage).
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export const DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT = 15;

package/src/cli/model-config.js

@@ -1,6 +1,15 @@
-import { getModelFromProcessArgv } from './argv.ts';
+import {
+  getModelFromProcessArgv,
+  getCompactionModelFromProcessArgv,
+  getCompactionSafetyMarginFromProcessArgv,
+} from './argv.ts';
 import { Log } from '../util/log.ts';
-import { DEFAULT_PROVIDER_ID, DEFAULT_MODEL_ID } from './defaults.ts';
+import {
+  DEFAULT_PROVIDER_ID,
+  DEFAULT_MODEL_ID,
+  DEFAULT_COMPACTION_MODEL,
+  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+} from './defaults.ts';
 
 /**
  * Parse model config from argv. Supports "provider/model" or short "model" format.
@@ -101,6 +110,13 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     }));
   }
 
+  // Parse compaction model (#219)
+  const compactionModelResult = await parseCompactionModelConfig(
+    argv,
+    providerID,
+    modelID
+  );
+
   // Handle --use-existing-claude-oauth option
   // This reads OAuth credentials from ~/.claude/.credentials.json (Claude Code CLI)
   // For new authentication, use: agent auth login (select Anthropic > Claude Pro/Max)
@@ -144,5 +160,73 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     }
   }
 
-  return { providerID, modelID };
+  return { providerID, modelID, compactionModel: compactionModelResult };
+}
+
+/**
+ * Parse compaction model config from argv.
+ * Resolves --compaction-model and --compaction-safety-margin CLI arguments.
+ * The special value "same" means use the base model for compaction.
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+async function parseCompactionModelConfig(argv, baseProviderID, baseModelID) {
+  // Get compaction model from CLI (safeguard against yargs caching)
+  const cliCompactionModelArg = getCompactionModelFromProcessArgv();
+  const compactionModelArg =
+    cliCompactionModelArg ??
+    argv['compaction-model'] ??
+    DEFAULT_COMPACTION_MODEL;
+
+  // Get safety margin from CLI
+  const cliSafetyMarginArg = getCompactionSafetyMarginFromProcessArgv();
+  const compactionSafetyMarginPercent = cliSafetyMarginArg
+    ? parseInt(cliSafetyMarginArg, 10)
+    : (argv['compaction-safety-margin'] ??
+      DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT);
+
+  // Special "same" alias — use the base model for compaction
+  const useSameModel = compactionModelArg.toLowerCase() === 'same';
+
+  let compactionProviderID;
+  let compactionModelID;
+
+  if (useSameModel) {
+    compactionProviderID = baseProviderID;
+    compactionModelID = baseModelID;
+    Log.Default.info(() => ({
+      message:
+        'compaction model set to "same" — using base model for compaction',
+      compactionProviderID,
+      compactionModelID,
+    }));
+  } else if (compactionModelArg.includes('/')) {
+    const parts = compactionModelArg.split('/');
+    compactionProviderID = parts[0];
+    compactionModelID = parts.slice(1).join('/');
+    Log.Default.info(() => ({
+      message: 'using explicit compaction model',
+      compactionProviderID,
+      compactionModelID,
+    }));
+  } else {
+    // Short name resolution
+    const { Provider } = await import('../provider/provider.ts');
+    const resolved =
+      await Provider.parseModelWithResolution(compactionModelArg);
+    compactionProviderID = resolved.providerID;
+    compactionModelID = resolved.modelID;
+    Log.Default.info(() => ({
+      message: 'resolved short compaction model name',
+      input: compactionModelArg,
+      compactionProviderID,
+      compactionModelID,
+    }));
+  }
+
+  return {
+    providerID: compactionProviderID,
+    modelID: compactionModelID,
+    useSameModel,
+    compactionSafetyMarginPercent,
+  };
 }

package/src/cli/run-options.js

@@ -0,0 +1,163 @@
+import {
+  DEFAULT_MODEL,
+  DEFAULT_COMPACTION_MODEL,
+  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+} from './defaults.ts';
+
+/**
+ * Yargs builder for the default `run` command options.
+ * Extracted from index.js to keep file size under 1000 lines.
+ */
+export function buildRunOptions(yargs) {
+  return yargs
+    .option('model', {
+      type: 'string',
+      description: 'Model to use in format providerID/modelID',
+      default: DEFAULT_MODEL,
+    })
+    .option('json-standard', {
+      type: 'string',
+      description:
+        'JSON output format standard: "opencode" (default) or "claude" (experimental)',
+      default: 'opencode',
+      choices: ['opencode', 'claude'],
+    })
+    .option('system-message', {
+      type: 'string',
+      description: 'Full override of the system message',
+    })
+    .option('system-message-file', {
+      type: 'string',
+      description: 'Full override of the system message from file',
+    })
+    .option('append-system-message', {
+      type: 'string',
+      description: 'Append to the default system message',
+    })
+    .option('append-system-message-file', {
+      type: 'string',
+      description: 'Append to the default system message from file',
+    })
+    .option('server', {
+      type: 'boolean',
+      description: 'Run in server mode (default)',
+      default: true,
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description:
+        'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
+      default: false,
+    })
+    .option('dry-run', {
+      type: 'boolean',
+      description:
+        'Simulate operations without making actual API calls or package installations (useful for testing)',
+      default: false,
+    })
+    .option('use-existing-claude-oauth', {
+      type: 'boolean',
+      description:
+        'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
+      default: false,
+    })
+    .option('prompt', {
+      alias: 'p',
+      type: 'string',
+      description: 'Prompt message to send directly (bypasses stdin reading)',
+    })
+    .option('disable-stdin', {
+      type: 'boolean',
+      description:
+        'Disable stdin streaming mode (requires --prompt or shows help)',
+      default: false,
+    })
+    .option('stdin-stream-timeout', {
+      type: 'number',
+      description:
+        'Optional timeout in milliseconds for stdin reading (default: no timeout)',
+    })
+    .option('auto-merge-queued-messages', {
+      type: 'boolean',
+      description:
+        'Enable auto-merging of rapidly arriving input lines into single messages (default: true)',
+      default: true,
+    })
+    .option('interactive', {
+      type: 'boolean',
+      description:
+        'Enable interactive mode to accept manual input as plain text strings (default: true). Use --no-interactive to only accept JSON input.',
+      default: true,
+    })
+    .option('always-accept-stdin', {
+      type: 'boolean',
+      description:
+        'Keep accepting stdin input even after the agent finishes work (default: true). Use --no-always-accept-stdin for single-message mode.',
+      default: true,
+    })
+    .option('compact-json', {
+      type: 'boolean',
+      description:
+        'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
+      default: false,
+    })
+    .option('resume', {
+      alias: 'r',
+      type: 'string',
+      description:
+        'Resume a specific session by ID. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+    })
+    .option('continue', {
+      alias: 'c',
+      type: 'boolean',
+      description:
+        'Continue the most recent session. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+      default: false,
+    })
+    .option('no-fork', {
+      type: 'boolean',
+      description:
+        'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
+      default: false,
+    })
+    .option('generate-title', {
+      type: 'boolean',
+      description:
+        'Generate session titles using AI (default: false). Disabling saves tokens and prevents rate limit issues.',
+      default: false,
+    })
+    .option('retry-timeout', {
+      type: 'number',
+      description:
+        'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
+    })
+    .option('retry-on-rate-limits', {
+      type: 'boolean',
+      description:
+        'Retry AI completions API requests when rate limited (HTTP 429). Use --no-retry-on-rate-limits in integration tests to fail fast instead of waiting.',
+      default: true,
+    })
+    .option('output-response-model', {
+      type: 'boolean',
+      description: 'Include model info in step_finish output',
+      default: true,
+    })
+    .option('summarize-session', {
+      type: 'boolean',
+      description:
+        'Generate AI session summaries (default: true). Use --no-summarize-session to disable.',
+      default: true,
+    })
+    .option('compaction-model', {
+      type: 'string',
+      description:
+        'Model to use for context compaction in format providerID/modelID. Use "same" to use the base model. Default: opencode/gpt-5-nano (free, 400K context).',
+      default: DEFAULT_COMPACTION_MODEL,
+    })
+    .option('compaction-safety-margin', {
+      type: 'number',
+      description:
+        'Safety margin (%) of usable context window before triggering compaction. Only applies when the compaction model has equal or smaller context than the base model. Default: 15.',
+      default: DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+    });
+}

package/src/index.js

@@ -6,7 +6,7 @@ import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
 import { Log } from './util/log.ts';
 import { parseModelConfig } from './cli/model-config.js';
-import { DEFAULT_MODEL } from './cli/defaults.ts';
+import { buildRunOptions } from './cli/run-options.js';
 // Bus is used via createBusEventSubscription in event-handler.js
 import { Session } from './session/index.ts';
 import { SessionPrompt } from './session/prompt.ts';
@@ -278,7 +278,7 @@ async function runAgentMode(argv, request) {
     fn: async () => {
       // Parse model config inside Instance.provide context
       // This allows parseModelWithResolution to access the provider state
-      const { providerID, modelID } = await parseModelConfig(
+      const { providerID, modelID, compactionModel } = await parseModelConfig(
         argv,
         outputError,
         outputStatus
@@ -293,7 +293,8 @@ async function runAgentMode(argv, request) {
           modelID,
           systemMessage,
           appendSystemMessage,
-          jsonStandard
+          jsonStandard,
+          compactionModel
         );
       } else {
         // DIRECT MODE: Run everything in single process
@@ -304,7 +305,8 @@ async function runAgentMode(argv, request) {
           modelID,
           systemMessage,
           appendSystemMessage,
-          jsonStandard
+          jsonStandard,
+          compactionModel
         );
       }
     },
@@ -363,7 +365,7 @@ async function runContinuousAgentMode(argv) {
     fn: async () => {
       // Parse model config inside Instance.provide context
       // This allows parseModelWithResolution to access the provider state
-      const { providerID, modelID } = await parseModelConfig(
+      const { providerID, modelID, compactionModel } = await parseModelConfig(
         argv,
         outputError,
         outputStatus
@@ -377,7 +379,8 @@ async function runContinuousAgentMode(argv) {
           modelID,
           systemMessage,
           appendSystemMessage,
-          jsonStandard
+          jsonStandard,
+          compactionModel
         );
       } else {
         // DIRECT MODE: Run everything in single process
@@ -387,7 +390,8 @@ async function runContinuousAgentMode(argv) {
           modelID,
           systemMessage,
           appendSystemMessage,
-          jsonStandard
+          jsonStandard,
+          compactionModel
         );
       }
     },
@@ -409,7 +413,8 @@ async function runServerMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   const compactJson = argv['compact-json'] === true;
 
@@ -475,6 +480,7 @@ async function runServerMode(
             providerID,
             modelID,
           },
+          compactionModel,
           system: systemMessage,
           appendSystem: appendSystemMessage,
         }),
@@ -508,7 +514,8 @@ async function runDirectMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   const compactJson = argv['compact-json'] === true;
 
@@ -558,6 +565,7 @@ async function runDirectMode(
         providerID,
         modelID,
       },
+      compactionModel,
       system: systemMessage,
       appendSystem: appendSystemMessage,
     }).catch((error) => {
@@ -596,147 +604,7 @@ async function main() {
       .command({
         command: '$0',
         describe: 'Run agent in interactive or stdin mode (default)',
-        builder: (yargs) =>
-          yargs
-            .option('model', {
-              type: 'string',
-              description: 'Model to use in format providerID/modelID',
-              default: DEFAULT_MODEL,
-            })
-            .option('json-standard', {
-              type: 'string',
-              description:
-                'JSON output format standard: "opencode" (default) or "claude" (experimental)',
-              default: 'opencode',
-              choices: ['opencode', 'claude'],
-            })
-            .option('system-message', {
-              type: 'string',
-              description: 'Full override of the system message',
-            })
-            .option('system-message-file', {
-              type: 'string',
-              description: 'Full override of the system message from file',
-            })
-            .option('append-system-message', {
-              type: 'string',
-              description: 'Append to the default system message',
-            })
-            .option('append-system-message-file', {
-              type: 'string',
-              description: 'Append to the default system message from file',
-            })
-            .option('server', {
-              type: 'boolean',
-              description: 'Run in server mode (default)',
-              default: true,
-            })
-            .option('verbose', {
-              type: 'boolean',
-              description:
-                'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
-              default: false,
-            })
-            .option('dry-run', {
-              type: 'boolean',
-              description:
-                'Simulate operations without making actual API calls or package installations (useful for testing)',
-              default: false,
-            })
-            .option('use-existing-claude-oauth', {
-              type: 'boolean',
-              description:
-                'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
-              default: false,
-            })
-            .option('prompt', {
-              alias: 'p',
-              type: 'string',
-              description:
-                'Prompt message to send directly (bypasses stdin reading)',
-            })
-            .option('disable-stdin', {
-              type: 'boolean',
-              description:
-                'Disable stdin streaming mode (requires --prompt or shows help)',
-              default: false,
-            })
-            .option('stdin-stream-timeout', {
-              type: 'number',
-              description:
-                'Optional timeout in milliseconds for stdin reading (default: no timeout)',
-            })
-            .option('auto-merge-queued-messages', {
-              type: 'boolean',
-              description:
-                'Enable auto-merging of rapidly arriving input lines into single messages (default: true)',
-              default: true,
-            })
-            .option('interactive', {
-              type: 'boolean',
-              description:
-                'Enable interactive mode to accept manual input as plain text strings (default: true). Use --no-interactive to only accept JSON input.',
-              default: true,
-            })
-            .option('always-accept-stdin', {
-              type: 'boolean',
-              description:
-                'Keep accepting stdin input even after the agent finishes work (default: true). Use --no-always-accept-stdin for single-message mode.',
-              default: true,
-            })
-            .option('compact-json', {
-              type: 'boolean',
-              description:
-                'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
-              default: false,
-            })
-            .option('resume', {
-              alias: 'r',
-              type: 'string',
-              description:
-                'Resume a specific session by ID. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
-            })
-            .option('continue', {
-              alias: 'c',
-              type: 'boolean',
-              description:
-                'Continue the most recent session. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
-              default: false,
-            })
-            .option('no-fork', {
-              type: 'boolean',
-              description:
-                'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
-              default: false,
-            })
-            .option('generate-title', {
-              type: 'boolean',
-              description:
-                'Generate session titles using AI (default: false). Disabling saves tokens and prevents rate limit issues.',
-              default: false,
-            })
-            .option('retry-timeout', {
-              type: 'number',
-              description:
-                'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
-            })
-            .option('retry-on-rate-limits', {
-              type: 'boolean',
-              description:
-                'Retry AI completions API requests when rate limited (HTTP 429). Use --no-retry-on-rate-limits in integration tests to fail fast instead of waiting.',
-              default: true,
-            })
-            .option('output-response-model', {
-              type: 'boolean',
-              description: 'Include model info in step_finish output',
-              default: true,
-            })
-            .option('summarize-session', {
-              type: 'boolean',
-              description:
-                'Generate AI session summaries (default: true). Use --no-summarize-session to disable.',
-              default: true,
-            }),
+        builder: buildRunOptions,
         handler: async (argv) => {
           // Check both CLI flag and environment variable for compact JSON mode
           const compactJson =
@@ -934,8 +802,14 @@ async function main() {
           compactJson: isCompact,
         });
 
-        // Monkey-patch globalThis.fetch for raw HTTP logging in --verbose mode.
-        // Catches ALL HTTP calls regardless of AI SDK fetch passthrough. (#217)
+        // 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',

package/src/provider/provider.ts

@@ -1201,11 +1201,13 @@ export namespace Provider {
         sessionID: provider.id,
       });
 
-      // Verbose HTTP logging is handled by the global fetch monkey-patch
-      // (installed in CLI middleware in index.js). The global patch catches ALL
-      // HTTP calls reliably, regardless of how the AI SDK passes fetch internally.
-      // This provider-level wrapper is kept as a fallback for environments where
-      // the global patch may not be installed (e.g., programmatic use).
+      // Verbose HTTP logging for provider API calls.
+      // This provider-level wrapper logs HTTP requests/responses independently
+      // of the global fetch monkey-patch. Both mechanisms are kept active to
+      // maximize HTTP observability — the global patch may miss calls if the
+      // AI SDK captures/resolves fetch references before it is installed,
+      // while this wrapper is injected directly into the SDK's fetch option.
+      // See: https://github.com/link-assistant/agent/issues/221
       // See: https://github.com/link-assistant/agent/issues/217
       // See: https://github.com/link-assistant/agent/issues/215
       {
@@ -1226,14 +1228,9 @@ export namespace Provider {
           init?: RequestInit
         ): Promise<Response> => {
           // Check verbose flag at call time — not at SDK creation time.
-          // When the global fetch monkey-patch is installed, it handles verbose
-          // logging for all calls. The provider wrapper is a fallback for
-          // environments without the global patch.
-          // See: https://github.com/link-assistant/agent/issues/217
-          if (
-            !Flag.OPENCODE_VERBOSE ||
-            globalThis.__agentVerboseFetchInstalled
-          ) {
+          // This ensures --verbose works even when the flag is set after SDK creation.
+          // See: https://github.com/link-assistant/agent/issues/206
+          if (!Flag.OPENCODE_VERBOSE) {
             return innerFetch(input, init);
           }
 

package/src/session/compaction.ts

@@ -29,36 +29,101 @@ export namespace SessionCompaction {
   };
 
   /**
-   * Safety margin ratio for compaction trigger.
+   * Default safety margin ratio for compaction trigger.
    * We trigger compaction at 85% of usable context to avoid hitting hard limits.
    * This means we stop 15% before (context - output) tokens.
    * @see https://github.com/link-assistant/agent/issues/217
    */
   export const OVERFLOW_SAFETY_MARGIN = 0.85;
 
+  /**
+   * Compaction model configuration passed from CLI.
+   * @see https://github.com/link-assistant/agent/issues/219
+   */
+  export interface CompactionModelConfig {
+    providerID: string;
+    modelID: string;
+    useSameModel: boolean;
+    compactionSafetyMarginPercent: number;
+  }
+
+  /**
+   * Compute the effective safety margin ratio.
+   *
+   * When the compaction model has a larger context window than the base model,
+   * the entire base model context can be used (ratio = 1.0, i.e. 0% margin),
+   * because the compaction model can ingest all of it.
+   *
+   * When the compaction model has equal or smaller context, the configured
+   * safety margin applies (default 15% → ratio 0.85).
+   *
+   * @see https://github.com/link-assistant/agent/issues/219
+   */
+  export function computeSafetyMarginRatio(input: {
+    baseModelContextLimit: number;
+    compactionModel?: CompactionModelConfig;
+    compactionModelContextLimit?: number;
+  }): number {
+    const compactionModelConfig = input.compactionModel;
+    if (!compactionModelConfig) return OVERFLOW_SAFETY_MARGIN;
+
+    const compactionSafetyMarginPercent =
+      compactionModelConfig.compactionSafetyMarginPercent;
+    const configuredRatio = 1 - compactionSafetyMarginPercent / 100;
+
+    // When using the same model, always apply the configured safety margin
+    if (compactionModelConfig.useSameModel) return configuredRatio;
+
+    // When compaction model has a larger context, no safety margin needed
+    const compactionContextLimit = input.compactionModelContextLimit ?? 0;
+    if (
+      compactionContextLimit > 0 &&
+      compactionContextLimit > input.baseModelContextLimit
+    ) {
+      log.info(() => ({
+        message:
+          'compaction model has larger context — using full base model context',
+        baseModelContextLimit: input.baseModelContextLimit,
+        compactionModelContextLimit: compactionContextLimit,
+      }));
+      return 1.0;
+    }
+
+    return configuredRatio;
+  }
+
   export function isOverflow(input: {
     tokens: MessageV2.Assistant['tokens'];
     model: ModelsDev.Model;
+    compactionModel?: CompactionModelConfig;
+    compactionModelContextLimit?: number;
   }) {
     if (Flag.OPENCODE_DISABLE_AUTOCOMPACT) return false;
-    const context = input.model.limit.context;
-    if (context === 0) return false;
+    const baseModelContextLimit = input.model.limit.context;
+    if (baseModelContextLimit === 0) return false;
     const count =
       input.tokens.input + input.tokens.cache.read + input.tokens.output;
-    const output =
+    const outputTokenLimit =
       Math.min(input.model.limit.output, SessionPrompt.OUTPUT_TOKEN_MAX) ||
       SessionPrompt.OUTPUT_TOKEN_MAX;
-    const usable = context - output;
-    const safeLimit = Math.floor(usable * OVERFLOW_SAFETY_MARGIN);
+    const usableContextWindow = baseModelContextLimit - outputTokenLimit;
+    const safetyMarginRatio = computeSafetyMarginRatio({
+      baseModelContextLimit,
+      compactionModel: input.compactionModel,
+      compactionModelContextLimit: input.compactionModelContextLimit,
+    });
+    const safeLimit = Math.floor(usableContextWindow * safetyMarginRatio);
     const overflow = count > safeLimit;
     log.info(() => ({
       message: 'overflow check',
       modelID: input.model.id,
-      contextLimit: context,
-      outputLimit: output,
-      usableContext: usable,
+      contextLimit: baseModelContextLimit,
+      outputLimit: outputTokenLimit,
+      usableContextWindow,
       safeLimit,
-      safetyMargin: OVERFLOW_SAFETY_MARGIN,
+      safetyMarginRatio,
+      compactionModelID: input.compactionModel?.modelID,
+      compactionModelContextLimit: input.compactionModelContextLimit,
       currentTokens: count,
       tokensBreakdown: {
         input: input.tokens.input,
@@ -79,6 +144,8 @@ export namespace SessionCompaction {
   export function contextDiagnostics(input: {
     tokens: { input: number; output: number; cache: { read: number } };
     model: ModelsDev.Model;
+    compactionModel?: CompactionModelConfig;
+    compactionModelContextLimit?: number;
   }): MessageV2.ContextDiagnostics | undefined {
     const contextLimit = input.model.limit.context;
     if (contextLimit === 0) return undefined;
@@ -86,7 +153,12 @@ export namespace SessionCompaction {
       Math.min(input.model.limit.output, SessionPrompt.OUTPUT_TOKEN_MAX) ||
       SessionPrompt.OUTPUT_TOKEN_MAX;
     const usableContext = contextLimit - outputLimit;
-    const safeLimit = Math.floor(usableContext * OVERFLOW_SAFETY_MARGIN);
+    const safetyMarginRatio = computeSafetyMarginRatio({
+      baseModelContextLimit: contextLimit,
+      compactionModel: input.compactionModel,
+      compactionModelContextLimit: input.compactionModelContextLimit,
+    });
+    const safeLimit = Math.floor(usableContext * safetyMarginRatio);
     const currentTokens =
       input.tokens.input + input.tokens.cache.read + input.tokens.output;
     return {
@@ -94,7 +166,7 @@ export namespace SessionCompaction {
       outputLimit,
       usableContext,
       safeLimit,
-      safetyMargin: OVERFLOW_SAFETY_MARGIN,
+      safetyMargin: safetyMarginRatio,
       currentTokens,
       headroom: safeLimit - currentTokens,
       overflow: currentTokens > safeLimit,

package/src/session/message-v2.ts

@@ -392,6 +392,14 @@ export namespace MessageV2 {
       providerID: z.string(),
       modelID: z.string(),
     }),
+    compactionModel: z
+      .object({
+        providerID: z.string(),
+        modelID: z.string(),
+        useSameModel: z.boolean(),
+        compactionSafetyMarginPercent: z.number(),
+      })
+      .optional(),
     system: z.string().optional(),
     appendSystem: z.string().optional(),
     tools: z.record(z.string(), z.boolean()).optional(),

package/src/session/prompt.ts

@@ -89,6 +89,14 @@ export namespace SessionPrompt {
         modelID: z.string(),
       })
       .optional(),
+    compactionModel: z
+      .object({
+        providerID: z.string(),
+        modelID: z.string(),
+        useSameModel: z.boolean(),
+        compactionSafetyMarginPercent: z.number(),
+      })
+      .optional(),
     agent: z.string().optional(),
     noReply: z.boolean().optional(),
     system: z.string().optional(),
@@ -396,6 +404,28 @@ export namespace SessionPrompt {
         // Re-throw the error so it can be handled by the caller
         throw error;
       }
+      // Resolve compaction model context limit for overflow detection (#219)
+      let compactionModelContextLimit: number | undefined;
+      const compactionModelConfig = lastUser.compactionModel;
+      if (compactionModelConfig && !compactionModelConfig.useSameModel) {
+        try {
+          const compactionModelResolved = await Provider.getModel(
+            compactionModelConfig.providerID,
+            compactionModelConfig.modelID
+          );
+          compactionModelContextLimit =
+            compactionModelResolved.info?.limit?.context;
+        } catch {
+          // If compaction model can't be resolved, fall back to default safety margin
+          log.info(() => ({
+            message:
+              'could not resolve compaction model for context limit — using default safety margin',
+            compactionProviderID: compactionModelConfig.providerID,
+            compactionModelID: compactionModelConfig.modelID,
+          }));
+        }
+      }
+
       const task = tasks.pop();
 
       // pending subtask
@@ -512,13 +542,23 @@ export namespace SessionPrompt {
 
       // pending compaction
       if (task?.type === 'compaction') {
+        // Use compaction model if configured, otherwise fall back to base model
+        const compactionModelConfig = lastUser.compactionModel;
+        const compactionProviderID =
+          compactionModelConfig && !compactionModelConfig.useSameModel
+            ? compactionModelConfig.providerID
+            : model.providerID;
+        const compactionModelID =
+          compactionModelConfig && !compactionModelConfig.useSameModel
+            ? compactionModelConfig.modelID
+            : model.modelID;
         const result = await SessionCompaction.process({
           messages: msgs,
           parentID: lastUser.id,
           abort,
           model: {
-            providerID: model.providerID,
-            modelID: model.modelID,
+            providerID: compactionProviderID,
+            modelID: compactionModelID,
           },
           sessionID,
         });
@@ -533,6 +573,8 @@ export namespace SessionPrompt {
         SessionCompaction.isOverflow({
           tokens: lastFinished.tokens,
           model: model.info ?? { id: model.modelID },
+          compactionModel: lastUser.compactionModel,
+          compactionModelContextLimit,
         })
       ) {
         await SessionCompaction.create({
@@ -1053,6 +1095,7 @@ export namespace SessionPrompt {
         model: input.model,
         agent,
       }),
+      compactionModel: input.compactionModel,
     };
 
     const parts = await Promise.all(