@getmarrow/install 0.1.19 → 0.1.21

package/src/installer.js

@@ -4,9 +4,6 @@ const os = require('node:os');
 const crypto = require('node:crypto');
 
 const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
-const INSTALLER_LATEST = '0.1.19';
-const SDK_LATEST = '3.7.35';
-const MCP_LATEST = '3.9.35';
 const MARROW_BLOCK_START = '<!-- marrow:passive-start -->';
 const MARROW_BLOCK_END = '<!-- marrow:passive-end -->';
 
@@ -18,7 +15,7 @@ function parseArgs(argv) {
     doctor: false,
     repair: false,
     mode: 'auto',
-    apiKey: process.env.MARROW_API_KEY || process.env.MARROW_KEY || '',
+    apiKey: process.env.MARROW_API_KEY || '',
     baseUrl: process.env.MARROW_BASE_URL || DEFAULT_BASE_URL,
     agentId: process.env.MARROW_FLEET_AGENT_ID || process.env.MARROW_AGENT_ID || '',
     selfTest: true,
@@ -60,12 +57,6 @@ function parseArgs(argv) {
     throw new Error('--mode must be one of auto, mcp, sdk, both, md');
   }
 
-  const resolved = resolveMarrowKeyMaterial(options.cwd);
-  if (!options.apiKey && resolved.apiKey) options.apiKey = resolved.apiKey;
-  if (!options.agentId && resolved.agentId) options.agentId = resolved.agentId;
-  if (options.baseUrl === DEFAULT_BASE_URL && resolved.baseUrl) options.baseUrl = resolved.baseUrl;
-  if (!options.keySource && resolved.source) options.keySource = resolved.source;
-
   return options;
 }
 
