@magnusekdahl/parallix 1.1.0 → 1.2.0

package/lib/agents/limit-hit.js

@@ -39,10 +39,12 @@ const PATTERN_SETS = Object.freeze({
   ]
 });
 
+/** @param {string} agent */
 function getPatternsForAgent(agent) {
-  return PATTERN_SETS[agent] || [];
+  return PATTERN_SETS[/** @type {keyof typeof PATTERN_SETS} */(agent)] || [];
 }
 
+/** @param {string} agent @param {string} text */
 function findLimitHitMatch(agent, text) {
   const patterns = getPatternsForAgent(agent);
   for (const pattern of patterns) {
@@ -54,6 +56,7 @@ function findLimitHitMatch(agent, text) {
   return null;
 }
 
+/** @param {string} text @param {number} index @param {number} length */
 function clipContext(text, index, length) {
   const before = Math.max(0, index - 200);
   const after = Math.min(text.length, index + length + 200);
@@ -67,18 +70,20 @@ const RELATIVE_PATTERN = /\bin\s+(\d+)\s+(hour|hours|minute|minutes|second|secon
 const RETRY_AFTER_PATTERN = /retry[- ]?after[:\s]+(\d+)\s*(seconds?|s|minutes?|m)?/i;
 const RETRY_AT_DATE_PATTERN = /(?:retry|reset|try again|reset(?:s)? at)[^\n]{0,40}?(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/i;
 
+/** @param {string | undefined} value */
 function parseIsoOffset(value) {
-  if (!value) return null;
-  if (value === 'Z') return 0;
+  if (!value) {return null;}
+  if (value === 'Z') {return 0;}
   const m = /([+-])(\d{2}):?(\d{2})/.exec(value);
-  if (!m) return null;
+  if (!m) {return null;}
   const sign = m[1] === '-' ? -1 : 1;
   return sign * (Number(m[2]) * 60 + Number(m[3]));
 }
 
+/** @param {string} text */
 function parseIso(text) {
   const m = ISO_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   const [, year, month, day, hour, minute, second, offset] = m;
   const offsetMinutes = parseIsoOffset(offset);
   if (offsetMinutes === null) {
@@ -88,55 +93,61 @@ function parseIso(text) {
   return new Date(utcMs - offsetMinutes * 60 * 1000);
 }
 
+/** @param {string} text @param {Date} now */
 function parseTwelveHour(text, now) {
   const m = TWELVE_HOUR_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   let hour = Number(m[1]);
   const minute = Number(m[2] || 0);
   const meridiem = m[3].toLowerCase();
-  if (hour < 1 || hour > 12) return null;
-  if (meridiem === 'pm' && hour !== 12) hour += 12;
-  if (meridiem === 'am' && hour === 12) hour = 0;
+  if (hour < 1 || hour > 12) {return null;}
+  if (meridiem === 'pm' && hour !== 12) {hour += 12;}
+  if (meridiem === 'am' && hour === 12) {hour = 0;}
   return projectClockTime(now, hour, minute);
 }
 
+/** @param {string} text @param {Date} now */
 function parseTwentyFourHour(text, now) {
   const m = TWENTY_FOUR_HOUR_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   const hour = Number(m[1]);
   const minute = Number(m[2]);
   return projectClockTime(now, hour, minute);
 }
 
+/** @param {string} text @param {Date} now */
 function parseRelative(text, now) {
   const m = RELATIVE_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   const amount = Number(m[1]);
   const unit = m[2].toLowerCase();
   let ms;
-  if (unit.startsWith('hour')) ms = amount * 60 * 60 * 1000;
-  else if (unit.startsWith('minute')) ms = amount * 60 * 1000;
-  else ms = amount * 1000;
+  if (unit.startsWith('hour')) {ms = amount * 60 * 60 * 1000;}
+  else if (unit.startsWith('minute')) {ms = amount * 60 * 1000;}
+  else {ms = amount * 1000;}
   return new Date(now.getTime() + ms);
 }
 
+/** @param {string} text @param {Date} now */
 function parseRetryAfter(text, now) {
   const m = RETRY_AFTER_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   const amount = Number(m[1]);
   const unit = (m[2] || 's').toLowerCase();
   let ms;
-  if (unit.startsWith('m') && unit !== 's') ms = amount * 60 * 1000;
-  else ms = amount * 1000;
+  if (unit.startsWith('m') && unit !== 's') {ms = amount * 60 * 1000;}
+  else {ms = amount * 1000;}
   return new Date(now.getTime() + ms);
 }
 
+/** @param {string} text */
 function parseRetryAtDate(text) {
   const m = RETRY_AT_DATE_PATTERN.exec(text);
-  if (!m) return null;
+  if (!m) {return null;}
   return parseIso(m[1]);
 }
 
+/** @param {Date} now @param {number} hour @param {number} minute */
 function projectClockTime(now, hour, minute) {
   const candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
   if (candidate.getTime() <= now.getTime()) {
@@ -145,8 +156,9 @@ function projectClockTime(now, hour, minute) {
   return candidate;
 }
 
+/** @param {string} text @param {Date} [now] */
 function parseResetTime(text, now = new Date()) {
-  if (!text) return null;
+  if (!text) {return null;}
   return (
     parseRetryAtDate(text) ||
     parseIso(text) ||
@@ -157,6 +169,7 @@ function parseResetTime(text, now = new Date()) {
   );
 }
 
+/** @param {Date} date */
 function formatBlockUntil(date) {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, '0');
@@ -165,6 +178,7 @@ function formatBlockUntil(date) {
   return `${year}-${month}-${day} ${hour}`;
 }
 
+/** @param {Date} date */
 function ceilToNextHour(date) {
   const ceil = new Date(date.getTime());
   if (ceil.getMinutes() === 0 && ceil.getSeconds() === 0 && ceil.getMilliseconds() === 0) {
@@ -175,6 +189,9 @@ function ceilToNextHour(date) {
   return ceil;
 }
 
+/**
+ * @param {{ agent: string, stdout?: string, stderr?: string, status?: number, signal?: string | null, error?: { code?: string } | null, now?: Date }} [opts]
+ */
 function detectLimitHit({
   agent,
   stdout = '',
@@ -183,8 +200,8 @@ function detectLimitHit({
   signal,
   error,
   now = new Date()
-} = {}) {
-  if (!agent) return null;
+} = /** @type {{ agent: string, stdout?: string, stderr?: string, status?: number, signal?: string | null, error?: { code?: string } | null, now?: Date }} */({})) {
+  if (!agent) {return null;}
   // Gate detection on a failed launcher invocation. A successful child (exit 0,
   // no signal, no spawn error) means any limit-hit phrases in the transcript
   // are quoted text — typically when the agent itself reviewed code, tests, or
@@ -193,11 +210,11 @@ function detectLimitHit({
   // `status === undefined` means the caller did not pass exit metadata; preserve
   // the legacy behavior so callers that haven't been updated still get detection.
   const launcherFailed =
-    error != null ||
-    signal != null ||
+    error !== null && error !== undefined ||
+    signal !== null && signal !== undefined ||
     (typeof status === 'number' && status !== 0) ||
     typeof status === 'undefined';
-  if (!launcherFailed) return null;
+  if (!launcherFailed) {return null;}
 
   const combined = `${stdout || ''}\n${stderr || ''}`;
   const match = findLimitHitMatch(agent, combined);
@@ -216,7 +233,7 @@ function detectLimitHit({
       target = new Date(now.getTime() + DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000);
       source = 'fallback';
     }
-  } else if (signal != null) {
+  } else if (signal !== null && signal !== undefined) {
     // Agent was killed by a signal (e.g. SIGINT/Ctrl-C) but no limit-hit
     // pattern matched. Apply a short-term block so the next invocation
     // selects a different agent instead of re-picking the same one.

package/lib/agents/mistral-telemetry.js

@@ -23,7 +23,7 @@
  * @param {object} result - The launcher result object
  * @returns {null} Always null — mistral/vibe has no telemetry parser
  */
-function extractMistralTelemetry(result) {
+function extractMistralTelemetry() {
   // Mistral Vibe does not emit token usage data. Honest zero.
   return null;
 }

package/lib/agents/mistral.js

@@ -12,9 +12,11 @@ const { spawnAndTee } = require('../core/spawn-tee');
 // Telemetry: mistral/vibe does not expose token-usage data. See mistral-telemetry.js
 // for the honest-zero stub. Stats hooks in active.js and review-loop.js call
 // recordStageStats which defaults to '0' for tokens when telemetry is null.
-const MISTRAL_SESSION_ID_RE = null;
 
+
+/** @param {string} stdout */
 function extractMistralSessionId(stdout) {
+  void stdout;
   // Vibe does not currently emit a resume hint in programmatic mode.
   // Return null to indicate no resume capability via stdout parsing.
   return null;
@@ -24,7 +26,12 @@ function resolveMistralCommand() {
   return 'vibe';
 }
 
-function buildMistralInvocation({ prompt, worktree, env, resume = false, sessionId = null, model = null }) {
+/**
+ * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null }} opts
+ */
+function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model = null }) {
+  void resume;
+  void sessionId;
   const args = ['--prompt', prompt, '--trust', '--output', 'text'];
 
   // Vibe programmatic mode does not support --resume flag in the same way
@@ -48,9 +55,12 @@ function buildMistralInvocation({ prompt, worktree, env, resume = false, session
   };
 }
 
+/**
+ * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null, teeOptions?: object }} opts
+ */
 function startMistralAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {} }) {
   const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
-  const resultPromise = spawnAndTee(invocation.command, invocation.args, { ...invocation.options, ...teeOptions }).then(result => {
+  const resultPromise = spawnAndTee(invocation.command, invocation.args, /** @type {any} */({ ...invocation.options, ...teeOptions })).then(result => {
     if (result && result.stdout) {
       result.sessionId = extractMistralSessionId(result.stdout);
     }

package/lib/agents/opencode-export.js

@@ -50,15 +50,19 @@ function captureOpencodeExport(sessionId, opts = {}) {
     }
 
     let settled = false;
+    /** @type {NodeJS.Timeout | null} */
     let timer = null;
     let size = 0;
+    /** @type {number | null} */
     let tmpFd = null;
+    /** @type {string | null} */
     let tmpPath = null;
 
+    /** @param {string | null} value */
     const finish = (value) => {
-      if (settled) return;
+      if (settled) {return;}
       settled = true;
-      if (timer) clearTimeout(timer);
+      if (timer) {clearTimeout(timer);}
       // Clean up temp file
       if (tmpFd !== null) {
         try { fs.closeSync(tmpFd); } catch (_) { /* already closed */ }
@@ -69,8 +73,9 @@ function captureOpencodeExport(sessionId, opts = {}) {
       resolve(value);
     };
 
+    /** @param {import('child_process').ChildProcess | undefined} child */
     const killChild = (child) => {
-      try { child.kill('SIGKILL'); } catch (_) { /* already gone */ }
+      try { if (child) { child.kill('SIGKILL'); } } catch (_) { /* already gone */ }
     };
 
     // Create a temp file for stdout to avoid pipe-buffer truncation
@@ -117,8 +122,8 @@ function captureOpencodeExport(sessionId, opts = {}) {
 
     child.on('error', () => finish(null));
 
-    child.on('close', (code) => {
-      if (settled) return;
+    child.on('close', () => {
+      if (settled) {return;}
       if (tmpFd === null) {
         finish(null);
         return;
@@ -130,6 +135,7 @@ function captureOpencodeExport(sessionId, opts = {}) {
       tmpFd = null;
 
       let content;
+      if (!tmpPath) { finish(null); return; }
       try {
         content = fs.readFileSync(tmpPath, 'utf8');
       } catch (_) {

package/lib/agents/opencode-telemetry.js

@@ -19,80 +19,75 @@
 const PROVIDER = 'opencode';
 const MODEL = 'custom';
 
-/**
- * Safely extract a finite number from a value, defaulting to 0.
- */
+/** @param {*} value */
 function num(value) {
   return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 }
 
 /**
- * Try to find token usage data anywhere in a parsed JSON object.
- * Searches common nesting paths used by opencode export JSON.
- *
- * @param {object} obj - Parsed JSON object
- * @returns {object|null} Normalized token usage object or null
+ * @param {{[key: string]: any}} obj
+ * @returns {{input_tokens?: number, output_tokens?: number, cached_input_tokens?: number, total_tokens?: number}|null}
  */
 function findTokenUsage(obj) {
-  if (!obj || typeof obj !== 'object') return null;
+  if (!obj || typeof obj !== 'object') {return null;}
 
   // Direct token usage fields at top level
   if ('input_tokens' in obj || 'output_tokens' in obj) {
     return {
-      input_tokens: obj.input_tokens,
-      output_tokens: obj.output_tokens,
-      cached_input_tokens: obj.cached_input_tokens || obj.cached_tokens || 0,
-      total_tokens: obj.total_tokens || 0,
+      input_tokens: /** @type {number} */(obj.input_tokens),
+      output_tokens: /** @type {number} */(obj.output_tokens),
+      cached_input_tokens: /** @type {number} */(obj.cached_input_tokens || obj.cached_tokens || 0),
+      total_tokens: /** @type {number} */(obj.total_tokens || 0),
     };
   }
 
   // Nested under total_token_usage (Codex-compatible shape)
   if (obj.total_token_usage && typeof obj.total_token_usage === 'object') {
     return {
-      input_tokens: obj.total_token_usage.input_tokens || 0,
-      output_tokens: obj.total_token_usage.output_tokens || 0,
-      cached_input_tokens: obj.total_token_usage.cached_input_tokens || obj.total_token_usage.cached_tokens || 0,
-      total_tokens: obj.total_token_usage.total_tokens || 0,
+      input_tokens: /** @type {number} */(obj.total_token_usage.input_tokens || 0),
+      output_tokens: /** @type {number} */(obj.total_token_usage.output_tokens || 0),
+      cached_input_tokens: /** @type {number} */(obj.total_token_usage.cached_input_tokens || obj.total_token_usage.cached_tokens || 0),
+      total_tokens: /** @type {number} */(obj.total_token_usage.total_tokens || 0),
     };
   }
 
   // Nested under token_usage
   if (obj.token_usage && typeof obj.token_usage === 'object') {
     return {
-      input_tokens: obj.token_usage.input_tokens || 0,
-      output_tokens: obj.token_usage.output_tokens || 0,
-      cached_input_tokens: obj.token_usage.cached_input_tokens || obj.token_usage.cached_tokens || 0,
-      total_tokens: obj.token_usage.total_tokens || 0,
+      input_tokens: /** @type {number} */(obj.token_usage.input_tokens || 0),
+      output_tokens: /** @type {number} */(obj.token_usage.output_tokens || 0),
+      cached_input_tokens: /** @type {number} */(obj.token_usage.cached_input_tokens || obj.token_usage.cached_tokens || 0),
+      total_tokens: /** @type {number} */(obj.token_usage.total_tokens || 0),
     };
   }
 
   // Nested under usage
   if (obj.usage && typeof obj.usage === 'object') {
     return {
-      input_tokens: obj.usage.input_tokens || 0,
-      output_tokens: obj.usage.output_tokens || 0,
-      cached_input_tokens: obj.usage.cached_input_tokens || obj.usage.cached_tokens || 0,
-      total_tokens: obj.usage.total_tokens || 0,
+      input_tokens: /** @type {number} */(obj.usage.input_tokens || 0),
+      output_tokens: /** @type {number} */(obj.usage.output_tokens || 0),
+      cached_input_tokens: /** @type {number} */(obj.usage.cached_input_tokens || obj.usage.cached_tokens || 0),
+      total_tokens: /** @type {number} */(obj.usage.total_tokens || 0),
     };
   }
 
   // Nested under meta or metadata
-  if ((obj.meta || obj.metadata) && typeof (obj.meta || obj.metadata) === 'object') {
-    const meta = obj.meta || obj.metadata;
-    if ('input_tokens' in meta || 'output_tokens' in meta) {
+  const metaOrMeta = obj.meta || obj.metadata;
+  if (metaOrMeta && typeof metaOrMeta === 'object') {
+    if ('input_tokens' in metaOrMeta || 'output_tokens' in metaOrMeta) {
       return {
-        input_tokens: meta.input_tokens || 0,
-        output_tokens: meta.output_tokens || 0,
-        cached_input_tokens: meta.cached_input_tokens || meta.cached_tokens || 0,
-        total_tokens: meta.total_tokens || 0,
+        input_tokens: /** @type {number} */(metaOrMeta.input_tokens || 0),
+        output_tokens: /** @type {number} */(metaOrMeta.output_tokens || 0),
+        cached_input_tokens: /** @type {number} */(metaOrMeta.cached_input_tokens || metaOrMeta.cached_tokens || 0),
+        total_tokens: /** @type {number} */(metaOrMeta.total_tokens || 0),
       };
     }
-    if (meta.total_token_usage && typeof meta.total_token_usage === 'object') {
+    if (metaOrMeta.total_token_usage && typeof metaOrMeta.total_token_usage === 'object') {
       return {
-        input_tokens: meta.total_token_usage.input_tokens || 0,
-        output_tokens: meta.total_token_usage.output_tokens || 0,
-        cached_input_tokens: meta.total_token_usage.cached_input_tokens || meta.total_token_usage.cached_tokens || 0,
-        total_tokens: meta.total_token_usage.total_tokens || 0,
+        input_tokens: /** @type {number} */(metaOrMeta.total_token_usage.input_tokens || 0),
+        output_tokens: /** @type {number} */(metaOrMeta.total_token_usage.output_tokens || 0),
+        cached_input_tokens: /** @type {number} */(metaOrMeta.total_token_usage.cached_input_tokens || metaOrMeta.total_token_usage.cached_tokens || 0),
+        total_tokens: /** @type {number} */(metaOrMeta.total_token_usage.total_tokens || 0),
       };
     }
   }
@@ -103,10 +98,10 @@ function findTokenUsage(obj) {
     const t = obj.info.tokens;
     if ('input' in t || 'output' in t) {
       return {
-        input_tokens: t.input || 0,
-        output_tokens: t.output || 0,
-        cached_input_tokens: (t.cache && typeof t.cache === 'object') ? (t.cache.read || 0) : 0,
-        total_tokens: t.input + t.output || 0,
+        input_tokens: /** @type {number} */(t.input || 0),
+        output_tokens: /** @type {number} */(t.output || 0),
+        cached_input_tokens: (t.cache && typeof t.cache === 'object') ? /** @type {number} */(t.cache.read || 0) : 0,
+        total_tokens: /** @type {number} */(t.input + t.output || 0),
       };
     }
   }
@@ -117,8 +112,8 @@ function findTokenUsage(obj) {
     if (Array.isArray(val)) {
       for (const item of val) {
         if (item && typeof item === 'object') {
-          const found = findTokenUsage(item);
-          if (found) return found;
+          const found = findTokenUsage(/** @type {{[key: string]: any}} */(item));
+          if (found) {return found;}
         }
       }
     }
@@ -128,89 +123,83 @@ function findTokenUsage(obj) {
 }
 
 /**
- * Extract a sessionId from parsed opencode export JSON.
- *
- * @param {object} parsed - Parsed JSON object
- * @returns {string|null} Session ID or null
+ * @param {{[key: string]: any}} parsed
+ * @returns {string|null}
  */
 function extractSessionId(parsed) {
-  if (!parsed || typeof parsed !== 'object') return null;
+  if (!parsed || typeof parsed !== 'object') {return null;}
 
   // Direct session_id
-  if (parsed.session_id) return String(parsed.session_id);
-  if (parsed.sessionId) return String(parsed.sessionId);
+  if (parsed.session_id) {return String(parsed.session_id);}
+  if (parsed.sessionId) {return String(parsed.sessionId);}
 
   // Nested under info (opencode v2.x export format)
   if (parsed.info && typeof parsed.info === 'object') {
-    if (parsed.info.id) return String(parsed.info.id);
+    if (parsed.info.id) {return String(parsed.info.id);}
   }
 
   // Nested in metadata/meta/session
   if (parsed.metadata && typeof parsed.metadata === 'object') {
-    if (parsed.metadata.session_id) return String(parsed.metadata.session_id);
-    if (parsed.metadata.sessionId) return String(parsed.metadata.sessionId);
+    if (parsed.metadata.session_id) {return String(parsed.metadata.session_id);}
+    if (parsed.metadata.sessionId) {return String(parsed.metadata.sessionId);}
   }
   if (parsed.meta && typeof parsed.meta === 'object') {
-    if (parsed.meta.session_id) return String(parsed.meta.session_id);
-    if (parsed.meta.sessionId) return String(parsed.meta.sessionId);
+    if (parsed.meta.session_id) {return String(parsed.meta.session_id);}
+    if (parsed.meta.sessionId) {return String(parsed.meta.sessionId);}
   }
   if (parsed.session && typeof parsed.session === 'object') {
-    if (parsed.session.id) return String(parsed.session.id);
-    if (parsed.session.session_id) return String(parsed.session.session_id);
+    if (parsed.session.id) {return String(parsed.session.id);}
+    if (parsed.session.session_id) {return String(parsed.session.session_id);}
   }
 
   return null;
 }
 
 /**
- * Extract a model name from parsed opencode export JSON.
- *
- * @param {object} parsed - Parsed JSON object
- * @returns {string|null} Model name or null
+ * @param {{[key: string]: any}} parsed
+ * @returns {string|null}
  */
 function extractModelName(parsed) {
-  if (!parsed || typeof parsed !== 'object') return null;
+  if (!parsed || typeof parsed !== 'object') {return null;}
 
   // Direct model fields
-  if (parsed.model) return String(parsed.model);
-  if (parsed.model_name) return String(parsed.model_name);
+  if (parsed.model) {return String(parsed.model);}
+  if (parsed.model_name) {return String(parsed.model_name);}
 
   // Nested under info.model (opencode v2.x format)
   if (parsed.info && typeof parsed.info === 'object' && parsed.info.model && typeof parsed.info.model === 'object') {
-    if (parsed.info.model.id) return String(parsed.info.model.id);
-    if (parsed.info.model.name) return String(parsed.info.model.name);
+    if (parsed.info.model.id) {return String(parsed.info.model.id);}
+    if (parsed.info.model.name) {return String(parsed.info.model.name);}
   }
 
   // Nested in metadata/meta/session
   if (parsed.metadata && typeof parsed.metadata === 'object') {
-    if (parsed.metadata.model) return String(parsed.metadata.model);
-    if (parsed.metadata.model_name) return String(parsed.metadata.model_name);
+    if (parsed.metadata.model) {return String(parsed.metadata.model);}
+    if (parsed.metadata.model_name) {return String(parsed.metadata.model_name);}
   }
   if (parsed.meta && typeof parsed.meta === 'object') {
-    if (parsed.meta.model) return String(parsed.meta.model);
+    if (parsed.meta.model) {return String(parsed.meta.model);}
   }
   if (parsed.session && typeof parsed.session === 'object') {
-    if (parsed.session.model) return String(parsed.session.model);
+    if (parsed.session.model) {return String(parsed.session.model);}
   }
 
   return null;
 }
 
 /**
- * Count tool calls from parsed opencode export JSON.
- *
- * @param {object} parsed - Parsed JSON object
- * @returns {number} Tool call count
+ * @param {{[key: string]: any}} parsed
+ * @returns {number}
  */
 function countToolCalls(parsed) {
-  if (!parsed || typeof parsed !== 'object') return 0;
+  if (!parsed || typeof parsed !== 'object') {return 0;}
 
   let count = 0;
 
   // Direct tool_calls field
-  if (typeof parsed.tool_calls === 'number') count += parsed.tool_calls;
-  if (typeof parsed.toolCalls === 'number') count += parsed.toolCalls;
-  if (typeof parsed.usage?.tool_calls === 'number') count += parsed.usage.tool_calls;
+  if (typeof parsed.tool_calls === 'number') {count += parsed.tool_calls;}
+  if (typeof parsed.toolCalls === 'number') {count += parsed.toolCalls;}
+  if (typeof parsed.usage?.tool_calls === 'number') {count += parsed.usage.tool_calls;}
 
   // Real opencode v2.x export schema: tool calls live in
   // messages[].parts[] where part.type === 'tool'.
@@ -218,7 +207,7 @@ function countToolCalls(parsed) {
     for (const msg of parsed.messages) {
       if (msg && typeof msg === 'object' && Array.isArray(msg.parts)) {
         for (const part of msg.parts) {
-          if (part && typeof part === 'object' && part.type === 'tool') count += 1;
+          if (part && typeof part === 'object' && part.type === 'tool') {count += 1;}
         }
       }
     }
@@ -228,13 +217,13 @@ function countToolCalls(parsed) {
   if (Array.isArray(parsed.events)) {
     for (const evt of parsed.events) {
       if (evt && typeof evt === 'object') {
-        if (evt.type === 'tool_use') count += 1;
-        if (evt.type === 'tool_call') count += 1;
-        if (evt.type === 'function_call') count += 1;
-        if (Array.isArray(evt.tool_calls)) count += evt.tool_calls.length;
+        if (evt.type === 'tool_use') {count += 1;}
+        if (evt.type === 'tool_call') {count += 1;}
+        if (evt.type === 'function_call') {count += 1;}
+        if (Array.isArray(evt.tool_calls)) {count += evt.tool_calls.length;}
         if (Array.isArray(evt.content_block_start)) {
           for (const cb of evt.content_block_start) {
-            if (cb && cb.type === 'tool_use') count += 1;
+            if (cb && cb.type === 'tool_use') {count += 1;}
           }
         }
       }
@@ -329,12 +318,8 @@ function extractOpencodeTelemetryFromExport(jsonString, fallbackModel) {
 }
 
 /**
- * Attempt to extract telemetry from an opencode launcher result.
- * Deprecated — use extractOpencodeTelemetryFromExport directly.
- * Kept for backward compatibility with existing call sites.
- *
- * @param {object} result - The launcher result object
- * @returns {object|null} Telemetry object or null
+ * @param {{exportJson?: string, telemetry?: object}} result
+ * @returns {object|null}
  */
 function extractOpencodeTelemetry(result) {
   if (result && result.exportJson && typeof result.exportJson === 'string') {