@link-assistant/hive-mind 1.57.3 → 1.58.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @link-assistant/hive-mind
 
+## 1.58.0
+
+### Minor Changes
+
+- 3616130: Add `--sub-session-size` and `--disable-1m-context` options for Claude and Codex (issue #1706)
+
+  `--sub-session-size` (default: `150k`) caps the size of each sub-session
+  between auto-compaction events. It accepts a token count (`150k`, `1m`,
+  `200000`), a percentage of the model context window (`50%`), or `default`
+  to keep the tool's built-in threshold.
+
+  `--disable-1m-context` (default: `true`) opts out of the 1M extended
+  context window so models stay on their standard 200K-400K window. This
+  preserves reasoning quality and avoids the long-context price tier.
+  Use `--no-disable-1m-context` to allow 1M.
+
+  Both options work for `--tool claude` and `--tool codex`. For Claude Code
+  the wrapper sets `CLAUDE_CODE_DISABLE_1M_CONTEXT`,
+  `CLAUDE_CODE_AUTO_COMPACT_WINDOW`, and `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`
+  env vars (clamped per upstream's "lower-only" semantics). For Codex the
+  wrapper appends `-c model_context_window=200000` and
+  `-c model_auto_compact_token_limit=<tokens>` overrides.
+
+  Verbose mode logs the applied env vars and `-c` overrides so operators
+  can confirm they reached the spawned tool process.
+
+- b341775: Hide the cost-estimation breakdown when the public and Anthropic numbers agree to within display precision (issue #1703)
+
+  Both the live `displayCostComparison` console output and the
+  `buildCostInfoString` markdown rendered into PR/issue comments previously
+  collapsed to the short `💰 Cost: $X.XXXXXX` form only when the two values
+  matched **exactly** at six decimal places. Real-world calls regularly produce
+  underlying values that differ by ~`1e-7` and round to **adjacent** displays
+  (e.g. `$11.219694` vs `$11.219693`); the rendered difference (`$-0.000000
+(-0.00%)`) was therefore noise yet still printed three full lines. The guard
+  now triggers whenever `|public − anthropic|.toFixed(6) === '0.000000'`, which
+  preserves the existing behaviour at every meaningful (≥ `$0.000001`) delta and
+  adds short-form output for the boundary case from issue #1703. Regression
+  tests live in `tests/test-build-cost-info-string.mjs` and
+  `tests/test-display-cost-comparison.mjs`.
+
 ## 1.57.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.57.3",
+  "version": "1.58.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.budget-stats.lib.mjs

@@ -129,7 +129,9 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
   const hasAnthropic = anthropicCost !== null && anthropicCost !== undefined;
   const publicDec = hasPublic ? new Decimal(publicCost) : null;
   const anthropicDec = hasAnthropic ? new Decimal(anthropicCost) : null;
-  if (publicDec && anthropicDec && publicDec.toFixed(6) === anthropicDec.toFixed(6)) {
+  // Issue #1703: also collapse to the short form when the rounded difference is below display precision,
+  // so reports like "Difference: $-0.000000 (-0.00%)" no longer waste two extra lines.
+  if (publicDec && anthropicDec && anthropicDec.minus(publicDec).abs().toFixed(6) === '0.000000') {
     await log(`\n   💰 Cost: $${anthropicDec.toFixed(6)}`);
     return;
   }

package/src/claude.lib.mjs

@@ -25,6 +25,7 @@ import { resolveClaudeSessionToolFlags } from './useless-tools.lib.mjs';
 import { ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
 import { fetchModelInfo } from './model-info.lib.mjs';
 import { classifyRetryableError, maybeSwitchToFallbackModel } from './tool-retry.lib.mjs';
+import { resolveSubSessionSize } from './sub-session-size.lib.mjs'; // Issue #1706
 export { availableModels }; // Re-export for backward compatibility
 export { fetchModelInfo };
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
@@ -761,9 +762,10 @@ export const executeClaudeCommand = async params => {
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      // Issue #817: Streaming mode sets exitAfterStopDelayMs=60000 so the
-      // headless Claude process stays alive between NDJSON turns.
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined });
+      // Issue #1706: --sub-session-size + --disable-1m-context. Resolve here, then pass into getClaudeEnv along with the rest.
+      const { parsed: parsedSubSessionSize, contextWindowTokens } = await resolveSubSessionSize({ rawValue: argv.subSessionSize, tool: 'claude', modelId: effectiveModel, fetchModelInfo, log });
+      // Issue #817: streaming mode sets exitAfterStopDelayMs=60000 so the headless Claude process stays alive between NDJSON turns.
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined, disable1mContext: !!argv.disable1mContext, subSessionSize: parsedSubSessionSize, contextWindowTokens });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
       const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
@@ -772,6 +774,9 @@ export const executeClaudeCommand = async params => {
         if (resolvedThinkingBudget !== undefined) await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
         if (claudeEnv.CLAUDE_CODE_EFFORT_LEVEL) await log(`📊 CLAUDE_CODE_EFFORT_LEVEL: ${claudeEnv.CLAUDE_CODE_EFFORT_LEVEL}`, { verbose: true });
         if (claudeEnv.CLAUDE_CODE_SHOW_THINKING) await log(`📊 CLAUDE_CODE_SHOW_THINKING: ${claudeEnv.CLAUDE_CODE_SHOW_THINKING}`, { verbose: true });
+        // Issue #1706: log applied env vars (--disable-1m-context, --sub-session-size).
+        const sub1706 = ['CLAUDE_CODE_DISABLE_1M_CONTEXT', 'CLAUDE_CODE_AUTO_COMPACT_WINDOW', 'CLAUDE_AUTOCOMPACT_PCT_OVERRIDE'].filter(k => claudeEnv[k]).map(k => `${k}=${claudeEnv[k]}`);
+        if (sub1706.length) await log(`📊 ${sub1706.join(', ')}`, { verbose: true });
         if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
       }
       const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');

package/src/codex.lib.mjs

@@ -25,6 +25,7 @@ import { getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs
 import { fetchModelInfo } from './model-info.lib.mjs';
 import { defaultModels } from './models/index.mjs';
 import { classifyRetryableError, getRetryDelayMs, maybeSwitchToFallbackModel, waitWithCountdown } from './tool-retry.lib.mjs';
+import { parseSubSessionSize, buildCodexSubSessionSizeConfigArgs, buildCodexDisable1mContextConfigArgs } from './sub-session-size.lib.mjs'; // Issue #1706
 import Decimal from 'decimal.js-light';
 
 const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
@@ -741,6 +742,36 @@ export const executeCodexCommand = async params => {
     }
     codexArgs += ` --json --skip-git-repo-check -o ${shellQuote(lastMessageFile)} -c ${shellQuote(`model_reasoning_effort=${reasoningEffort}`)} -c ${shellQuote('model_reasoning_summary=auto')} --dangerously-bypass-approvals-and-sandbox`;
 
+    // Issue #1706: Append --disable-1m-context and --sub-session-size as Codex -c overrides.
+    let parsedSubSessionSize;
+    try {
+      parsedSubSessionSize = parseSubSessionSize(argv.subSessionSize);
+    } catch (parseError) {
+      await log(`⚠️  ${parseError.message}`, { level: 'warn' });
+      parsedSubSessionSize = { kind: 'default', tokens: null, percent: null, raw: '' };
+    }
+    let codexContextWindowTokens = null;
+    if (parsedSubSessionSize.kind === 'percent') {
+      try {
+        const codexModelMeta = await fetchModelInfo(mappedModel, { preferredProviderIds: ['openai'] });
+        codexContextWindowTokens = codexModelMeta?.limit?.context || null;
+      } catch {
+        codexContextWindowTokens = null;
+      }
+    }
+    const disable1mArgs = buildCodexDisable1mContextConfigArgs(!!argv.disable1mContext);
+    for (const arg of disable1mArgs) {
+      codexArgs += ` ${shellQuote(arg)}`;
+    }
+    const subSessionSizeArgs = buildCodexSubSessionSizeConfigArgs(parsedSubSessionSize, { contextWindow: codexContextWindowTokens });
+    for (const arg of subSessionSizeArgs) {
+      codexArgs += ` ${shellQuote(arg)}`;
+    }
+    if (argv.verbose) {
+      if (disable1mArgs.length) await log(`📊 Codex --disable-1m-context: ${disable1mArgs.join(' ')}`, { verbose: true });
+      if (subSessionSizeArgs.length) await log(`📊 Codex --sub-session-size: ${subSessionSizeArgs.join(' ')}`, { verbose: true });
+    }
+
     const fullCommand = `(cd ${shellQuote(tempDir)} && cat ${shellQuote(promptFile)} | ${codexPath} ${codexArgs})`;
 
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);

package/src/config.lib.mjs

@@ -413,9 +413,12 @@ export const supportsThinkingBudget = (version, minVersion = '2.1.12') => {
 // Supports model-specific max output tokens for Opus 4.6 (Issue #1221)
 // Sets CLAUDE_CODE_EFFORT_LEVEL for Opus 4.6 models (Issue #1238)
 // Supports planModel/executionModel for opusplan mode (Issue #1223)
-// See: https://code.claude.com/docs/en/model-config
+// Issue #1706: supports subSessionSize (parsed) + disable1mContext to cap
+// auto-compaction sub-session size and opt out of the 1M extended context.
+// See: https://code.claude.com/docs/en/env-vars and https://code.claude.com/docs/en/model-config
 //   ANTHROPIC_DEFAULT_OPUS_MODEL  → model used in plan mode (and for 'opus' alias)
 //   ANTHROPIC_DEFAULT_SONNET_MODEL → model used in execution mode (and for 'sonnet' alias)
+//   CLAUDE_CODE_DISABLE_1M_CONTEXT, CLAUDE_CODE_AUTO_COMPACT_WINDOW, CLAUDE_AUTOCOMPACT_PCT_OVERRIDE
 export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
   const maxOutputTokens = options.model ? getMaxOutputTokensForModel(options.model) : claudeCode.maxOutputTokens;
@@ -483,6 +486,36 @@ export const getClaudeEnv = (options = {}) => {
     env.ANTHROPIC_DEFAULT_SONNET_MODEL = String(options.executionModel);
   }
 
+  // Issue #1706: --disable-1m-context. Sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1.
+  if (options.disable1mContext) {
+    env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+  }
+
+  // Issue #1706: --sub-session-size. Caller passes a pre-parsed descriptor and the
+  // model context window so we can convert percentages to absolute tokens.
+  if (options.subSessionSize && options.subSessionSize.kind && options.subSessionSize.kind !== 'default') {
+    const window = Number.isFinite(options.contextWindowTokens) && options.contextWindowTokens > 0 ? options.contextWindowTokens : null;
+    if (options.subSessionSize.kind === 'tokens') {
+      const tokens = options.subSessionSize.tokens;
+      if (Number.isFinite(tokens) && tokens > 0) {
+        env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(tokens);
+        // Compute percentage relative to the context window so the override stays
+        // within Claude Code's "lower-only" semantics. Default to 95 when unknown.
+        let pct = 95;
+        if (window) {
+          pct = Math.max(1, Math.min(95, Math.round((tokens / window) * 100)));
+        }
+        env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(pct);
+      }
+    } else if (options.subSessionSize.kind === 'percent') {
+      const pct = Math.max(1, Math.min(95, Math.round(options.subSessionSize.percent)));
+      env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(pct);
+      if (window) {
+        env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(window);
+      }
+    }
+  }
+
   return env;
 };
 

package/src/github-cost-info.lib.mjs

@@ -30,7 +30,10 @@ export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricing
   if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
   const publicDec = hasPublic ? new Decimal(totalCostUSD) : null;
   const anthropicDec = hasAnthropic ? new Decimal(anthropicTotalCostUSD) : null;
-  if (publicDec && anthropicDec && publicDec.toFixed(6) === anthropicDec.toFixed(6)) return `\n\n### 💰 Cost: **$${anthropicDec.toFixed(6)}**`;
+  // Issue #1703: collapse to short form when the rounded difference is below 6-decimal display precision.
+  // Without this, near-matching values like $11.219694 vs $11.219693 still printed the full breakdown
+  // even though "Difference: $-0.000000 (-0.00%)" carries no meaningful information.
+  if (publicDec && anthropicDec && anthropicDec.minus(publicDec).abs().toFixed(6) === '0.000000') return `\n\n### 💰 Cost: **$${anthropicDec.toFixed(6)}**`;
   let costInfo = '\n\n### 💰 **Cost estimation:**';
   if (pricingInfo?.modelName) {
     costInfo += `\n- Model: ${pricingInfo.modelName}`;

package/src/solve.config.lib.mjs

@@ -260,6 +260,16 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Maximum thinking budget for calculating --think level mappings (default: 31999 for Claude Code). Values: off=0, low=max/4, medium=max/2, high=max*3/4, max=max.',
     default: 31999,
   },
+  'sub-session-size': {
+    type: 'string',
+    description: 'Cap on sub-session size between auto-compaction events. Accepts a token count (e.g. 150k, 1m, 200000), a percentage of the model context window (e.g. 50%), or "default" to keep the tool\'s built-in threshold. Default: 150k. For Claude this maps to CLAUDE_CODE_AUTO_COMPACT_WINDOW + CLAUDE_AUTOCOMPACT_PCT_OVERRIDE env vars. For Codex this maps to -c model_auto_compact_token_limit. (Issue #1706)',
+    default: '150k',
+  },
+  'disable-1m-context': {
+    type: 'boolean',
+    description: 'Disable 1M extended context window so the model uses its standard 200K-400K window. Helps preserve reasoning quality and reduces cost. Default: true. For Claude this sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1 (also forbids the [1m] model-name suffix). For Codex this sets -c model_context_window=200000. Use --no-disable-1m-context to allow the 1M window. (Issue #1706)',
+    default: true,
+  },
   'fallback-model': {
     type: 'string',
     description: 'Fallback model to switch to on model capacity/overload errors. When supported, retries resume the same session with this model. Defaults: claude opus/opus-4-7 -> opus-4-6; codex gpt-5.5 -> gpt-5.4; all others unset.',

package/src/sub-session-size.lib.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * Sub-session size and 1M-context controls.
+ *
+ * Implements --sub-session-size and --disable-1m-context (issue #1706).
+ *
+ * --sub-session-size accepts:
+ *   - "default" / "auto"  → keep tool's built-in compaction threshold (no override)
+ *   - "off" / "0"         → keep tool's default (alias for "default")
+ *   - A token count       → "150k", "150K", "150000", "1.5m", "1M"
+ *   - A percentage        → "50%", "75%" (relative to model context window)
+ *
+ * --disable-1m-context (boolean, default true) opts out of the 1M extended
+ * context window so models fall back to their standard 200K-400K window.
+ *
+ * Claude Code controls (env vars only — no CLI flags exist):
+ *   - CLAUDE_CODE_DISABLE_1M_CONTEXT=1
+ *   - CLAUDE_CODE_AUTO_COMPACT_WINDOW=<tokens>     (basis for compaction math)
+ *   - CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=<1..100>     (only lowers; clamped to <= 95)
+ *
+ * Codex controls (via -c key=value, same mechanism as model_reasoning_effort):
+ *   - -c model_context_window=<tokens>             (forces 200K window)
+ *   - -c model_auto_compact_token_limit=<tokens>   (compaction threshold)
+ */
+
+const PARSE_ERROR_PREFIX = '--sub-session-size';
+
+const DEFAULT_TOKENS_VALUES = new Set(['default', 'auto', 'off', '0', 'none']);
+
+/**
+ * Parse a token count expression: "150k", "150K", "150000", "1.5m", "1M".
+ * Returns null if the input doesn't match the token-count format.
+ */
+const parseTokenCount = value => {
+  const match = String(value)
+    .trim()
+    .match(/^(\d+(?:\.\d+)?)\s*([kmKM]?)$/);
+  if (!match) return null;
+  const number = parseFloat(match[1]);
+  if (!Number.isFinite(number) || number < 0) return null;
+  const suffix = match[2].toLowerCase();
+  const multiplier = suffix === 'k' ? 1_000 : suffix === 'm' ? 1_000_000 : 1;
+  return Math.round(number * multiplier);
+};
+
+/**
+ * Parse a percentage expression: "50%", "75%".
+ * Returns null if the input doesn't match the percentage format.
+ */
+const parsePercent = value => {
+  const match = String(value)
+    .trim()
+    .match(/^(\d+(?:\.\d+)?)\s*%$/);
+  if (!match) return null;
+  const percent = parseFloat(match[1]);
+  if (!Number.isFinite(percent) || percent <= 0 || percent > 100) return null;
+  return percent;
+};
+
+/**
+ * Parse the --sub-session-size option value into a normalized descriptor.
+ *
+ * @param {string|undefined|null} rawValue - The raw option value.
+ * @param {Object} [options]
+ * @param {number|null} [options.contextWindow] - Model context window in tokens (used for percentage values).
+ * @returns {{ kind: 'default' | 'tokens' | 'percent', tokens: number | null, percent: number | null, raw: string }}
+ * @throws {Error} If the value cannot be parsed.
+ */
+export const parseSubSessionSize = (rawValue, { contextWindow = null } = {}) => {
+  if (rawValue === undefined || rawValue === null || rawValue === '') {
+    return { kind: 'default', tokens: null, percent: null, raw: '' };
+  }
+
+  const trimmed = String(rawValue).trim();
+  const lower = trimmed.toLowerCase();
+
+  if (DEFAULT_TOKENS_VALUES.has(lower)) {
+    return { kind: 'default', tokens: null, percent: null, raw: trimmed };
+  }
+
+  const percent = parsePercent(trimmed);
+  if (percent !== null) {
+    const tokens = Number.isFinite(contextWindow) && contextWindow > 0 ? Math.round((contextWindow * percent) / 100) : null;
+    return { kind: 'percent', percent, tokens, raw: trimmed };
+  }
+
+  const tokens = parseTokenCount(trimmed);
+  if (tokens !== null) {
+    return { kind: 'tokens', tokens, percent: null, raw: trimmed };
+  }
+
+  throw new Error(`${PARSE_ERROR_PREFIX}: invalid value "${rawValue}". Expected a token count (e.g. 150k, 1m), a percentage (e.g. 50%), or "default".`);
+};
+
+/**
+ * Apply --sub-session-size to a Claude Code env object.
+ *
+ * Claude Code uses CLAUDE_CODE_AUTO_COMPACT_WINDOW + CLAUDE_AUTOCOMPACT_PCT_OVERRIDE.
+ * The percentage override only *lowers* the default ~95% threshold (per upstream
+ * docs), so we clamp it at 95 to avoid silently being ignored.
+ *
+ * @param {Object} env - Mutable env object to update.
+ * @param {Object} parsed - Result of parseSubSessionSize.
+ * @param {Object} [options]
+ * @param {number|null} [options.contextWindow] - Model context window in tokens.
+ * @returns {{ applied: boolean, summary: string|null }}
+ */
+export const applySubSessionSizeToClaudeEnv = (env, parsed, { contextWindow = null } = {}) => {
+  if (!parsed || parsed.kind === 'default') {
+    return { applied: false, summary: null };
+  }
+
+  const window = Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : null;
+
+  if (parsed.kind === 'tokens') {
+    const tokens = parsed.tokens;
+    if (!Number.isFinite(tokens) || tokens <= 0) return { applied: false, summary: null };
+
+    // Use the tokens value as the compaction window basis and apply 100%.
+    // Capped to the model's actual window by Claude Code itself.
+    env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(tokens);
+    // Compute percentage relative to the model context window (if known) so the
+    // override stays within Claude Code's "lower-only" semantics. Default to 95.
+    let pct = 95;
+    if (window) {
+      pct = Math.max(1, Math.min(95, Math.round((tokens / window) * 100)));
+    }
+    env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(pct);
+    return {
+      applied: true,
+      summary: `CLAUDE_CODE_AUTO_COMPACT_WINDOW=${tokens}, CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=${pct}`,
+    };
+  }
+
+  if (parsed.kind === 'percent') {
+    const pct = Math.max(1, Math.min(95, Math.round(parsed.percent)));
+    env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = String(pct);
+    if (window) {
+      env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(window);
+    }
+    return {
+      applied: true,
+      summary: `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=${pct}${window ? `, CLAUDE_CODE_AUTO_COMPACT_WINDOW=${window}` : ''}`,
+    };
+  }
+
+  return { applied: false, summary: null };
+};
+
+/**
+ * Apply --disable-1m-context to a Claude Code env object.
+ * Sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1 when disabled is true.
+ */
+export const applyDisable1mContextToClaudeEnv = (env, disabled) => {
+  if (!disabled) return { applied: false };
+  env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+  return { applied: true };
+};
+
+/**
+ * Build Codex `-c` config args for --sub-session-size.
+ * Returns an array like ['-c', 'model_auto_compact_token_limit=150000'] or [].
+ */
+export const buildCodexSubSessionSizeConfigArgs = (parsed, { contextWindow = null } = {}) => {
+  if (!parsed || parsed.kind === 'default') return [];
+
+  let tokens = null;
+  if (parsed.kind === 'tokens') {
+    tokens = parsed.tokens;
+  } else if (parsed.kind === 'percent') {
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0) return [];
+    tokens = Math.round((contextWindow * parsed.percent) / 100);
+  }
+
+  if (!Number.isFinite(tokens) || tokens <= 0) return [];
+  return ['-c', `model_auto_compact_token_limit=${tokens}`];
+};
+
+/**
+ * Build Codex `-c` config args for --disable-1m-context.
+ *
+ * Codex doesn't have a 1M-specific opt-out flag, but setting
+ * `model_context_window=200000` forces the standard window.
+ *
+ * @param {boolean} disabled - True when --disable-1m-context is in effect.
+ * @param {Object} [options]
+ * @param {number} [options.fallbackTokens] - Tokens to set when disabling (default: 200_000).
+ * @returns {string[]} Codex `-c` args, possibly empty.
+ */
+export const buildCodexDisable1mContextConfigArgs = (disabled, { fallbackTokens = 200_000 } = {}) => {
+  if (!disabled) return [];
+  return ['-c', `model_context_window=${fallbackTokens}`];
+};
+
+/**
+ * Resolve --sub-session-size for a given tool, including fetching the model
+ * context window when a percentage is provided. Tolerates fetch failures.
+ *
+ * @param {Object} params
+ * @param {string|undefined|null} params.rawValue - The argv.subSessionSize value.
+ * @param {string} params.tool - 'claude' or 'codex'.
+ * @param {string} params.modelId - Model id (used for models.dev lookup when percent).
+ * @param {Function} [params.fetchModelInfo] - models.dev fetcher (injected for testability).
+ * @param {Function} [params.log] - log function (used for parse warnings).
+ * @returns {Promise<{ parsed: Object, contextWindowTokens: number|null }>}
+ */
+export const resolveSubSessionSize = async ({ rawValue, tool, modelId, fetchModelInfo, log }) => {
+  let parsed;
+  try {
+    parsed = parseSubSessionSize(rawValue);
+  } catch (parseError) {
+    if (log) await log(`⚠️  ${parseError.message}`, { level: 'warn' });
+    parsed = { kind: 'default', tokens: null, percent: null, raw: '' };
+  }
+
+  let contextWindowTokens = null;
+  if (parsed.kind === 'percent' && typeof fetchModelInfo === 'function') {
+    try {
+      const baseModelId = String(modelId || '').replace(/\[1m\]$/i, '');
+      const preferredProviderIds = tool === 'codex' ? ['openai'] : ['anthropic'];
+      const meta = await fetchModelInfo(baseModelId, { preferredProviderIds });
+      contextWindowTokens = meta?.limit?.context || null;
+    } catch {
+      contextWindowTokens = null;
+    }
+  }
+
+  return { parsed, contextWindowTokens };
+};
+
+export default {
+  parseSubSessionSize,
+  applySubSessionSizeToClaudeEnv,
+  applyDisable1mContextToClaudeEnv,
+  buildCodexSubSessionSizeConfigArgs,
+  buildCodexDisable1mContextConfigArgs,
+  resolveSubSessionSize,
+};