@@ -80,14 +71,14 @@ function usage() {
 
 Options:
   --dry-run          Print planned changes without writing
-  --doctor           Check install health; self-test writes and closes a harmless test event
+  --doctor           Check install health without writing
   --repair           Write missing hooks/config, then run self-test and status check
   --yes, -y          Write detected config files
   --mode <mode>      auto, mcp, sdk, both, or md
   --key <key>        Marrow API key for self-test. Prefer MARROW_API_KEY because CLI args can appear in process listings.
   --base-url <url>   Marrow API base URL
   --agent-id <id>    Agent/fleet id for self-test headers
-  --no-self-test     Skip API smoke/self-test for a read-only doctor check
+  --no-self-test     Skip API smoke/self-test
 `;
 }
 
@@ -114,12 +105,6 @@ function findUp(startDir, names, maxDepth = 8) {
 }
 
 function projectRoot(startDir) {
-  const resolved = path.resolve(startDir);
-  if (path.basename(resolved) === '.marrow') return path.dirname(resolved);
-  if (path.basename(resolved) === 'env' && path.basename(path.dirname(resolved)) === '.marrow') {
-    return path.dirname(path.dirname(resolved));
-  }
-  if (exists(path.join(resolved, '.marrow'))) return resolved;
   const marker = findUp(startDir, ['package.json', 'pyproject.toml', 'requirements.txt', '.git', 'AGENTS.md', 'CLAUDE.md']);
   return marker ? path.dirname(marker) : path.resolve(startDir);
 }
@@ -166,7 +151,8 @@ function findLikelyEnvFiles(detection, env = process.env) {
     path.join(detection.root, '.marrow', 'env'),
     path.join(detection.root, '.marrow', 'env.local'),
     path.join(home, '.marrow', 'env'),
-    path.join(home, '.marrow', 'env.local'),
+    path.join(home, '.openclaw', 'credentials', 'marrow-mcp.env'),
+    path.join(home, '.openclaw', 'gateway.systemd.env'),
   ];
   return candidates.filter((filePath) => {
     if (!exists(filePath)) return false;
@@ -191,36 +177,6 @@ function readEnvVar(filePath, name) {
   return match ? stripQuotes(match[1]) : '';
 }
 
-function resolveMarrowKeyMaterial(cwd = process.cwd(), env = process.env) {
-  if (env.MARROW_API_KEY || env.MARROW_KEY) {
-    return {
-      apiKey: env.MARROW_API_KEY || env.MARROW_KEY,
-      baseUrl: env.MARROW_BASE_URL || DEFAULT_BASE_URL,
-      agentId: env.MARROW_FLEET_AGENT_ID || env.MARROW_AGENT_ID || '',
-      source: env.MARROW_API_KEY ? 'MARROW_API_KEY' : 'MARROW_KEY',
-    };
-  }
-
-  const detection = detectEnvironment(cwd, env);
-  for (const filePath of findLikelyEnvFiles(detection, env)) {
-    const apiKey = readEnvVar(filePath, 'MARROW_API_KEY') || readEnvVar(filePath, 'MARROW_KEY');
-    if (!apiKey) continue;
-    return {
-      apiKey,
-      baseUrl: readEnvVar(filePath, 'MARROW_BASE_URL') || env.MARROW_BASE_URL || DEFAULT_BASE_URL,
-      agentId: readEnvVar(filePath, 'MARROW_FLEET_AGENT_ID') || readEnvVar(filePath, 'MARROW_AGENT_ID') || env.MARROW_FLEET_AGENT_ID || env.MARROW_AGENT_ID || '',
-      source: filePath,
-    };
-  }
-
-  return {
-    apiKey: '',
-    baseUrl: env.MARROW_BASE_URL || DEFAULT_BASE_URL,
-    agentId: env.MARROW_FLEET_AGENT_ID || env.MARROW_AGENT_ID || '',
-    source: null,
-  };
-}
-
 function readFirstLineSecret(filePath) {
   if (!exists(filePath)) return '';
   return safeRead(filePath).split(/\r?\n/).map((line) => line.trim()).find(Boolean) || '';
@@ -327,7 +283,8 @@ Marrow should run passively after install:
 
 - Use MCP hooks when available: \`npx -y @getmarrow/mcp setup\`.
 - Use SDK passive runtime in owned Node processes: \`createPassiveRuntime().install()\`.
-- Before risky work, use Marrow's before-action intervention from \`GET /v1/agent/status\` or \`POST /v1/agent/runtime\`.
+- Keep passive token/model usage proof enabled so Marrow can show token, cost, latency, and workflow savings after real work completes.
+- Before risky work, use Marrow's decision brief or passive prompt hook.
 - After meaningful work, record the outcome so future agents learn from it.
 - Check health with \`marrow_agent_status\` or \`GET /v1/agent/status\`.
 
@@ -335,79 +292,29 @@ Required environment:
 
 - \`MARROW_API_KEY\`
 - Optional: \`MARROW_BASE_URL\`, \`MARROW_FLEET_AGENT_ID\`
-
-Key loading:
-
-- Prefer your shell, MCP secret store, or agent secret manager.
-- Marrow also auto-detects \`.marrow/env\`, \`.marrow/env.local\`, \`.env\`, \`.env.local\`, and \`~/.marrow/env\`.
-- Run \`npx @getmarrow/install doctor\` any time an agent says Marrow is missing or degraded.
+- Optional: \`MARROW_PASSIVE_TOKEN_USAGE=false\` disables compact provider usage capture when needed.
 ${MARROW_BLOCK_END}`;
 }
 
 function passiveRuntimeSource() {
-  return `import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-function stripQuotes(value) {
-  const trimmed = String(value || '').trim();
-  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) return trimmed.slice(1, -1);
-  return trimmed;
-}
-
-function readEnvFile(filePath) {
-  if (!fs.existsSync(filePath)) return {};
-  const values = {};
-  const allowed = new Set(['MARROW_API_KEY', 'MARROW_KEY', 'MARROW_BASE_URL', 'MARROW_FLEET_AGENT_ID', 'MARROW_AGENT_ID', 'MARROW_SESSION_ID', 'MARROW_ENFORCEMENT_MODE', 'MARROW_PASSIVE_VALUE_REPORT', 'MARROW_VALUE_REPORT_PERIOD', 'MARROW_AGENT_RUNTIME', 'MARROW_WORKFLOW_GATE', 'MARROW_REQUIRE_OUTCOME_CLOSURE']);
-  for (const line of fs.readFileSync(filePath, 'utf8').split(/\\r?\\n/)) {
-    const match = line.match(/^\\s*(?:export\\s+)?([A-Z_][A-Z0-9_]*)\\s*=\\s*(.*?)\\s*$/);
-    if (!match) continue;
-    if (!allowed.has(match[1])) continue;
-    let value = match[2] || '';
-    const hashIndex = value.search(/\\s+#/);
-    if (hashIndex >= 0) value = value.slice(0, hashIndex);
-    values[match[1]] = stripQuotes(value);
-  }
-  return values;
-}
-
-function resolveMarrowEnv() {
-  if (process.env.MARROW_API_KEY || process.env.MARROW_KEY) return process.env;
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const files = [];
-  let dir = process.cwd();
-  for (let depth = 0; depth < 8; depth += 1) {
-    files.push(path.join(dir, '.marrow', 'env'), path.join(dir, '.marrow', 'env.local'), path.join(dir, '.env'), path.join(dir, '.env.local'));
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  files.push(path.join(home, '.marrow', 'env'), path.join(home, '.marrow', 'env.local'));
-  for (const filePath of [...new Set(files)]) {
-    const values = readEnvFile(filePath);
-    if (values.MARROW_API_KEY || values.MARROW_KEY) return { ...process.env, ...values };
-  }
-  return process.env;
-}
-
-const marrowEnv = resolveMarrowEnv();
-const apiKey = marrowEnv.MARROW_API_KEY || marrowEnv.MARROW_KEY;
+  return `const apiKey = process.env.MARROW_API_KEY;
 if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
   try {
     const { MarrowClient } = await import('@getmarrow/sdk');
     const marrow = new MarrowClient(apiKey, {
-      baseUrl: marrowEnv.MARROW_BASE_URL,
-      agentId: marrowEnv.MARROW_FLEET_AGENT_ID || marrowEnv.MARROW_AGENT_ID,
-      sessionId: marrowEnv.MARROW_SESSION_ID,
-      mode: marrowEnv.MARROW_ENFORCEMENT_MODE || 'auto',
+      baseUrl: process.env.MARROW_BASE_URL,
+      agentId: process.env.MARROW_FLEET_AGENT_ID || process.env.MARROW_AGENT_ID,
+      sessionId: process.env.MARROW_SESSION_ID,
+      mode: process.env.MARROW_ENFORCEMENT_MODE || 'auto',
     });
 
     const runtime = marrow.createPassiveRuntime({
-      includeValueReport: marrowEnv.MARROW_PASSIVE_VALUE_REPORT !== 'false',
-      valueReportPeriod: marrowEnv.MARROW_VALUE_REPORT_PERIOD || '7d',
-      useAgentRuntime: marrowEnv.MARROW_AGENT_RUNTIME !== 'false',
-      useWorkflowGate: marrowEnv.MARROW_WORKFLOW_GATE !== 'false',
-      requireOutcomeClosure: marrowEnv.MARROW_REQUIRE_OUTCOME_CLOSURE !== 'false',
+      includeValueReport: process.env.MARROW_PASSIVE_VALUE_REPORT !== 'false',
+      valueReportPeriod: process.env.MARROW_VALUE_REPORT_PERIOD || '7d',
+      useAgentRuntime: process.env.MARROW_AGENT_RUNTIME !== 'false',
+      useWorkflowGate: process.env.MARROW_WORKFLOW_GATE !== 'false',
+      requireOutcomeClosure: process.env.MARROW_REQUIRE_OUTCOME_CLOSURE !== 'false',
+      captureModelUsage: process.env.MARROW_PASSIVE_TOKEN_USAGE !== 'false',
     });
 
     runtime.install();
@@ -415,8 +322,6 @@ if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
   } catch {
     console.warn('[Marrow] passive runtime skipped: install @getmarrow/sdk or verify SDK initialization. Run npm install @getmarrow/sdk, then rerun npx @getmarrow/install --repair.');
   }
-} else if (!apiKey) {
-  console.warn('[Marrow] passive runtime skipped: MARROW_API_KEY missing. Put it in .marrow/env or run npx @getmarrow/install doctor for the exact fix.');
 }
 `;
 }
@@ -431,6 +336,7 @@ MARROW_PASSIVE_VALUE_REPORT=true
 MARROW_AGENT_RUNTIME=true
 MARROW_WORKFLOW_GATE=true
 MARROW_REQUIRE_OUTCOME_CLOSURE=true
+MARROW_PASSIVE_TOKEN_USAGE=true
 `;
 }
 
