thumbgate 1.27.17 → 1.27.19

package/scripts/gates-engine.js

@@ -1163,9 +1163,47 @@ function isThreadResolutionEvidenceAction(toolName, toolInput = {}) {
   return /\b(?:gate-satisfy|satisfy_gate|track_action|gh\s+pr\s+(?:view|checks|status)|gh\s+api\b.*(?:reviewThreads|reviews|comments|threads)|git\s+(?:status|diff|show))\b/i.test(command);
 }
 
+// Read-only observability/metrics MCP tools must NEVER be blocked by the pending
+// PR-thread-resolution gate. Reading revenue, the dashboard, gate stats, or a
+// semantic entity cannot advance a "done" claim or mutate any state, so gating it
+// only blinds the operator to their own numbers. This is the exact failure the CEO
+// hit on 2026-06-30: `get_business_metrics` denied with "a git commit was made on a
+// PR branch" — a governance gate eating the observability path. The exempt set is
+// sourced from the canonical `readonly` MCP profile (config/mcp-allowlists.json) so
+// it cannot drift from the product's own definition of "safe to read"; the hard-coded
+// fallback guarantees the core observability tools stay readable even if that policy
+// file is unreadable at runtime.
+const READ_ONLY_TOOL_FALLBACK = new Set([
+  'get_business_metrics', 'describe_semantic_entity', 'describe_reliability_entity',
+  'get_reliability_rules', 'dashboard', 'org_dashboard', 'gate_stats', 'feedback_stats',
+  'feedback_summary', 'session_report', 'generate_operator_artifact', 'settings_status',
+  'get_scope_state', 'get_branch_governance', 'context_provenance', 'native_messaging_audit',
+  'list_harnesses', 'list_intents', 'list_imported_documents', 'get_imported_document',
+  'check_operational_integrity', 'workflow_sentinel', 'recall', 'search_lessons',
+  'retrieve_lessons', 'search_thumbgate', 'unified_context', 'verify_claim',
+]);
+let readOnlyToolCache = null;
+function getReadOnlyToolNames() {
+  if (readOnlyToolCache) return readOnlyToolCache;
+  const names = new Set(READ_ONLY_TOOL_FALLBACK);
+  try {
+    const { getAllowedTools } = require('./mcp-policy');
+    for (const tool of getAllowedTools('readonly')) names.add(tool);
+  } catch (_) {
+    // Policy file missing/malformed — the fallback set still covers the core
+    // observability tools, so the operator can always read state.
+  }
+  readOnlyToolCache = names;
+  return names;
+}
+function isReadOnlyObservabilityTool(toolName) {
+  return Boolean(toolName) && getReadOnlyToolNames().has(toolName);
+}
+
 function evaluatePendingPrThreadResolutionGate(toolName, toolInput = {}) {
   if (!hasAction(PR_THREAD_RESOLUTION_ACTION)) return null;
   if (isThreadResolutionSatisfied()) return null;
+  if (isReadOnlyObservabilityTool(toolName)) return null;
   if (isThreadResolutionEvidenceAction(toolName, toolInput)) return null;
 
   const message = 'A git commit was made on a PR branch. Verify review threads are resolved before the next tool call.';
@@ -1991,6 +2029,19 @@ async function checkMetricCondition(metricCondition) {
   return true;
 }
 
+/**
+ * Whether this run is autonomous — i.e. no human is present to resolve an
+ * `approve` (human-in-the-loop) gate. Opt-in ONLY via THUMBGATE_AUTONOMOUS=1
+ * (or "true"); interactive and existing CI behavior is unchanged unless an
+ * operator explicitly sets it. In an autonomous agent loop an approval gate has
+ * nobody to sign off, so it must fail CLOSED (deny) rather than defer forever or
+ * slip through — a guardrail has to guard precisely when it is unattended.
+ */
+function isAutonomousRun() {
+  const raw = String(process.env.THUMBGATE_AUTONOMOUS || '').trim().toLowerCase();
+  return raw === '1' || raw === 'true';
+}
+
 async function evaluateGatesAsync(toolName, toolInput, configPath) {
   let config;
   try {
@@ -2145,6 +2196,15 @@ async function evaluateGatesAsync(toolName, toolInput, configPath) {
     if (gate.action === 'approve') {
       const approvalEnabled = process.env.THUMBGATE_APPROVAL_GATES !== '0';
       if (approvalEnabled) {
+        if (isAutonomousRun()) {
+          // Autonomous run: no human to approve. Fail CLOSED so the actions that
+          // most need sign-off cannot slip through unattended.
+          const failClosedMessage = `[autonomous run — no approver present, failing closed] ${message}`;
+          recordStat(gate.id, 'block', gate, { toolName, toolInput });
+          const failClosedAudit = recordAuditEvent({ toolName, toolInput, decision: 'deny', gateId: gate.id, message: failClosedMessage, severity: gate.severity, source: 'gates-engine', autonomousFailClosed: true });
+          auditToFeedback(failClosedAudit);
+          return { decision: 'deny', gate: gate.id, message: failClosedMessage, severity: gate.severity, reasoning, requiresApproval: true, failedClosed: true };
+        }
         recordStat(gate.id, 'approve', gate, { toolName, toolInput });
         const result = { decision: 'approve', gate: gate.id, message, severity: gate.severity, reasoning, requiresApproval: true };
         const auditRecord = recordAuditEvent({ toolName, toolInput, decision: 'approve', gateId: gate.id, message, severity: gate.severity, source: 'gates-engine' });
@@ -2349,6 +2409,15 @@ function evaluateGates(toolName, toolInput, configPath) {
     if (gate.action === 'approve') {
       const approvalEnabled = process.env.THUMBGATE_APPROVAL_GATES !== '0';
       if (approvalEnabled) {
+        if (isAutonomousRun()) {
+          // Autonomous run: no human to approve. Fail CLOSED so the actions that
+          // most need sign-off cannot slip through unattended.
+          const failClosedMessage = `[autonomous run — no approver present, failing closed] ${message}`;
+          recordStat(gate.id, 'block', gate, { toolName, toolInput });
+          const failClosedAudit = recordAuditEvent({ toolName, toolInput, decision: 'deny', gateId: gate.id, message: failClosedMessage, severity: gate.severity, source: 'gates-engine', autonomousFailClosed: true });
+          auditToFeedback(failClosedAudit);
+          return { decision: 'deny', gate: gate.id, message: failClosedMessage, severity: gate.severity, reasoning, requiresApproval: true, failedClosed: true };
+        }
         recordStat(gate.id, 'approve', gate, { toolName, toolInput });
         const result = { decision: 'approve', gate: gate.id, message, severity: gate.severity, reasoning, requiresApproval: true };
         const auditRecord = recordAuditEvent({ toolName, toolInput, decision: 'approve', gateId: gate.id, message, severity: gate.severity, source: 'gates-engine' });
@@ -2785,7 +2854,7 @@ function buildRecentCorrectiveActionsContext(options = {}) {
 function buildRelevantLessonContext(toolName, toolInput) {
   if (!toolName) return null;
 
-  const { retrieveRelevantLessons, calculateRetrievalEntropy, filterTopP } = loadOptionalModule("./lesson-retrieval", () => ({ retrieveRelevantLessons: () => [], calculateRetrievalEntropy: () => 0, filterTopP: (l) => l }));
+  const { retrieveRelevantLessons, calculateRetrievalEntropy } = loadOptionalModule("./lesson-retrieval", () => ({ retrieveRelevantLessons: () => [], calculateRetrievalEntropy: () => 0 }));
 
   // Extract a searchable action context from the tool input
   const actionContext = extractActionContext(toolName, toolInput);
@@ -3294,6 +3363,7 @@ module.exports = {
   matchesGate,
   evaluateGates,
   evaluateGatesAsync,
+  isAutonomousRun,
   computeExecutableHash,
   formatOutput,
   isApprovalGatesEnabled,
@@ -3335,6 +3405,7 @@ module.exports = {
   evaluateBoostedRiskTagGuard,
   registerPrThreadResolutionClaimGate,
   evaluatePendingPrThreadResolutionGate,
+  isReadOnlyObservabilityTool,
   getLocalOnlyScopeSources,
   isRemoteSideEffectCommand,
   evaluateLocalOnlyRemoteSideEffectGate,

package/scripts/hook-runtime.js

@@ -53,12 +53,12 @@ function resolveCliCommand(subcommand) {
 function resolveCodexCliCommand(subcommand) {
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
-    return publishedCliShellCommand('latest', [subcommand], { preferInstalled: false });
+    return publishedCliShellCommand('latest', [subcommand]);
   }
   if (isSourceCheckout(PKG_ROOT)) {
     return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
   }
-  return publishedCliShellCommand('latest', [subcommand], { preferInstalled: false });
+  return publishedCliShellCommand('latest', [subcommand]);
 }
 
 function buildPortableHookCommand(subcommand) {

package/scripts/license.js

@@ -23,15 +23,17 @@ function isValidKey(key) {
 }
 
 function verifyLicense(options = {}) {
-  const envKey = [
-    process.env.THUMBGATE_API_KEY,
-    process.env.THUMBGATE_PRO_KEY,
+  // Only ThumbGate's own env vars are license candidates — scanning foreign
+  // *_API_KEY / *_PRO_KEY vars would treat another vendor's secret as a
+  // license key. The result object never carries the raw key value.
+  const envEntry = [
+    ['THUMBGATE_API_KEY', process.env.THUMBGATE_API_KEY],
+    ['THUMBGATE_PRO_KEY', process.env.THUMBGATE_PRO_KEY],
     ...Object.entries(process.env)
-      .filter(([name]) => /(?:_API_KEY|_PRO_KEY)$/.test(name))
-      .map(([, value]) => value),
-  ].find((value) => isValidKey(value));
-  if (isValidKey(envKey)) {
-    return { valid: true, source: 'env', key: envKey };
+      .filter(([name]) => name.startsWith('THUMBGATE_') && /(?:_API_KEY|_PRO_KEY)$/.test(name)),
+  ].find(([, value]) => isValidKey(value));
+  if (envEntry) {
+    return { valid: true, source: 'env', envVar: envEntry[0] };
   }
 
   const licensePath = getLicensePath(options.homeDir);
@@ -42,7 +44,6 @@ function verifyLicense(options = {}) {
         return {
           valid: true,
           source: 'file',
-          key: data.key,
           activatedAt: data.activatedAt,
           path: licensePath,
         };

package/scripts/llm-client.js

@@ -4,90 +4,26 @@
 const { runStep } = require('./durability/step');
 
 const MODELS = {
-  FAST: 'glm-5.2',
-  SMART: 'glm-5.2',
-  ZAI_CODING: 'glm-5.2',
-  LEGACY_CLAUDE_FAST: 'claude-haiku-4-5-20251001',
-  LEGACY_CLAUDE_SMART: 'claude-sonnet-4-6',
+  FAST: 'claude-haiku-4-5-20251001',
+  SMART: 'claude-sonnet-4-6',
 };
 
 const DEFAULT_MODEL = MODELS.FAST;
 const DEFAULT_MAX_TOKENS = 1024;
 const DEFAULT_CACHE_TTL = '5m';
-const DEFAULT_ZAI_BASE_URL = 'https://api.z.ai/api/coding/paas/v4';
-const DEFAULT_ZAI_MODEL = MODELS.ZAI_CODING;
-const DEFAULT_OMLX_BASE_URL = 'http://127.0.0.1:8000/v1';
-const DEFAULT_OMLX_MODEL = 'qwen3-coder-next';
+const DEFAULT_ZAI_BASE_URL = 'https://api.z.ai/api/paas/v4';
+const DEFAULT_ZAI_MODEL = 'glm-5.2-flash';
 
 let _anthropicClient = null;
 let _geminiClient = null;
 
-function getZaiApiKey(env = process.env) {
-  return env.ZAI_API_KEY || env.THUMBGATE_ZAI_API_KEY || env.GLM_API_KEY || '';
-}
-
-function getZaiBaseUrl(env = process.env) {
-  return (env.ZAI_API_BASE_URL || env.THUMBGATE_ZAI_API_BASE_URL || DEFAULT_ZAI_BASE_URL).replace(/\/+$/, '');
-}
-
-function getZaiModel(env = process.env) {
-  return env.ZAI_API_MODEL || env.THUMBGATE_ZAI_MODEL || DEFAULT_ZAI_MODEL;
-}
-
-function getOmlxApiKey(env = process.env) {
-  return env.OMLX_API_KEY || env.THUMBGATE_OMLX_API_KEY || '';
-}
-
-function getOmlxBaseUrl(env = process.env) {
-  return (env.OMLX_BASE_URL || env.THUMBGATE_OMLX_BASE_URL || DEFAULT_OMLX_BASE_URL)
-    .replace(/\/chat\/completions\/?$/i, '')
-    .replace(/\/+$/, '');
-}
-
-function getOmlxModel(env = process.env) {
-  return env.OMLX_MODEL || env.THUMBGATE_OMLX_MODEL || DEFAULT_OMLX_MODEL;
-}
-
-function hasZaiApiKey(env = process.env) {
-  return Boolean(getZaiApiKey(env));
-}
-
-function hasOmlxConfig(env = process.env) {
-  return env.THUMBGATE_LLM_PROVIDER === 'omlx'
-    || env.LLM_PROVIDER === 'omlx'
-    || env.THUMBGATE_OMLX_ENABLED === '1'
-    || env.OMLX_ENABLED === '1'
-    || Boolean(env.OMLX_BASE_URL || env.THUMBGATE_OMLX_BASE_URL);
-}
-
-function isZaiProvider(provider = '') {
-  return /^(zai|z\.ai|glm|glm-coding)$/i.test(String(provider || '').trim());
-}
-
-function isOmlxProvider(provider = '') {
-  return /^(omlx|local-omlx|mlx-local)$/i.test(String(provider || '').trim());
-}
-
-function isZaiModel(model = '') {
-  return /^(glm|zai|z\.ai)/i.test(String(model || '').trim());
-}
-
-function isAvailable(provider = '') {
-  const normalizedProvider = String(provider || '').trim().toLowerCase();
-  if (isZaiProvider(normalizedProvider)) return hasZaiApiKey();
-  if (isOmlxProvider(normalizedProvider)) return hasOmlxConfig();
-  if (normalizedProvider === 'anthropic' || normalizedProvider === 'claude') {
-    return Boolean(process.env.ANTHROPIC_API_KEY);
-  }
-  if (normalizedProvider === 'gemini' || normalizedProvider === 'vertex') {
-    return Boolean(process.env.GEMINI_API_KEY || process.env.VERTEX_PROJECT_ID);
-  }
-  return Boolean(hasOmlxConfig() || hasZaiApiKey() || process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY || process.env.VERTEX_PROJECT_ID);
+function isAvailable() {
+  return Boolean(process.env.ANTHROPIC_API_KEY);
 }
 
 function getClient() {
   if (_anthropicClient) return _anthropicClient;
-  if (!isAvailable('anthropic')) return null;
+  if (!isAvailable()) return null;
   try {
     const Anthropic = require('@anthropic-ai/sdk');
     _anthropicClient = new Anthropic();
@@ -189,63 +125,6 @@ function buildClaudeRequest({
   return request;
 }
 
-function normalizeMessageText(content) {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (typeof part === 'string') return part;
-      if (part && typeof part === 'object') return part.text || JSON.stringify(part);
-      return '';
-    }).join('');
-  }
-  if (content && typeof content === 'object') {
-    return content.text || JSON.stringify(content);
-  }
-  return '';
-}
-
-function convertMessagesToOpenAi(messages, userPrompt, systemPrompt) {
-  const normalized = [];
-  if (systemPrompt) normalized.push({ role: 'system', content: systemPrompt });
-
-  const list = Array.isArray(messages) && messages.length > 0
-    ? messages
-    : [{ role: 'user', content: userPrompt }];
-
-  for (const message of list) {
-    if (!message || typeof message !== 'object') continue;
-    const role = message.role === 'assistant' || message.role === 'system' ? message.role : 'user';
-    const content = normalizeMessageText(message.content);
-    if (content) normalized.push({ role, content });
-  }
-
-  if (normalized.length === 0) {
-    normalized.push({ role: 'user', content: String(userPrompt || '') });
-  }
-
-  return normalized;
-}
-
-function buildOpenAiCompatibleRequest({
-  systemPrompt,
-  userPrompt,
-  messages,
-  model,
-  maxTokens,
-  temperature,
-  metadata,
-} = {}, env = process.env) {
-  const request = {
-    model: model || getZaiModel(env),
-    messages: convertMessagesToOpenAi(messages, userPrompt, systemPrompt),
-    max_tokens: maxTokens || DEFAULT_MAX_TOKENS,
-  };
-
-  if (Number.isFinite(temperature)) request.temperature = temperature;
-  if (metadata && typeof metadata === 'object') request.metadata = metadata;
-  return request;
-}
-
 function extractTextContent(response) {
   return (response?.content || [])
     .filter((block) => block.type === 'text')
@@ -262,92 +141,54 @@ function parseClaudeJson(text) {
   }
 }
 
-async function callZaiInternal(options = {}) {
-  const apiKey = getZaiApiKey();
-  if (!apiKey) return null;
-  if (typeof fetch !== 'function') return null;
-
-  const baseUrl = getZaiBaseUrl();
-  const requestedModel = options.model && isZaiModel(options.model) ? options.model : undefined;
-  const request = buildOpenAiCompatibleRequest({
-    ...options,
-    model: requestedModel || getZaiModel(),
-  });
-
-  try {
-    const response = await runStep('llm.callZai', {
-      retries: 2,
-      logger: (msg) => console.warn(msg),
-    }, async () => fetch(`${baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(request),
-    }));
+function getZaiApiKey(env = process.env) {
+  return env.ZAI_API_KEY || env.THUMBGATE_ZAI_API_KEY || '';
+}
 
-    if (!response || !response.ok) {
-      throw new Error(`Z.ai request failed with status ${response?.status || 'unknown'}`);
-    }
+function getZaiBaseUrl(env = process.env) {
+  return env.ZAI_BASE_URL || env.THUMBGATE_ZAI_BASE_URL || DEFAULT_ZAI_BASE_URL;
+}
 
-    const json = await response.json();
-    const text = stripCodeFences(json?.choices?.[0]?.message?.content || '');
-    return {
-      text,
-      usage: json?.usage || null,
-      stopReason: json?.choices?.[0]?.finish_reason || null,
-      id: json?.id || null,
-      model: json?.model || request.model,
-      provider: 'zai',
-    };
-  } catch (err) {
-    console.error('Z.ai execution error:', err?.message || err);
-    return null;
-  }
+function getZaiModel(env = process.env) {
+  return env.ZAI_API_MODEL || env.THUMBGATE_ZAI_MODEL || DEFAULT_ZAI_MODEL;
 }
 
-async function callOmlxInternal(options = {}) {
-  if (!hasOmlxConfig()) return null;
-  if (typeof fetch !== 'function') return null;
+async function callZaiInternal(options = {}, env = process.env) {
+  const apiKey = getZaiApiKey(env);
+  if (!apiKey || typeof fetch !== 'function') return null;
 
-  const baseUrl = getOmlxBaseUrl();
-  const request = buildOpenAiCompatibleRequest({
-    ...options,
-    model: options.model || getOmlxModel(),
-  });
-  const apiKey = getOmlxApiKey();
-  const headers = {
-    'Content-Type': 'application/json',
-  };
-  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const messages = Array.isArray(options.messages) && options.messages.length > 0
+    ? options.messages
+    : [
+      ...(options.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+      { role: 'user', content: options.userPrompt || '' },
+    ];
 
   try {
-    const response = await runStep('llm.callOmlx', {
-      retries: 1,
-      logger: (msg) => console.warn(msg),
-    }, async () => fetch(`${baseUrl}/chat/completions`, {
+    const response = await fetch(`${getZaiBaseUrl(env).replace(/\/$/, '')}/chat/completions`, {
       method: 'POST',
-      headers,
-      body: JSON.stringify(request),
-    }));
-
-    if (!response || !response.ok) {
-      throw new Error(`oMLX request failed with status ${response?.status || 'unknown'}`);
-    }
-
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options.model || getZaiModel(env),
+        messages,
+        max_tokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+        temperature: Number.isFinite(options.temperature) ? options.temperature : 0,
+      }),
+    });
+
+    if (!response.ok) return null;
     const json = await response.json();
-    const text = stripCodeFences(json?.choices?.[0]?.message?.content || '');
     return {
-      text,
+      text: stripCodeFences(json?.choices?.[0]?.message?.content || ''),
       usage: json?.usage || null,
       stopReason: json?.choices?.[0]?.finish_reason || null,
       id: json?.id || null,
-      model: json?.model || request.model,
-      provider: 'omlx',
+      model: json?.model || options.model || getZaiModel(env),
     };
-  } catch (err) {
-    console.error('oMLX execution error:', err?.message || err);
+  } catch {
     return null;
   }
 }
@@ -434,16 +275,6 @@ function convertMessagesToGemini(messages, userPrompt) {
 
 async function callClaudeInternal(options = {}) {
   const modelName = options.model || '';
-  const provider = options.provider || process.env.THUMBGATE_LLM_PROVIDER || process.env.LLM_PROVIDER || '';
-  const requestedZai = isZaiProvider(provider) || isZaiModel(modelName);
-  if (isOmlxProvider(provider)) {
-    return callOmlxInternal(options);
-  }
-  if (requestedZai || (!process.env.ANTHROPIC_API_KEY && hasZaiApiKey() && !modelName.startsWith('gemini') && !modelName.startsWith('vertex'))) {
-    const zaiOptions = requestedZai ? options : { ...options, model: undefined };
-    return callZaiInternal(zaiOptions);
-  }
-
   if (modelName.startsWith('gemini') || modelName.startsWith('vertex')) {
     return callGeminiInternal(options);
   }
@@ -496,19 +327,12 @@ async function callClaudeJson(options = {}) {
       stopReason: result.stopReason,
       id: result.id,
       model: result.model,
-      provider: result.provider || 'anthropic',
     };
   }
 
   return parsed;
 }
 
-async function callZai(options = {}) {
-  const result = await callZaiInternal(options);
-  if (!result) return null;
-  return options.returnMetadata ? result : result.text;
-}
-
 async function callZaiJson(options = {}) {
   const result = await callZaiInternal(options);
   if (!result) return null;
@@ -524,35 +348,6 @@ async function callZaiJson(options = {}) {
       stopReason: result.stopReason,
       id: result.id,
       model: result.model,
-      provider: result.provider,
-    };
-  }
-
-  return parsed;
-}
-
-async function callOmlx(options = {}) {
-  const result = await callOmlxInternal(options);
-  if (!result) return null;
-  return options.returnMetadata ? result : result.text;
-}
-
-async function callOmlxJson(options = {}) {
-  const result = await callOmlxInternal(options);
-  if (!result) return null;
-
-  const parsed = parseClaudeJson(result.text);
-  if (parsed === null) return null;
-
-  if (options.returnMetadata) {
-    return {
-      parsed,
-      text: result.text,
-      usage: result.usage,
-      stopReason: result.stopReason,
-      id: result.id,
-      model: result.model,
-      provider: result.provider,
     };
   }
 
@@ -563,24 +358,13 @@ module.exports = {
   isAvailable,
   callClaude,
   callClaudeJson,
-  callZai,
   callZaiJson,
-  callOmlx,
-  callOmlxJson,
+  getZaiApiKey,
+  getZaiBaseUrl,
+  getZaiModel,
   stripCodeFences,
   parseClaudeJson,
   normalizeCacheOptions,
   buildClaudeRequest,
-  buildOpenAiCompatibleRequest,
-  convertMessagesToOpenAi,
-  getZaiApiKey,
-  getZaiBaseUrl,
-  getZaiModel,
-  getOmlxApiKey,
-  getOmlxBaseUrl,
-  getOmlxModel,
   MODELS,
-  DEFAULT_ZAI_BASE_URL,
-  DEFAULT_OMLX_BASE_URL,
-  DEFAULT_OMLX_MODEL,
 };

package/scripts/mcp-config.js

@@ -107,9 +107,15 @@ function portableMcpEntry(pkgVersion) {
 }
 
 function codexAutoUpdateCliEntry(commandArgs = []) {
+  // Fast-start from the installed runtime binary; only resolve @latest via npx
+  // when the runtime is absent (e.g. first launch). This matches the hook
+  // commands and must never block MCP server startup on a per-launch reinstall
+  // (a blocking `npm install thumbgate@latest` on every launch caused
+  // capture/serve timeouts on slow or offline networks — a failed install left
+  // the chained `exec` unreached, so the server never started).
   return {
     command: 'sh',
-    args: ['-lc', publishedCliShellCommand('latest', commandArgs, { preferInstalled: false })],
+    args: ['-lc', publishedCliShellCommand('latest', commandArgs)],
   };
 }
 

package/scripts/published-cli.js

@@ -37,14 +37,6 @@ function publishedCliShellCommand(pkgVersion, commandArgs = [], options = {}) {
   const escapedArgs = commandArgs.map(shellQuote).join(' ');
   const fastPath = `[ -x ${shellQuote(runtimeBin)} ] && exec ${shellQuote(runtimeBin)}${escapedArgs ? ` ${escapedArgs}` : ''}`;
   const installPath = `mkdir -p ${shellQuote(prefixDir)} && exec npm ${publishedCliArgs(pkgVersion, commandArgs, { prefixDir }).map(shellQuote).join(' ')}`;
-  if (options.preferInstalled === false) {
-    const packageSpec = `thumbgate@${pkgVersion}`;
-    return [
-      `mkdir -p ${shellQuote(prefixDir)}`,
-      `npm "install" "--prefix" ${shellQuote(prefixDir)} "--no-save" "--omit=dev" ${shellQuote(packageSpec)} >/dev/null 2>&1`,
-      `exec ${shellQuote(runtimeBin)}${escapedArgs ? ` ${escapedArgs}` : ''}`,
-    ].join(' && ');
-  }
   return `${fastPath} || ${installPath}`;
 }
 

package/scripts/seo-gsd.js

@@ -12,7 +12,6 @@ const PRODUCT = {
   repoUrl: 'https://github.com/IgorGanapolsky/ThumbGate',
   homepageUrl: 'https://thumbgate.ai',
   verificationUrl: 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/VERIFICATION_EVIDENCE.md',
-  automationUrl: 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/proof/automation/report.json',
   sprintDiagnosticPaymentUrl: 'https://buy.stripe.com/00w14neyUcXA5pL5e33sI0e',
   workflowSprintPaymentUrl: 'https://buy.stripe.com/fZu9AT76saPsg4pbCr3sI0f',
   compatibility: ['Claude Code', 'Cursor', 'Codex', 'Gemini', 'Amp', 'OpenCode'],
@@ -3389,10 +3388,6 @@ function createPageSpec(blueprint, row) {
     },
     proofLinks: [
       { label: 'Verification evidence', href: PRODUCT.verificationUrl },
-      { label: 'Automation proof', href: PRODUCT.automationUrl },
-      ...(blueprint.path === '/guides/agent-harness-optimization'
-        ? [{ label: 'Harness proof', href: 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/proof/harnesses-report.json' }]
-        : []),
       { label: 'GitHub repository', href: PRODUCT.repoUrl },
     ],
     changefreq: blueprint.pageType === 'comparison' ? 'weekly' : 'monthly',