@link-assistant/hive-mind 1.52.0 → 1.53.0

package/src/claude.lib.mjs

@@ -13,10 +13,12 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import Decimal from 'decimal.js-light';
 import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison, mergeResultModelUsage, createSubAgentCallEntry, accumulateSubAgentUsage } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
+import { buildMcpConfigWithoutPlaywright } from './playwright-mcp.lib.mjs';
 export { availableModels }; // Re-export for backward compatibility
 const showResumeCommand = async (sessionId, tempDir, claudePath, model, log) => {
   if (!sessionId || !tempDir) return;
@@ -429,51 +431,48 @@ export const checkModelVisionCapability = async modelId => {
     return false;
   }
 };
-/** Calculate USD cost for a model's usage with detailed breakdown */
+/** Calculate USD cost for a model's usage with detailed breakdown (Issue #1600: uses Decimal for precision) */
 export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) => {
   if (!modelInfo || !modelInfo.cost) {
     return includeBreakdown ? { total: 0, breakdown: null } : 0;
   }
   const cost = modelInfo.cost;
+  const million = new Decimal(1000000);
   const breakdown = {
     input: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheWrite: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheRead: { tokens: 0, costPerMillion: 0, cost: 0 },
     output: { tokens: 0, costPerMillion: 0, cost: 0 },
   };
-  // Input tokens cost (per million tokens)
   if (usage.inputTokens && cost.input) {
     breakdown.input = {
       tokens: usage.inputTokens,
       costPerMillion: cost.input,
-      cost: (usage.inputTokens / 1000000) * cost.input,
+      cost: new Decimal(usage.inputTokens).div(million).mul(new Decimal(cost.input)).toNumber(),
     };
   }
-  // Cache creation tokens cost
   if (usage.cacheCreationTokens && cost.cache_write) {
     breakdown.cacheWrite = {
       tokens: usage.cacheCreationTokens,
       costPerMillion: cost.cache_write,
-      cost: (usage.cacheCreationTokens / 1000000) * cost.cache_write,
+      cost: new Decimal(usage.cacheCreationTokens).div(million).mul(new Decimal(cost.cache_write)).toNumber(),
     };
   }
-  // Cache read tokens cost
   if (usage.cacheReadTokens && cost.cache_read) {
     breakdown.cacheRead = {
       tokens: usage.cacheReadTokens,
       costPerMillion: cost.cache_read,
-      cost: (usage.cacheReadTokens / 1000000) * cost.cache_read,
+      cost: new Decimal(usage.cacheReadTokens).div(million).mul(new Decimal(cost.cache_read)).toNumber(),
     };
   }
-  // Output tokens cost
   if (usage.outputTokens && cost.output) {
     breakdown.output = {
       tokens: usage.outputTokens,
       costPerMillion: cost.output,
-      cost: (usage.outputTokens / 1000000) * cost.output,
+      cost: new Decimal(usage.outputTokens).div(million).mul(new Decimal(cost.output)).toNumber(),
     };
   }
-  const totalCost = breakdown.input.cost + breakdown.cacheWrite.cost + breakdown.cacheRead.cost + breakdown.output.cost;
+  const totalCost = new Decimal(breakdown.input.cost).plus(breakdown.cacheWrite.cost).plus(breakdown.cacheRead.cost).plus(breakdown.output.cost).toNumber();
   if (includeBreakdown) {
     return {
       total: totalCost,
@@ -619,7 +618,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
     let totalCacheCreationTokens = 0;
     let totalCacheReadTokens = 0;
     let totalOutputTokens = 0;
-    let totalCostUSD = 0;
+    let totalCostDecimal = new Decimal(0);
     let hasCostData = false;
     for (const usage of Object.values(modelUsage)) {
       totalInputTokens += usage.inputTokens;
@@ -627,7 +626,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       totalCacheReadTokens += usage.cacheReadTokens;
       totalOutputTokens += usage.outputTokens;
       if (usage.costUSD !== null) {
-        totalCostUSD += usage.costUSD;
+        totalCostDecimal = totalCostDecimal.plus(new Decimal(usage.costUSD));
         hasCostData = true;
       }
     }
@@ -642,7 +641,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       cacheReadTokens: totalCacheReadTokens,
       outputTokens: totalOutputTokens,
       totalTokens,
-      totalCostUSD: hasCostData ? totalCostUSD : null,
+      totalCostUSD: hasCostData ? totalCostDecimal.toNumber() : null,
       // Issue #1501: Peak context usage (max single-request fill) and dedup stats
       peakContextUsage: globalPeakContext,
       duplicateEntriesSkipped: duplicateCount,
@@ -774,6 +773,14 @@ export const executeClaudeCommand = async params => {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
     }
+    let mcpConfigPath = null;
+    if (argv.playwrightMcp === false) {
+      mcpConfigPath = await buildMcpConfigWithoutPlaywright(log);
+      if (mcpConfigPath) {
+        claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
+        await log('🎭 Playwright MCP physically disabled for this session via --strict-mcp-config', { verbose: true });
+      }
+    }
     claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
     const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
@@ -797,11 +804,12 @@ export const executeClaudeCommand = async params => {
         if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
       }
       const simpleEscapedSystem = systemPrompt.replace(/"/g, '\\"');
+      const mcpDisableArgs = mcpConfigPath ? ['--strict-mcp-config', '--mcp-config', mcpConfigPath] : [];
       if (argv.resume) {
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
-        execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
-        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} --append-system-prompt "${simpleEscapedSystem}"`;
+        execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));

package/src/claude.prompts.lib.mjs

@@ -268,6 +268,7 @@ GitHub CLI command patterns.
 Playwright MCP usage (browser automation via mcp__playwright__* tools).
    - When you develop frontend web applications (HTML, CSS, JavaScript, React, Vue, Angular, etc.), use Playwright MCP tools to test the UI in a real browser.
    - When WebFetch tool fails to retrieve expected content (e.g., returns empty content, JavaScript-rendered pages, or login-protected pages), use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for web browsing.
+   - When WebSearch tool fails or returns insufficient results, use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for internet search.
    - When you need to interact with dynamic web pages that require JavaScript execution, use Playwright MCP tools.
    - When you need to visually verify how a web page looks or take screenshots, use browser_take_screenshot from Playwright MCP.
    - When you need to fill forms, click buttons, or perform user interactions on web pages, use Playwright MCP tools (browser_click, browser_type, browser_fill_form).

package/src/codex.lib.mjs

@@ -21,8 +21,9 @@ import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
+import { getCodexPlaywrightMcpDisableConfigArgs } from './playwright-mcp.lib.mjs';
 
-const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens'];
+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'];
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['model', data => data?.model],
@@ -32,6 +33,40 @@ const CODEX_MODEL_DIAGNOSTIC_PATHS = [
   ['message.model', data => data?.message?.model],
 ];
 
+const createCodexTokenFieldAvailability = () => ({
+  inputTokens: false,
+  outputTokens: false,
+  reasoningTokens: false,
+  cacheReadTokens: false,
+  cacheWriteTokens: false,
+});
+
+const hasOwnPath = (object, pathName) => {
+  let cursor = object;
+  for (const part of pathName.split('.')) {
+    if (!cursor || typeof cursor !== 'object' || !Object.hasOwn(cursor, part)) return false;
+    cursor = cursor[part];
+  }
+  return true;
+};
+
+const getPathValue = (object, pathName) => pathName.split('.').reduce((cursor, part) => cursor?.[part], object);
+
+const getFirstObservedNumber = (object, pathNames) => {
+  for (const pathName of pathNames) {
+    if (!hasOwnPath(object, pathName)) continue;
+    const value = getPathValue(object, pathName);
+    return Number.isFinite(value) ? value : 0;
+  }
+  return 0;
+};
+
+const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => hasOwnPath(object, pathName));
+
+const CODEX_CACHE_READ_USAGE_PATHS = ['cached_input_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens'];
+const CODEX_CACHE_WRITE_USAGE_PATHS = ['cache_write_tokens', 'cache_creation_input_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens'];
+const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'output_tokens_details.reasoning_tokens'];
+
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
   outputTokens: 0,
@@ -42,6 +77,7 @@ export const createCodexTokenUsage = requestedModelId => ({
   stepCount: 0,
   requestedModelId: requestedModelId || null,
   respondedModelId: requestedModelId || null,
+  tokenFieldAvailability: createCodexTokenFieldAvailability(),
 });
 
 const createEmptyCodexItemUsage = () => ({
@@ -162,6 +198,7 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     observedModelDiagnosticPaths: state.observedModelDiagnosticPaths || [],
   };
 
+  nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
   const observedModelPaths = new Set(nextState.observedModelDiagnosticPaths);
 
   for (const rawLine of output.split('\n')) {
@@ -205,17 +242,28 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     }
 
     if (eventType === 'turn.completed' && data.usage && typeof data.usage === 'object') {
-      const inputTokens = Number.isFinite(data.usage.input_tokens) ? data.usage.input_tokens : 0;
-      const cachedInputTokens = Number.isFinite(data.usage.cached_input_tokens) ? data.usage.cached_input_tokens : 0;
-      const outputTokens = Number.isFinite(data.usage.output_tokens) ? data.usage.output_tokens : 0;
+      const inputTokens = getFirstObservedNumber(data.usage, ['input_tokens']);
+      const cachedInputTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_READ_USAGE_PATHS);
+      const cacheWriteTokens = getFirstObservedNumber(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS);
+      const outputTokens = getFirstObservedNumber(data.usage, ['output_tokens']);
+      const reasoningTokens = getFirstObservedNumber(data.usage, CODEX_REASONING_USAGE_PATHS);
+
+      if (hasOwnPath(data.usage, 'input_tokens')) nextState.tokenUsage.tokenFieldAvailability.inputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_READ_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheReadTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_CACHE_WRITE_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.cacheWriteTokens = true;
+      if (hasOwnPath(data.usage, 'output_tokens')) nextState.tokenUsage.tokenFieldAvailability.outputTokens = true;
+      if (hasAnyObservedPath(data.usage, CODEX_REASONING_USAGE_PATHS)) nextState.tokenUsage.tokenFieldAvailability.reasoningTokens = true;
+
       const nonCachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
       nextState.tokenUsage.inputTokens += nonCachedInputTokens;
       nextState.tokenUsage.cacheReadTokens += cachedInputTokens;
+      nextState.tokenUsage.cacheWriteTokens += cacheWriteTokens;
       nextState.tokenUsage.outputTokens += outputTokens;
+      nextState.tokenUsage.reasoningTokens += reasoningTokens;
       nextState.tokenUsage.totalTokens = nextState.tokenUsage.inputTokens + nextState.tokenUsage.cacheReadTokens + nextState.tokenUsage.outputTokens + nextState.tokenUsage.cacheWriteTokens;
       nextState.tokenUsage.stepCount += 1;
 
-      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => Object.hasOwn(data.usage, fieldName));
+      const usageFieldSet = CODEX_USAGE_FIELD_NAMES.filter(fieldName => hasOwnPath(data.usage, fieldName));
       if (usageFieldSet.length > 0) nextState.observedUsageFieldSets.push(usageFieldSet);
     }
 
@@ -537,6 +585,10 @@ export const executeCodexCommand = async params => {
     } else {
       codexArgs += ` --model ${shellQuote(mappedModel)}`;
     }
+    const codexPlaywrightMcpDisableConfigArgs = argv.playwrightMcp === false ? await getCodexPlaywrightMcpDisableConfigArgs(log) : [];
+    for (const arg of codexPlaywrightMcpDisableConfigArgs) {
+      codexArgs += ` ${shellQuote(arg)}`;
+    }
     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`;
 
     const fullCommand = `(cd ${shellQuote(tempDir)} && cat ${shellQuote(promptFile)} | ${codexPath} ${codexArgs})`;

package/src/codex.prompts.lib.mjs

@@ -260,6 +260,7 @@ GitHub CLI command patterns.
 Playwright MCP usage (browser automation via MCP tools).
    - When you develop frontend web applications or debug UI issues, use Playwright MCP tools to test the UI in a real browser.
    - When simple fetch-based browsing is insufficient for dynamic pages, use Playwright MCP browser automation as a fallback.
+   - When WebSearch tool fails or returns insufficient results, use Playwright MCP browser automation as a fallback for internet search.
    - When reproducing or verifying UI bugs, take before/after screenshots and close the browser when finished.`
        : ''
    }${

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import Decimal from 'decimal.js-light';
+
+const formatTokenCount = value => (Number.isFinite(value) ? value : 0).toLocaleString();
+
+const isObservedTokenField = (usage, fieldName) => {
+  const value = usage?.[fieldName];
+  if (Number.isFinite(value) && value > 0) return true;
+  if (usage?.tokenFieldAvailability?.[fieldName] === true) return true;
+  if (Array.isArray(usage?.availableTokenFields) && usage.availableTokenFields.includes(fieldName)) return true;
+  return false;
+};
+
+const buildTokenUsageString = tokenUsage => {
+  const parts = [`${formatTokenCount(tokenUsage.inputTokens)} input`, `${formatTokenCount(tokenUsage.outputTokens)} output`];
+  if (isObservedTokenField(tokenUsage, 'reasoningTokens')) parts.push(`${formatTokenCount(tokenUsage.reasoningTokens)} reasoning`);
+  if (isObservedTokenField(tokenUsage, 'cacheReadTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheReadTokens)} cache read`);
+  if (isObservedTokenField(tokenUsage, 'cacheWriteTokens')) parts.push(`${formatTokenCount(tokenUsage.cacheWriteTokens)} cache write`);
+  return `\n- Token usage: ${parts.join(', ')}`;
+};
+
+/** Build cost estimation string for log comments (Issue #1250, Issue #1557, Issue #1600: Decimal precision) */
+export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
+  const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
+  const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
+  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
+  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
+  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)}**`;
+  let costInfo = '\n\n### 💰 **Cost estimation:**';
+  if (pricingInfo?.modelName) {
+    costInfo += `\n- Model: ${pricingInfo.modelName}`;
+    if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
+  }
+  if (hasPublic) {
+    if (pricingInfo?.isFreeModel && publicDec.eq(0) && !pricingInfo?.baseModelName) {
+      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
+    } else {
+      let pricingRef = '';
+      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
+      } else if (pricingInfo?.originalProvider) {
+        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
+      }
+      costInfo += `\n- Public pricing estimate: $${publicDec.toFixed(6)}${pricingRef}`;
+    }
+  } else if (hasPricing) {
+    costInfo += '\n- Public pricing estimate: unknown';
+  }
+  if (hasOpencodeCost) {
+    if (pricingInfo.isOpencodeFreeModel) {
+      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
+    } else {
+      costInfo += `\n- Calculated by OpenCode Zen: $${new Decimal(pricingInfo.opencodeCost).toFixed(6)}`;
+    }
+  }
+  if (pricingInfo?.tokenUsage) costInfo += buildTokenUsageString(pricingInfo.tokenUsage);
+  if (hasAnthropic) {
+    costInfo += `\n- Calculated by Anthropic: $${anthropicDec.toFixed(6)}`;
+    if (hasPublic) {
+      const diff = anthropicDec.minus(publicDec);
+      const pct = publicDec.gt(0) ? diff.div(publicDec).mul(100) : new Decimal(0);
+      costInfo += `\n- Difference: $${diff.toFixed(6)} (${pct.gt(0) ? '+' : ''}${pct.toFixed(2)}%)`;
+    }
+  }
+  return costInfo;
+};

package/src/github.lib.mjs

@@ -14,60 +14,8 @@ import { formatResetTimeWithRelative } from './usage-limit.lib.mjs'; // See: htt
 import { getToolDisplayName, getModelInfoForComment } from './models/index.mjs';
 export { getToolDisplayName }; // Re-export for use by other modules
 import { buildBudgetStatsString } from './claude.budget-stats.lib.mjs';
-
-/** Build cost estimation string for log comments (Issue #1250, Issue #1557) */
-const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
-  const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
-  const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
-  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
-  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
-  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
-  // Issue #1557: Simplified display when public and Anthropic costs match
-  if (hasPublic && hasAnthropic && totalCostUSD.toFixed(6) === anthropicTotalCostUSD.toFixed(6)) return `\n\n### 💰 Cost: **$${anthropicTotalCostUSD.toFixed(6)}**`;
-  let costInfo = '\n\n### 💰 **Cost estimation:**';
-  if (pricingInfo?.modelName) {
-    costInfo += `\n- Model: ${pricingInfo.modelName}`;
-    if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
-  }
-  if (hasPublic) {
-    if (pricingInfo?.isFreeModel && totalCostUSD === 0 && !pricingInfo?.baseModelName) {
-      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
-    } else {
-      let pricingRef = '';
-      if (pricingInfo?.baseModelName && pricingInfo?.originalProvider) {
-        pricingRef = ` (based on ${pricingInfo.originalProvider} ${pricingInfo.baseModelName} prices)`;
-      } else if (pricingInfo?.originalProvider) {
-        pricingRef = ` (based on ${pricingInfo.originalProvider} prices)`;
-      }
-      costInfo += `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)}${pricingRef}`;
-    }
-  } else if (hasPricing) {
-    costInfo += '\n- Public pricing estimate: unknown';
-  }
-  if (hasOpencodeCost) {
-    if (pricingInfo.isOpencodeFreeModel) {
-      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
-    } else {
-      costInfo += `\n- Calculated by OpenCode Zen: $${pricingInfo.opencodeCost.toFixed(6)}`;
-    }
-  }
-  if (pricingInfo?.tokenUsage) {
-    const u = pricingInfo.tokenUsage;
-    let tokenInfo = `\n- Token usage: ${u.inputTokens?.toLocaleString() || 0} input, ${u.outputTokens?.toLocaleString() || 0} output`;
-    if (u.reasoningTokens > 0) tokenInfo += `, ${u.reasoningTokens.toLocaleString()} reasoning`;
-    if (u.cacheReadTokens > 0 || u.cacheWriteTokens > 0) tokenInfo += `, ${u.cacheReadTokens?.toLocaleString() || 0} cache read, ${u.cacheWriteTokens?.toLocaleString() || 0} cache write`;
-    costInfo += tokenInfo;
-  }
-  if (hasAnthropic) {
-    costInfo += `\n- Calculated by Anthropic: $${anthropicTotalCostUSD.toFixed(6)}`;
-    if (hasPublic) {
-      const diff = anthropicTotalCostUSD - totalCostUSD;
-      const pct = totalCostUSD > 0 ? (diff / totalCostUSD) * 100 : 0;
-      costInfo += `\n- Difference: $${diff.toFixed(6)} (${pct > 0 ? '+' : ''}${pct.toFixed(2)}%)`;
-    }
-  }
-  return costInfo;
-};
+import { buildCostInfoString } from './github-cost-info.lib.mjs';
+export { buildCostInfoString };
 export const maskGitHubToken = maskToken; // Alias for backward compatibility
 export const escapeCodeBlocksInLog = logContent => logContent.replace(/```/g, '\\`\\`\\`'); // Escape ``` in logs
 export const checkFileInBranch = async (owner, repo, fileName, branchName) => {

package/src/opencode.lib.mjs

@@ -19,6 +19,11 @@ import { timeouts } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import { opencodeModels, defaultModels } from './models/index.mjs';
+import { checkPlaywrightMcpPackageAvailability, getOpenCodePlaywrightMcpDisableEnv } from './playwright-mcp.lib.mjs';
+import { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage as parseOpenCodeTokenUsage } from './agent-token-usage.lib.mjs';
+import { calculateAgentPricing } from './agent.lib.mjs';
+
+export { parseOpenCodeTokenUsage };
 
 // Model mapping to translate aliases to full model IDs for OpenCode
 // Issue #1473: Uses centralized opencodeModels from models/index.mjs (single source of truth)
@@ -97,6 +102,9 @@ export const handleOpenCodeRuntimeSwitch = async () => {
   await log('ℹ️  OpenCode runtime handling not required for this operation');
 };
 
+/** Check if Playwright MCP is available for OpenCode @returns {Promise<boolean>} */
+export const checkPlaywrightMcpAvailability = checkPlaywrightMcpPackageAvailability;
+
 // Main function to execute OpenCode with prompts and settings
 export const executeOpenCode = async params => {
   const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, mergeStateStatus, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, log, formatAligned, getResourceSnapshot, opencodePath = 'opencode', $ } = params;
@@ -237,11 +245,20 @@ export const executeOpenCodeCommand = async params => {
     await log(`   Memory: ${resourcesBefore.memory.split('\n')[1]}`, { verbose: true });
     await log(`   Load: ${resourcesBefore.load}`, { verbose: true });
 
+    const opencodeEnv = { ...process.env };
+
+    // Apply Playwright MCP session state before launching OpenCode.
+    if (argv.playwrightMcp === false) {
+      Object.assign(opencodeEnv, await getOpenCodePlaywrightMcpDisableEnv({ env: opencodeEnv, cwd: tempDir, log }));
+      await log('🎭 Playwright MCP physically disabled for this OpenCode session via --no-playwright-mcp', { verbose: true });
+    }
+
     // Build OpenCode command
     let execCommand;
 
     // Map model alias to full ID
     const mappedModel = mapModelToId(argv.model);
+    const streamingTokenUsage = createAgentTokenUsage();
 
     // Build opencode command arguments
     let opencodeArgs = `run --format json --model ${mappedModel}`;
@@ -268,17 +285,28 @@ export const executeOpenCodeCommand = async params => {
     await log(`${fullCommand}`);
     await log('');
 
+    const buildPricingInfo = async () => {
+      const tokenUsage = streamingTokenUsage;
+      if (tokenUsage.stepCount === 0) {
+        return { tokenUsage, pricingInfo: null, publicPricingEstimate: null };
+      }
+      const pricingInfo = await calculateAgentPricing(mappedModel, tokenUsage);
+      return { tokenUsage, pricingInfo, publicPricingEstimate: pricingInfo?.totalCostUSD ?? null };
+    };
+
     try {
       // Pipe the prompt file to opencode via stdin
       if (argv.resume) {
         execCommand = $({
           cwd: tempDir,
           mirror: false,
+          env: opencodeEnv,
         })`cat ${promptFile} | ${opencodePath} run --format json --resume ${argv.resume} --model ${mappedModel}`;
       } else {
         execCommand = $({
           cwd: tempDir,
           mirror: false,
+          env: opencodeEnv,
         })`cat ${promptFile} | ${opencodePath} run --format json --model ${mappedModel}`;
       }
 
@@ -313,6 +341,7 @@ export const executeOpenCodeCommand = async params => {
             for (const line of lines) {
               if (!line.trim()) continue;
               const data = sanitizeObjectStrings(JSON.parse(line));
+              accumulateAgentStepFinishUsage(streamingTokenUsage, data);
               // Track text content for result summary
               // OpenCode outputs text via 'text', 'assistant', 'message', or 'result' type events
               if (data.type === 'text' && data.text) {
@@ -355,6 +384,7 @@ export const executeOpenCodeCommand = async params => {
               for (const line of lines) {
                 if (!line.trim()) continue;
                 const data = sanitizeObjectStrings(JSON.parse(line));
+                accumulateAgentStepFinishUsage(streamingTokenUsage, data);
                 if (data.type === 'text' && data.text) {
                   lastTextContent = data.text;
                 } else if (data.type === 'assistant' && data.message?.content) {
@@ -427,12 +457,14 @@ export const executeOpenCodeCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
 
+        const pricingResult = await buildPricingInfo();
         return {
           success: false,
           sessionId,
           limitReached: false,
           limitResetTime: null,
           permissionPromptDetected: true,
+          ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
         };
       }
@@ -466,17 +498,41 @@ export const executeOpenCodeCommand = async params => {
         await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
         await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
 
+        const pricingResult = await buildPricingInfo();
         return {
           success: false,
           sessionId,
           limitReached,
           limitResetTime,
+          ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
         };
       }
 
       await log('\n\n✅ OpenCode command completed');
 
+      const pricingResult = await buildPricingInfo();
+      if (pricingResult.tokenUsage.stepCount > 0) {
+        await log('\n💰 Token Usage Summary:');
+        await log(`   📊 ${pricingResult.pricingInfo?.modelName || mappedModel} (${pricingResult.tokenUsage.stepCount} steps):`);
+        await log(`      Input tokens:     ${pricingResult.tokenUsage.inputTokens.toLocaleString()}`);
+        await log(`      Output tokens:    ${pricingResult.tokenUsage.outputTokens.toLocaleString()}`);
+        if (pricingResult.tokenUsage.reasoningTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.reasoningTokens) {
+          await log(`      Reasoning tokens: ${pricingResult.tokenUsage.reasoningTokens.toLocaleString()}`);
+        }
+        if (pricingResult.tokenUsage.cacheReadTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.cacheReadTokens) {
+          await log(`      Cache read:       ${pricingResult.tokenUsage.cacheReadTokens.toLocaleString()}`);
+        }
+        if (pricingResult.tokenUsage.cacheWriteTokens > 0 || pricingResult.tokenUsage.tokenFieldAvailability?.cacheWriteTokens) {
+          await log(`      Cache write:      ${pricingResult.tokenUsage.cacheWriteTokens.toLocaleString()}`);
+        }
+        if (pricingResult.pricingInfo?.totalCostUSD !== null && pricingResult.pricingInfo?.totalCostUSD !== undefined) {
+          await log(`      Public pricing estimate: $${pricingResult.pricingInfo.totalCostUSD.toFixed(6)}`);
+        } else {
+          await log('      Cost: Not available (could not fetch pricing)');
+        }
+      }
+
       // Issue #1263: Log if result summary was captured
       if (lastTextContent) {
         await log('📝 Captured result summary from OpenCode output', { verbose: true });
@@ -487,6 +543,7 @@ export const executeOpenCodeCommand = async params => {
         sessionId,
         limitReached,
         limitResetTime,
+        ...pricingResult,
         resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
       };
     } catch (error) {
@@ -510,6 +567,9 @@ export const executeOpenCodeCommand = async params => {
         sessionId: null,
         limitReached: false,
         limitResetTime: null,
+        tokenUsage: streamingTokenUsage.stepCount > 0 ? streamingTokenUsage : null,
+        pricingInfo: null,
+        publicPricingEstimate: null,
         resultSummary: null, // Issue #1263: No result summary available on error
       };
     }
@@ -607,7 +667,9 @@ export const checkForUncommittedChanges = async (tempDir, owner, repo, branchNam
 export default {
   validateOpenCodeConnection,
   handleOpenCodeRuntimeSwitch,
+  checkPlaywrightMcpAvailability,
   executeOpenCode,
   executeOpenCodeCommand,
   checkForUncommittedChanges,
+  parseOpenCodeTokenUsage,
 };

package/src/opencode.prompts.lib.mjs

@@ -226,6 +226,24 @@ GitHub CLI command patterns.
    - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.
    - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.
    - When filtering with jq, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate --jq 'reverse | .[0:5]'.${
+     argv && argv.promptPlaywrightMcp
+       ? `
+
+Playwright MCP usage (browser automation via MCP tools).
+   - When you develop frontend web applications (HTML, CSS, JavaScript, React, Vue, Angular, etc.), use Playwright MCP tools to test the UI in a real browser.
+   - When WebFetch tool fails to retrieve expected content (e.g., returns empty content, JavaScript-rendered pages, or login-protected pages), use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for web browsing.
+   - When WebSearch tool fails or returns insufficient results, use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for internet search.
+   - When you need to interact with dynamic web pages that require JavaScript execution, use Playwright MCP tools.
+   - When you need to visually verify how a web page looks or take screenshots, use browser_take_screenshot from Playwright MCP.
+   - When you need to fill forms, click buttons, or perform user interactions on web pages, use Playwright MCP tools (browser_click, browser_type, browser_fill_form).
+   - When you need to test responsive design or different viewport sizes, use browser_resize from Playwright MCP.
+   - When you finish using the browser, close it with browser_close to free resources.
+   - When reproducing UI bugs, use browser_take_screenshot to capture the problem state before implementing any fix.
+   - When fixing UI bugs, take before/after screenshots to provide visual evidence of the fix for human verification.
+   - When creating UI tests, save baseline screenshots to the repository for visual regression testing.
+   - When verifying UI fixes, compare screenshots to ensure the fix does not introduce unintended visual changes.`
+       : ''
+   }${
      modelSupportsVision
        ? `