@@ -536,82 +442,6 @@ function inspectSdkDependency(detection) {
   };
 }
 
-function compareVersions(a, b) {
-  const left = String(a || '0.0.0').replace(/^[^\d]*/, '').split('.').map((part) => parseInt(part, 10) || 0);
-  const right = String(b || '0.0.0').replace(/^[^\d]*/, '').split('.').map((part) => parseInt(part, 10) || 0);
-  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
-    const x = left[i] || 0;
-    const y = right[i] || 0;
-    if (x > y) return 1;
-    if (x < y) return -1;
-  }
-  return 0;
-}
-
-function dependencyVersion(packageJson, packageName) {
-  for (const block of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
-    const value = packageJson?.[block]?.[packageName];
-    if (typeof value === 'string') return value;
-  }
-  return null;
-}
-
-function installedPackageVersion(root, packageName) {
-  const packageJsonPath = path.join(root, 'node_modules', ...packageName.split('/'), 'package.json');
-  try {
-    const raw = safeRead(packageJsonPath);
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    return typeof parsed.version === 'string' ? parsed.version : null;
-  } catch {
-    return null;
-  }
-}
-
-function inspectPackageVersions(detection) {
-  const rootPackage = safeRead(detection.paths.packageJson);
-  let packageJson = {};
-  try {
-    packageJson = rootPackage ? JSON.parse(rootPackage) : {};
-  } catch {
-    packageJson = {};
-  }
-  const versions = [
-    {
-      name: '@getmarrow/install',
-      installed: require('../package.json').version,
-      latest: INSTALLER_LATEST,
-      source: 'current installer',
-      update_command: 'npm install -g @getmarrow/install@latest',
-    },
-    {
-      name: '@getmarrow/sdk',
-      installed: installedPackageVersion(detection.root, '@getmarrow/sdk') || dependencyVersion(packageJson, '@getmarrow/sdk'),
-      latest: SDK_LATEST,
-      source: installedPackageVersion(detection.root, '@getmarrow/sdk') ? 'node_modules' : 'package.json',
-      update_command: 'npm install @getmarrow/sdk@latest',
-    },
-    {
-      name: '@getmarrow/mcp',
-      installed: installedPackageVersion(detection.root, '@getmarrow/mcp') || dependencyVersion(packageJson, '@getmarrow/mcp'),
-      latest: MCP_LATEST,
-      source: installedPackageVersion(detection.root, '@getmarrow/mcp') ? 'node_modules' : 'package.json',
-      update_command: 'npm install @getmarrow/mcp@latest',
-    },
-  ];
-  return versions.map((entry) => {
-    const normalized = entry.installed ? String(entry.installed).replace(/^[^\d]*/, '') : null;
-    const outdated = normalized ? compareVersions(normalized, entry.latest) < 0 : false;
-    return {
-      ...entry,
-      installed: normalized,
-      present: Boolean(normalized),
-      outdated,
-      warning: outdated ? `${entry.name} ${normalized} is older than ${entry.latest}.` : null,
-    };
-  });
-}
-
 function buildPlan(detection, options) {
   const mode = options.mode === 'auto'
     ? detection.node && (detection.claudeCode || detection.cursor || detection.codex || detection.openclaw)
@@ -716,108 +546,11 @@ async function requestJson(url, options) {
   }
   if (!res.ok) {
     const message = json.error || json.message || `HTTP ${res.status}`;
-    const error = new Error(String(message));
-    error.status = res.status;
-    error.code = json.code || null;
-    error.details = json.details || null;
-    throw error;
+    throw new Error(String(message));
   }
   return json.data || json;
 }
 
-function classifyDoctorFailure(error) {
-  const status = error?.status || 0;
-  const text = `${error?.code || ''} ${error?.message || error}`.toLowerCase();
-  if (status === 401 || /missing_key|invalid_key|unauthorized|invalid api key/.test(text)) return 'invalid_key';
-  if (status === 403 && /agent|bound|identity/.test(text)) return 'wrong_agent_id';
-  if (status === 403) return 'invalid_key';
-  if (status === 409 || /proof/.test(text)) return 'proof_required';
-  if (status === 429 || /rate limit|too many/.test(text)) return 'network_blocked';
-  if (status >= 500 || /timeout|network|fetch failed|econnreset|enotfound|eai_again/.test(text)) return 'network_blocked';
-  return 'unknown';
-}
-
-async function runDoctorValidation(options, selfTest) {
-  if (!options.apiKey) {
-    return {
-      key_found: false,
-      key_valid: false,
-      account_active: false,
-      agent_identity_accepted: false,
-      write_test_event: 'skipped',
-      outcome_closed: 'skipped',
-      failure_reason: 'missing_key',
-      exact_fix: 'Create an API key at https://getmarrow.ai/account, then put MARROW_API_KEY in .marrow/env and run npx @getmarrow/install doctor --self-test.',
-    };
-  }
-
-  if (selfTest && !selfTest.skipped && selfTest.active && !selfTest.error) {
-    return {
-      key_found: true,
-      key_valid: true,
-      account_active: true,
-      agent_identity_accepted: true,
-      write_test_event: 'passed',
-      outcome_closed: 'passed',
-      failure_reason: null,
-      decision_id: selfTest.decision_id,
-      exact_fix: null,
-    };
-  }
-
-  if (selfTest && selfTest.error) {
-    const reason = classifyDoctorFailure(selfTest);
-    return {
-      key_found: true,
-      key_valid: !['missing_key', 'invalid_key'].includes(reason),
-      account_active: !['missing_key', 'invalid_key'].includes(reason),
-      agent_identity_accepted: reason !== 'wrong_agent_id',
-      write_test_event: 'failed',
-      outcome_closed: 'failed',
-      failure_reason: reason,
-      exact_fix: reason === 'wrong_agent_id'
-        ? 'Set MARROW_FLEET_AGENT_ID/MARROW_AGENT_ID to the id bound to this key, then rerun doctor.'
-        : reason === 'network_blocked'
-        ? 'Retry from a network path that can reach api.getmarrow.ai, or reduce status polling if rate-limited.'
-        : 'Create/copy a live API key from the Marrow dashboard and update MARROW_API_KEY.',
-    };
-  }
-
-  const headers = { authorization: `Bearer ${options.apiKey}` };
-  if (options.agentId) headers['x-marrow-agent-id'] = options.agentId;
-  try {
-    const status = await requestJson(`${options.baseUrl.replace(/\/+$/, '')}/v1/agent/status`, { headers });
-    return {
-      key_found: true,
-      key_valid: true,
-      account_active: true,
-      agent_identity_accepted: true,
-      write_test_event: 'skipped',
-      outcome_closed: 'skipped',
-      failure_reason: null,
-      status_health: status.health || 'unknown',
-      status_failure_reasons: status.failure_reasons || [],
-      exact_fix: status.recommended_fix || status.diagnostics?.exact_fix || null,
-    };
-  } catch (error) {
-    const reason = classifyDoctorFailure(error);
-    return {
-      key_found: true,
-      key_valid: !['missing_key', 'invalid_key'].includes(reason),
-      account_active: !['missing_key', 'invalid_key'].includes(reason),
-      agent_identity_accepted: reason !== 'wrong_agent_id',
-      write_test_event: 'skipped',
-      outcome_closed: 'skipped',
-      failure_reason: reason,
-      exact_fix: reason === 'wrong_agent_id'
-        ? 'Set MARROW_FLEET_AGENT_ID/MARROW_AGENT_ID to the id bound to this key, then rerun doctor.'
-        : reason === 'network_blocked'
-        ? 'Check network access to api.getmarrow.ai and rerun doctor.'
-        : 'Create/copy a live API key from the Marrow dashboard and update MARROW_API_KEY.',
-    };
-  }
-}
-
 async function runSelfTest(options) {
   if (!options.selfTest) return { skipped: true, reason: 'disabled' };
   if (!options.apiKey) {
@@ -898,8 +631,14 @@ async function runSelfTest(options) {
     ok: false,
     error: error instanceof Error ? error.message : String(error),
   }));
-  const firstValueSignal = buildFirstValueSignal(status, runtime, performance, firstValue);
-  const installValueMoment = buildInstallValueMoment(firstValueSignal, status, runtime, performance, firstValue);
+  const valueProof = await requestJson(`${baseUrl}/v1/agent/value/proof?period_days=30`, { headers })
+    .catch((error) => ({
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  const tokenValueProof = buildTokenValueProof(valueProof);
+  const firstValueSignal = buildFirstValueSignal(status, runtime, performance, firstValue, tokenValueProof);
+  const installValueMoment = buildInstallValueMoment(firstValueSignal, status, runtime, performance, firstValue, tokenValueProof);
   return {
     skipped: false,
     decision_id: decisionId,
@@ -911,11 +650,11 @@ async function runSelfTest(options) {
     auto_outcome_closure: status.auto_outcome_closure || null,
     runtime_active: Boolean(runtime && runtime.ok !== false),
     runtime_exact_next_action: runtime.exact_next_action || null,
-    runtime_before_you_act: runtime.intervention?.agent_copy || runtime.intervention?.before_action || runtime.before_you_act || null,
-    runtime_intervention: runtime.intervention || null,
+    runtime_before_you_act: runtime.before_you_act || null,
     first_value: firstValue && firstValue.ok !== false ? firstValue : null,
     first_value_signal: firstValueSignal,
     install_value_moment: installValueMoment,
+    token_value_proof: tokenValueProof,
     performance_proof: performance && performance.ok !== false ? {
       avoided_mistakes: performance.avoided_mistakes ?? performance.avoided_repeated_mistakes ?? 0,
       reused_winning_decisions: performance.reused_winning_decisions ?? 0,
@@ -927,11 +666,30 @@ async function runSelfTest(options) {
   };
 }
 
-function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {}, performance = {}, firstValue = {}) {
+function buildTokenValueProof(valueProof = {}) {
+  const modelUsage = valueProof && valueProof.ok !== false
+    ? valueProof.model_usage || valueProof.token_value_signal || valueProof
+    : null;
+  if (!modelUsage || typeof modelUsage !== 'object') {
+    return {
+      enabled: true,
+      capture_default: 'on_when_sdk_mcp_or_installer_hooks_available',
+      observed: { model_calls: 0, tokens: { total: 0 } },
+      savings: { estimated_tokens_saved: 0, estimated_minutes_saved: 0, confidence: 'none', method: 'warming_up' },
+      proof_line: 'Token usage capture is ready; no model calls have been reported yet.',
+      exact_next_action: 'Keep passive token capture enabled so Marrow can attach usage proof after real model calls complete.',
+    };
+  }
+  return modelUsage;
+}
+
+function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {}, performance = {}, firstValue = {}, tokenValueProof = null) {
   if (firstValue && firstValue.ok !== false && firstValue.first_value) {
+    const proof = Array.isArray(firstValue.first_value.proof) ? [...firstValue.first_value.proof] : [];
+    if (tokenValueProof?.proof_line && !proof.includes(tokenValueProof.proof_line)) proof.push(tokenValueProof.proof_line);
     return {
       headline: firstValue.headline || firstValue.first_value.headline || 'Your agent is no longer starting from zero.',
-      proof: Array.isArray(firstValue.first_value.proof) ? firstValue.first_value.proof : [],
+      proof,
       fleet_signal: firstValue.history_signal?.summary || 'Fresh account: Marrow will build fleet memory from this first captured outcome.',
       try_this_now: firstValue.first_value.try_this_now || 'Ask your agent: "I am about to deploy to production. What should I check first?"',
       expected_response: firstValue.first_value.expected_response || 'Marrow should answer with a risk gate, required proof, and any matching fleet lessons before the agent acts.',
@@ -941,9 +699,7 @@ function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {
 
   const proof = firstValueSignal.value_proof || [];
   const hasFleetSignal = proof.length > 0;
-  const runtimeLesson = runtime.intervention?.agent_copy
-    || runtime.intervention?.before_action
-    || runtime.before_you_act
+  const runtimeLesson = runtime.before_you_act
     || runtime.before_you_act_injection?.message
     || runtime.exact_next_action
     || firstValueSignal.first_lesson;
@@ -954,18 +710,19 @@ function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {
       'Captured this setup decision',
       'Closed the outcome successfully',
       'Runtime gate is ' + (firstValueSignal.active ? 'active' : 'installed'),
-      runtime.intervention?.must_use_before_action ? 'Before-action intervention is active for risky work' : runtimeLesson ? 'Future risky work now gets a pre-action brief' : 'Future risky work now gets checked before action',
+      runtimeLesson ? 'Future risky work now gets a pre-action brief' : 'Future risky work now gets checked before action',
+      tokenValueProof?.proof_line || 'Token usage proof is active and warming up after the first model call',
     ],
     fleet_signal: hasFleetSignal
       ? 'Marrow already found signal: ' + proof.join('; ') + '.'
       : 'Fresh account: Marrow will start building fleet memory from this first captured outcome.',
     try_this_now: 'Ask your agent: "I am about to deploy to production. What should I check first?"',
-    expected_response: 'Marrow should answer with proceed/warn/block, required proof, and any matching prior lesson/playbook before the agent acts.',
-    first_lesson: runtimeLesson || 'Marrow will stop agents before risky or repeated work and surface the prior lesson/playbook.',
+    expected_response: 'Marrow should answer with a risk gate, required proof, and any matching fleet lessons before the agent acts.',
+    first_lesson: runtimeLesson || 'Marrow will surface prior lessons before risky or repeated work.',
   };
 }
 
-function buildFirstValueSignal(status, runtime, performance, firstValue = {}) {
+function buildFirstValueSignal(status, runtime, performance, firstValue = {}, tokenValueProof = null) {
   if (firstValue && firstValue.ok !== false && firstValue.first_value) {
     const capture = firstValue.capture || {};
     const proof = firstValue.value_proof || {};
@@ -974,11 +731,13 @@ function buildFirstValueSignal(status, runtime, performance, firstValue = {}) {
     if (Number(proof.reused_winning_decisions || 0) > 0) proofBits.push(`${proof.reused_winning_decisions} reused winning decision(s)`);
     if (Number(proof.prevented_bad_actions || 0) > 0) proofBits.push(`${proof.prevented_bad_actions} prevented risky action(s)`);
     if (Number(proof.estimated_tokens_saved || 0) > 0) proofBits.push(`~${proof.estimated_tokens_saved} tokens saved`);
+    if (Number(tokenValueProof?.savings?.estimated_tokens_saved || 0) > 0) proofBits.push(`~${tokenValueProof.savings.estimated_tokens_saved} measured model tokens saved`);
+    else if (tokenValueProof?.proof_line) proofBits.push(tokenValueProof.proof_line);
     return {
       active: Boolean(firstValue.active),
       headline: `Marrow active: ${(capture.surfaces || ['decisions']).join(', ')} captured.`,
       captured: capture.surfaces || ['decisions'],
-      first_lesson: firstValue.first_value.first_lesson || runtime?.intervention?.agent_copy,
+      first_lesson: firstValue.first_value.first_lesson,
       value_proof: proofBits,
       next_action: firstValue.next_action?.reason || 'Keep working; Marrow will capture outcomes and reuse lessons automatically.',
     };
@@ -1001,6 +760,8 @@ function buildFirstValueSignal(status, runtime, performance, firstValue = {}) {
   if (Number(proof.prevented_bad_actions || 0) > 0) proofBits.push(`${proof.prevented_bad_actions} prevented risky action(s)`);
   const tokens = proof.token_time_saved_estimate?.estimated_tokens_saved || 0;
   if (tokens > 0) proofBits.push(`~${tokens} tokens saved`);
+  if (Number(tokenValueProof?.savings?.estimated_tokens_saved || 0) > 0) proofBits.push(`~${tokenValueProof.savings.estimated_tokens_saved} measured model tokens saved`);
+  else if (tokenValueProof?.proof_line) proofBits.push(tokenValueProof.proof_line);
 
   const firstLesson = runtime.before_you_act
     || runtime.before_you_act_injection?.message
@@ -1064,6 +825,20 @@ function printReport(report) {
         process.stdout.write(`- Next: ${report.selfTest.first_value_signal.next_action}\n`);
       }
     }
+    if (report.selfTest.token_value_proof) {
+      const proof = report.selfTest.token_value_proof;
+      const observed = proof.observed || {};
+      const savings = proof.savings || {};
+      const tokens = observed.tokens || {};
+      process.stdout.write('\nToken value proof:\n');
+      process.stdout.write(`- passive capture: ${proof.enabled ? 'on' : 'unknown'}\n`);
+      process.stdout.write(`- model calls observed: ${observed.model_calls || 0}\n`);
+      process.stdout.write(`- tokens observed: ${tokens.total || 0}\n`);
+      process.stdout.write(`- estimated tokens saved: ${savings.estimated_tokens_saved || 0}\n`);
+      if (savings.confidence) process.stdout.write(`- confidence: ${savings.confidence}\n`);
+      if (proof.proof_line) process.stdout.write(`- proof: ${proof.proof_line}\n`);
+      if (proof.exact_next_action) process.stdout.write(`- next: ${proof.exact_next_action}\n`);
+    }
   }
 
   if (report.remediation) {
@@ -1103,24 +878,6 @@ function printReport(report) {
     process.stdout.write(`- missing env: ${report.doctor.missingEnv.length ? report.doctor.missingEnv.join(', ') : 'none'}\n`);
     if (report.doctor.envHints.length) process.stdout.write(`- possible env files: ${report.doctor.envHints.join(', ')}\n`);
     process.stdout.write(`- missing hooks/config: ${report.doctor.missingHooks.length ? report.doctor.missingHooks.join('; ') : 'none'}\n`);
-    if (report.doctor.validation) {
-      const validation = report.doctor.validation;
-      process.stdout.write(`- key found: ${validation.key_found ? 'yes' : 'no'}\n`);
-      process.stdout.write(`- key valid: ${validation.key_valid ? 'yes' : 'no'}\n`);
-      process.stdout.write(`- account active: ${validation.account_active ? 'yes' : 'no'}\n`);
-      process.stdout.write(`- agent identity accepted: ${validation.agent_identity_accepted ? 'yes' : 'no'}\n`);
-      process.stdout.write(`- write test event: ${validation.write_test_event}\n`);
-      process.stdout.write(`- outcome closed: ${validation.outcome_closed}\n`);
-      if (validation.failure_reason) process.stdout.write(`- failure reason: ${validation.failure_reason}\n`);
-      if (validation.exact_fix) process.stdout.write(`- exact fix: ${validation.exact_fix}\n`);
-    }
-    if (report.packageVersions?.length) {
-      const outdated = report.packageVersions.filter((pkg) => pkg.outdated);
-      process.stdout.write(`- package versions: ${outdated.length ? 'updates recommended' : 'current'}\n`);
-      for (const pkg of outdated) {
-        process.stdout.write(`  - ${pkg.warning} Fix: ${pkg.update_command}\n`);
-      }
-    }
     if (report.doctor.recommendedFix) process.stdout.write(`- recommended fix: ${report.doctor.recommendedFix}\n`);
   }
 
@@ -1143,7 +900,6 @@ async function install(options) {
   const changes = applyPlan(plan, options);
   const configInspection = inspectNpmTokenConfig();
   const sdkDependency = inspectSdkDependency(detection);
-  const packageVersions = inspectPackageVersions(detection);
   const configDiagnostics = configInspection.safe;
   const configRepairs = options.repair && !options.dryRun && !options.doctor
     ? repairConfigDiagnostics(configDiagnostics)
@@ -1153,11 +909,7 @@ async function install(options) {
     skipped: false,
     active: false,
     error: error instanceof Error ? error.message : String(error),
-    status: error?.status || null,
-    code: error?.code || null,
-    details: error?.details || null,
   }));
-  const doctorValidation = await runDoctorValidation(options, selfTest);
   const changedConfig = changes.some((change) => change.changed) || configRepairs.some((repair) => repair.changed);
   const selfTestPassed = Boolean(!selfTest.skipped && selfTest.active && !selfTest.error);
   const remediation = options.repair
@@ -1194,19 +946,16 @@ async function install(options) {
       missingEnv: options.apiKey ? [] : ['MARROW_API_KEY'],
       envHints,
       missingHooks: changes.filter((change) => change.changed).map((change) => change.label),
-      validation: doctorValidation,
-      packageVersions,
       recommendedFix: configDiagnostics.npm_token.recommended_fix || selfTest.recommended_fix || (!options.apiKey
         ? envHints.length
-          ? `MARROW_API_KEY was found in ${envHints[0]} and can now be auto-loaded by Marrow SDK/MCP runtimes. Run npx @getmarrow/install --repair to refresh hooks and self-test.`
-          : 'Set MARROW_API_KEY or MARROW_KEY in your shell, MCP secret store, .marrow/env, or ~/.marrow/env, then run npx @getmarrow/install --repair.'
+          ? `MARROW_API_KEY was found in a likely env file at ${envHints[0]}. Load that key from trusted secret storage, export only MARROW_API_KEY, then run npx @getmarrow/install --repair.`
+          : 'Set MARROW_API_KEY, then run npx @getmarrow/install --repair.'
         : null),
     },
     remediation,
     configDiagnostics,
     configRepairs,
     sdkDependency,
-    packageVersions,
     selfTest,
     warnings: options.keyFromArg
       ? ['Avoid --key in shared shells because command-line arguments can be visible in process listings. Prefer MARROW_API_KEY in your environment or secret manager.']
@@ -1237,10 +986,8 @@ module.exports = {
   runSelfTest,
   runCli,
   passiveRuntimeSource,
-  resolveMarrowKeyMaterial,
   inspectNpmTokenConfig,
   inspectSdkDependency,
-  inspectPackageVersions,
-  runDoctorValidation,
   buildInstallValueMoment,
+  buildTokenValueProof,
 };