@getmarrow/install 0.1.19 → 0.1.20

package/README.md

@@ -9,35 +9,32 @@ npx @getmarrow/install --dry-run
 npx @getmarrow/install --yes
 npx @getmarrow/install --repair
 npx @getmarrow/install doctor
+npx @getmarrow/install fleet
 ```
 
-## What's New in v0.1.19
+## What's New in v0.1.20
 
-v0.1.19 makes Marrow doctor and release smoke stricter, so agents know exactly why logging is degraded.
+v0.1.20 adds the Fleet Operator TUI for teams running multiple agents under one Marrow account.
 
-- `npx @getmarrow/install doctor --self-test` now validates: key found, key valid, account active, agent identity accepted, harmless write test created, and outcome closed.
-- Doctor reports exact failure reasons such as `missing_key`, `invalid_key`, `wrong_agent_id`, `network_blocked`, and `proof_required`.
-- Doctor warns when local `@getmarrow/install`, `@getmarrow/sdk`, or `@getmarrow/mcp` versions are behind the current release.
-- New `scripts/fresh-install-smoke.sh` verifies a clean temp install can load `.marrow/env`, run doctor, write a test event, and close the outcome.
-- Full keys are still never printed in diagnostics. Keep `.marrow/env` out of git and set file permissions to owner-only when possible.
+- `npx @getmarrow/install fleet` opens a terminal operator view when run in a real TTY.
+- CI/headless agents can use `npx @getmarrow/install fleet --no-interactive` for a stable text snapshot or `--json` for machine-readable status.
+- The view shows live agents, active workflows, risky actions waiting for proof, failed/stale outcomes, backpressure/capacity status, recent decisions, degraded hooks, and deploy/publish/merge gate posture.
+- Operators can press Enter to inspect an agent and print the exact fix command when hooks, outcome closure, or status coverage is degraded.
+- The command reads existing Marrow account endpoints and degrades gracefully when a route is unavailable, so it is safe to use during incidents.
 
-## What's New in v0.1.17
+Example:
 
-v0.1.17 expands the Govern TUI harness addon coverage while preserving adaptive mode recommendations.
-
-- `npx @getmarrow/install govern` now shows first-class rows for Codex, Claude Code, Cursor, Cline, Gemini CLI, Grok CLI, DeepSeek CLI, Minimax CLI, Kimi CLI, Hermes, GLM CLI, Qwen CLI, OpenCode, OpenClaw, MCP-compatible clients, CI scripts, and custom commands.
-- Marrow remains a thin governance layer. It does not replace your model or harness; it wraps the command your agent already runs with pre-action risk gates, proof requirements, and automatic outcome closure.
-- Detection stays recommendation-first. Marrow uses local config, instruction, CI, and MCP markers to suggest the safest path, then the user or owner accepts, overrides, or saves a policy profile.
-- Cursor is treated as a development workflow surface. Marrow can govern Cursor-backed code review, edits, tests, deploys, and release steps through MCP setup, project rules, or the governed command wrapper.
-- If a harness is not detected yet, use **Custom command** or `npx @getmarrow/install run -- <your-agent-command>` to govern it immediately.
-
-Business value: teams can add Marrow to the agent stack they already use instead of migrating to a new agent host. Codex, Claude Code, Cursor, Cline, Gemini, Grok, DeepSeek, Minimax, Kimi/Moonshot, Hermes, GLM, Qwen, OpenClaw, OpenCode, MCP clients, and CI scripts can all be brought under the same governance loop.
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet --no-interactive
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet --json
+```
 
 ## What's New in v0.1.14
 
 v0.1.14 adds adaptive governance mode recommendations without silent auto-switching.
 
-- `npx @getmarrow/install govern` now detects project signals such as `package.json`, deploy/publish scripts, platform config files, GitHub workflows, migrations, Cursor/Codex/Claude files, and MCP config.
+- `npx @getmarrow/install govern` now detects project signals such as `package.json`, deploy/publish scripts, `wrangler` config, GitHub workflows, migrations, Cursor/Codex/Claude files, and MCP config.
 - When `MARROW_API_KEY` is present, the TUI asks Marrow for a recommended mode: `passive`, `pilot`, or `enforce`.
 - The TUI shows the exact reasons, confidence, and selected command before the user applies anything.
 - User choice is explicit. Marrow logs whether the recommendation was accepted or overridden, but it does not silently switch modes.
@@ -49,7 +46,7 @@ Example recommendation:
 Recommended mode: pilot
 Reason:
 - Node project detected
-- Edge service detected
+- Cloudflare Worker detected
 - GitHub workflow detected
 - No owner approval policy configured yet
 ```
@@ -104,7 +101,7 @@ MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run --agent codex-prod --prof
 Gate a production action before the agent executes it:
 
 ```bash
-MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install gate "deploy production service after tests pass"
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install gate "deploy production worker after tests pass"
 ```
 
 Wrap a real deploy, publish, merge, or migration command only after the agent has the required proof:
@@ -115,7 +112,7 @@ MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run \
   --type deploy \
   --profile production \
   --policy enforce \
-  -- npm run deploy
+  -- wrangler deploy
 ```
 
 Use `--policy warn` for pilot mode and `--fail-open` only for non-production local workflows where Marrow should never block execution.
@@ -175,24 +172,49 @@ I am about to deploy to production. What should I check first?
 
 Marrow should answer with `proceed`, `warn`, `block`, or `owner_approval_required`, plus required proof and matching fleet lessons/playbooks before the agent acts. This is the first product moment: not just "hooks installed", but "the agent is being warned before risky work."
 
+## Fleet Scale Startup Guidance
+
+For business fleets, agents can read `GET /v1/agent/scale/capacity-contract` after install or during startup. The capacity contract tells the agent whether the account is under backpressure, when low-risk runtime guidance can be reused, when high-risk actions must still call Marrow, and how to batch low-risk telemetry through `/v1/agent/ingest/batch`.
+
+This keeps Marrow passive without making it chatty. The current contract models the common `50 businesses x 50 agents = 2,500 agents` rollout shape and gives agents an exact next action: cache low-risk runtime guidance briefly, batch command/tool telemetry, and preserve proof-gated checks for deploys, publishes, merges, migrations, secrets, billing, and destructive work.
+
+## Fleet Operator TUI
+
+Use the operator TUI when a human owner or orchestrator agent needs to understand fleet health before acting:
+
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet
+```
+
+It shows:
+
+- live agents and selected agent inspection
+- active workflows
+- risky actions waiting for proof
+- failed or stale outcomes
+- backpressure and capacity guidance
+- recent decisions
+- degraded hooks
+- deploy, publish, and merge gate status
+- exact fix commands for common degraded states
+
+For automated reports or headless agents:
+
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet --no-interactive
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install fleet --json
+```
+
 ## What It Detects
 
 - OpenClaw-style workspaces
 - Codex/agent instruction files such as `AGENTS.md`
 - Claude Code settings and hooks
 - Cursor project folders
-- Gemini, Grok, DeepSeek, Minimax, Kimi/Moonshot, Hermes, GLM, and Qwen project marker files when present
 - MCP config files
-- CI workflow/script markers
 - Node projects
 - Python projects
 
-The detector is intentionally conservative. If Marrow cannot identify the harness from local files, it still supports the workflow through the custom command path:
-
-```bash
-MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run --agent research-agent -- <your-agent-command>
-```
-
 ## Install Modes
 
 ```bash
@@ -233,14 +255,6 @@ Doctor check:
 MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install doctor
 ```
 
-Deep doctor with harmless write/outcome verification:
-
-```bash
-MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install doctor --self-test
-```
-
-Expected healthy output includes `key valid: yes`, `write test event: passed`, and `outcome closed: passed`.
-
 Repair missing hooks/config:
 
 ```bash

package/bin/marrow-install.js

@@ -4,7 +4,7 @@ const installer = require('../src/installer');
 const governedRunner = require('../src/governed-runner');
 
 const argv = process.argv.slice(2);
-const governedCommands = new Set(['run', 'gate', 'proof', 'status', 'govern']);
+const governedCommands = new Set(['run', 'gate', 'proof', 'status', 'govern', 'fleet']);
 const runCli = governedCommands.has(argv[0]) ? governedRunner.runCli : installer.runCli;
 
 runCli(argv).catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmarrow/install",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Universal installer for Marrow passive agent setup.",
   "bin": {
     "marrow-install": "bin/marrow-install.js"

package/src/governed-runner.js

@@ -8,6 +8,7 @@ const readline = require('node:readline');
 const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
 const HIGH_RISK_TERMS = /\b(deploy|prod|production|publish|release|merge|migration|migrate|secret|token|key|cloudflare|wrangler|npm publish|gh pr merge|git push|terraform apply|kubectl apply|delete|destroy|drop)\b/i;
 const GOVERN_TUI_ROW_COUNT = 7;
+const FLEET_TUI_ROW_COUNT = 11;
 function usage() {
   return `Usage:
   npx @getmarrow/install run --agent deploy-agent -- npm test
@@ -17,6 +18,7 @@ function usage() {
   npx @getmarrow/install status
   npx @getmarrow/install govern
   npx @getmarrow/install govern --no-interactive
+  npx @getmarrow/install fleet
 
 Commands:
   run       Run a command through Marrow pre-action gate and automatic outcome closure
@@ -24,6 +26,7 @@ Commands:
   proof     Commit an outcome/proof for an existing decision
   status    Read /v1/agent/status
   govern    Interactive setup TUI when run in a terminal; text panel in CI/non-TTY
+  fleet     Fleet operator TUI for live agents, workflows, gates, proof debt, and exact fixes
 
 Options:
   --agent <id>            Agent identity. Defaults to MARROW_FLEET_AGENT_ID, MARROW_AGENT_ID, or local user
@@ -40,7 +43,7 @@ Options:
   --key <key>             Marrow API key. Prefer MARROW_API_KEY
   --json                  Print machine-readable result after completion
   --interactive           Force interactive govern TUI when possible
-  --no-interactive        Print govern panel instead of opening the TUI
+  --no-interactive        Print govern/fleet panel instead of opening the TUI
 `;
 }
 
@@ -265,7 +268,7 @@ function parseArgs(argv) {
     return { command, options };
   }
 
-  if (command === 'status' || command === 'govern') {
+  if (command === 'status' || command === 'govern' || command === 'fleet') {
     const parsed = parseBaseOptions(argv, 1);
     if (parsed.options.help) return { command: 'help' };
     return { command, options: parsed.options };
@@ -568,29 +571,282 @@ async function statusOnly(parsed) {
   return requestJson(parsed.options, 'GET', '/v1/agent/status');
 }
 
-function existsAny(paths) {
-  return paths.some((candidate) => fs.existsSync(candidate));
+async function optionalRequestJson(options, method, route, body) {
+  try {
+    return { ok: true, data: await requestJson(options, method, route, body) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      status: error?.status || 0,
+      details: error?.details || null,
+    };
+  }
+}
+
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && value !== '') return value;
+  }
+  return undefined;
+}
+
+function numberValue(value, fallback = null) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value))) return Number(value);
+  return fallback;
+}
+
+function listValue(...values) {
+  for (const value of values) {
+    if (Array.isArray(value)) return value;
+  }
+  return [];
+}
+
+function statusLabel(value, fallback = 'unknown') {
+  if (typeof value === 'string' && value.trim()) return displayText(value, 80);
+  if (typeof value === 'boolean') return value ? 'ok' : 'warn';
+  return fallback;
+}
+
+function normalizeRecentDecisions(status, report, fleet) {
+  return listValue(
+    fleet.recent_decisions,
+    fleet.decisions,
+    report.recent_decisions,
+    report.decisions,
+    status.recent_decisions,
+    status.last_decisions,
+  ).slice(0, 5).map((decision) => {
+    if (typeof decision === 'string') return displayText(decision, 120);
+    return displayText(
+      firstDefined(
+        decision?.summary,
+        decision?.action,
+        decision?.type,
+        decision?.id,
+        decision?.decision_id,
+        JSON.stringify(decision || {}),
+      ),
+      120,
+    );
+  });
+}
+
+function normalizeAgents(report, fleet, status) {
+  return listValue(
+    fleet.agents,
+    fleet.live_agents,
+    fleet.active_agents,
+    report.agents,
+    report.active_agents,
+    status.agents,
+  ).slice(0, 20).map((agent) => {
+    if (typeof agent === 'string') return { id: displayText(agent, 80), status: 'active', role: '' };
+    return {
+      id: displayText(firstDefined(agent?.id, agent?.agent_id, agent?.name, agent?.key, 'agent'), 80),
+      status: displayText(firstDefined(agent?.status, agent?.health, agent?.state, 'active'), 40),
+      role: displayText(firstDefined(agent?.role, agent?.type, ''), 60),
+      last_seen_at: displayText(firstDefined(agent?.last_seen_at, agent?.last_event_at, agent?.updated_at, ''), 80),
+    };
+  });
+}
+
+function normalizeGates(status, report) {
+  const gateSource = status.gates || report.gates || {};
+  const gateValue = (name) => {
+    const value = firstDefined(
+      gateSource[name],
+      status[`${name}_gate`],
+      report[`${name}_gate`],
+      status[`${name}_status`],
+      report[`${name}_status`],
+    );
+    if (value && typeof value === 'object') {
+      return statusLabel(firstDefined(value.status, value.decision, value.enforcement_decision, value.state), 'unknown');
+    }
+    return statusLabel(value, 'unknown');
+  };
+  return {
+    deploy: gateValue('deploy'),
+    publish: gateValue('publish'),
+    merge: gateValue('merge'),
+  };
+}
+
+function normalizeFixCommands(status, capacity) {
+  const commands = [];
+  const add = (value, commandOnly = false) => {
+    const text = displayText(value || '', 240);
+    if (commandOnly && !/^(?:npx|npm|pnpm|yarn|node|export|MARROW_|curl|bash|sh)\b/.test(text)) return;
+    if (text && !commands.includes(text)) commands.push(text);
+  };
+  add(status.exact_fix);
+  add(status.recommended_fix);
+  add(status.next_action);
+  add(status.route_contract?.exact_fix);
+  add(status.auto_outcome_closure?.exact_fix);
+  add(status.capture_coverage?.exact_fix);
+  add(capacity.exact_next_action, true);
+  add(capacity.next_action, true);
+  if (listValue(status.missed_hooks, status.degraded_hooks).length) add('npx @getmarrow/install --repair');
+  if (status.auto_outcome_closure?.status === 'degraded') add('npx @getmarrow/install --repair');
+  return commands.slice(0, 6);
+}
+
+function normalizeFleetSnapshot(raw, options) {
+  const status = raw.status?.data || {};
+  const capacity = raw.capacity?.data || {};
+  const report = raw.report?.data || {};
+  const fleet = raw.fleet?.data || {};
+  const agents = normalizeAgents(report, fleet, status);
+  const liveAgents = numberValue(firstDefined(
+    fleet.live_agent_count,
+    fleet.active_agent_count,
+    fleet.fleet?.active_agents,
+    fleet.fleet?.total_agents,
+    report.live_agent_count,
+    report.active_agent_count,
+    report.fleet?.active_agents,
+    report.fleet?.total_agents,
+    status.live_agent_count,
+    status.active_agent_count,
+    agents.length || undefined,
+  ), agents.length || null);
+  const activeWorkflows = numberValue(firstDefined(
+    Array.isArray(fleet.active_workflows) ? fleet.active_workflows.length : undefined,
+    fleet.active_workflows,
+    fleet.active_workflow_count,
+    Array.isArray(report.active_workflows) ? report.active_workflows.length : undefined,
+    report.active_workflows,
+    report.active_workflow_count,
+    status.active_workflows,
+    status.active_workflow_count,
+    status.workflow_sessions?.active,
+  ), null);
+  const proofWaiting = numberValue(firstDefined(
+    status.proof_packs?.waiting,
+    status.proof_packs?.incomplete,
+    status.proof_pack_hygiene?.incomplete,
+    status.proof_pack_incomplete,
+    report.proof_packs?.waiting,
+    fleet.proof_packs?.waiting,
+  ), 0);
+  const failedStaleOutcomes = numberValue(firstDefined(
+    status.failed_stale_outcomes,
+    status.stale_outcomes,
+    status.auto_outcome_closure?.stale,
+    status.outcome_hygiene?.stale,
+    report.failed_outcomes,
+    fleet.failed_outcomes,
+  ), 0);
+  const missedHooks = listValue(status.missed_hooks, status.degraded_hooks, status.capture_coverage?.missed_hooks)
+    .map((hook) => displayText(typeof hook === 'string' ? hook : firstDefined(hook?.name, hook?.hook, JSON.stringify(hook)), 80))
+    .slice(0, 8);
+  const backpressure = capacity.current_backpressure || capacity.backpressure || capacity.scale_slo?.backpressure || {};
+  const backpressureStatus = statusLabel(firstDefined(
+    backpressure.status,
+    backpressure.level,
+    capacity.status,
+    capacity.scale_status,
+    capacity.agent_capacity?.status,
+  ), raw.capacity?.ok ? 'ok' : 'unknown');
+  const recentDecisions = normalizeRecentDecisions(status, report, fleet);
+  const gates = normalizeGates(status, report);
+  const fixCommands = normalizeFixCommands(status, capacity);
+  const errors = Object.entries(raw)
+    .filter(([, value]) => value && value.ok === false)
+    .map(([name, value]) => `${name}: ${displayText(value.error, 120)}`);
+
+  return {
+    ok: raw.status?.ok !== false,
+    generated_at: new Date().toISOString(),
+    agent_id: displayText(options.agentId, 80),
+    base_url: options.baseUrl,
+    live_agents: liveAgents,
+    active_workflows: activeWorkflows,
+    proof_waiting: proofWaiting,
+    failed_stale_outcomes: failedStaleOutcomes,
+    backpressure_status: backpressureStatus,
+    capacity_next_action: displayText(firstDefined(capacity.exact_next_action, capacity.next_action, capacity.failure_mode?.exact_next_action, ''), 180),
+    recent_decisions: recentDecisions,
+    degraded_hooks: missedHooks,
+    gates,
+    agents,
+    fix_commands: fixCommands.length ? fixCommands : ['npx @getmarrow/install doctor'],
+    source_errors: errors,
+  };
+}
+
+async function fleetSnapshot(options) {
+  if (!options.apiKey) {
+    return normalizeFleetSnapshot({
+      status: {
+        ok: false,
+        error: 'MARROW_API_KEY missing',
+        data: {
+          enabled: false,
+          missed_hooks: ['api_key'],
+          recommended_fix: 'export MARROW_API_KEY=mrw_live_... && npx @getmarrow/install fleet',
+        },
+      },
+      capacity: { ok: false, error: 'MARROW_API_KEY missing', data: {} },
+      report: { ok: false, error: 'MARROW_API_KEY missing', data: {} },
+      fleet: { ok: false, error: 'MARROW_API_KEY missing', data: {} },
+    }, options);
+  }
+  const [status, capacity, report, fleet] = await Promise.all([
+    optionalRequestJson(options, 'GET', '/v1/agent/status?fast=1'),
+    optionalRequestJson(options, 'GET', '/v1/agent/scale/capacity-contract'),
+    optionalRequestJson(options, 'GET', '/v1/agent/report'),
+    optionalRequestJson(options, 'GET', '/v1/fleet'),
+  ]);
+  return normalizeFleetSnapshot({ status, capacity, report, fleet }, options);
+}
+
+function fleetPanel(snapshot) {
+  const degraded = snapshot.degraded_hooks.length ? snapshot.degraded_hooks.join(', ') : 'none';
+  const recent = snapshot.recent_decisions.length ? snapshot.recent_decisions.map((item) => `  - ${item}`).join('\n') : '  - none reported yet';
+  const agents = snapshot.agents.length
+    ? snapshot.agents.slice(0, 5).map((agent) => `  - ${agent.id}${agent.role ? ` (${agent.role})` : ''}: ${agent.status}${agent.last_seen_at ? ` last_seen=${agent.last_seen_at}` : ''}`).join('\n')
+    : '  - no agent roster returned yet';
+  const fixes = snapshot.fix_commands.map((command) => `  - ${command}`).join('\n');
+  return [
+    'Marrow Fleet Operator',
+    '',
+    `Agent: ${snapshot.agent_id}`,
+    `Snapshot: ${snapshot.generated_at}`,
+    '',
+    `Live agents: ${snapshot.live_agents ?? 'unknown'}`,
+    `Active workflows: ${snapshot.active_workflows ?? 'unknown'}`,
+    `Risky actions waiting for proof: ${snapshot.proof_waiting}`,
+    `Failed/stale outcomes: ${snapshot.failed_stale_outcomes}`,
+    `Backpressure/capacity status: ${snapshot.backpressure_status}${snapshot.capacity_next_action ? ` - ${snapshot.capacity_next_action}` : ''}`,
+    `Degraded hooks: ${degraded}`,
+    `Deploy/publish/merge gates: deploy=${snapshot.gates.deploy} publish=${snapshot.gates.publish} merge=${snapshot.gates.merge}`,
+    '',
+    'Live agent roster:',
+    agents,
+    '',
+    'Recent decisions:',
+    recent,
+    '',
+    'Press Enter to inspect agent when run in an interactive terminal.',
+    'Copy exact fix command:',
+    fixes,
+    snapshot.source_errors.length ? ['', 'Partial data:', ...snapshot.source_errors.map((error) => `  - ${error}`)].join('\n') : '',
+  ].filter(Boolean).join('\n');
 }
 
 function detectHarnesses(cwd = process.cwd()) {
-  const home = os.homedir();
   const candidates = [
-    { name: 'Codex', command: 'codex', detected: existsAny([path.join(cwd, 'AGENTS.md'), path.join(cwd, '.codex'), path.join(home, '.codex')]) },
-    { name: 'Claude Code', command: 'claude -p', detected: existsAny([path.join(cwd, 'CLAUDE.md'), path.join(cwd, '.claude'), path.join(home, '.claude.json')]) },
-    { name: 'Cursor', command: 'cursor', detected: existsAny([path.join(cwd, '.cursor'), path.join(cwd, '.cursor', 'mcp.json'), path.join(cwd, '.cursor', 'rules'), path.join(home, '.cursor')]) },
-    { name: 'Gemini CLI', command: 'gemini', detected: existsAny([path.join(cwd, 'GEMINI.md'), path.join(cwd, '.gemini'), path.join(home, '.gemini')]) },
-    { name: 'Grok CLI', command: 'grok', detected: existsAny([path.join(cwd, 'GROK.md'), path.join(cwd, '.grok'), path.join(home, '.grok')]) },
-    { name: 'DeepSeek CLI', command: 'deepseek', detected: existsAny([path.join(cwd, 'DEEPSEEK.md'), path.join(cwd, '.deepseek'), path.join(home, '.deepseek')]) },
-    { name: 'Minimax CLI', command: 'minimax', detected: existsAny([path.join(cwd, 'MINIMAX.md'), path.join(cwd, '.minimax'), path.join(home, '.minimax')]) },
-    { name: 'Kimi CLI', command: 'kimi', detected: existsAny([path.join(cwd, 'KIMI.md'), path.join(cwd, 'MOONSHOT.md'), path.join(cwd, '.kimi'), path.join(cwd, '.moonshot'), path.join(home, '.kimi'), path.join(home, '.moonshot')]) },
-    { name: 'Hermes', command: 'hermes', detected: existsAny([path.join(cwd, 'HERMES.md'), path.join(cwd, 'hermes.json'), path.join(cwd, '.hermes'), path.join(home, '.hermes')]) },
-    { name: 'GLM CLI', command: 'glm', detected: existsAny([path.join(cwd, 'GLM.md'), path.join(cwd, '.glm'), path.join(home, '.glm')]) },
-    { name: 'Qwen CLI', command: 'qwen', detected: existsAny([path.join(cwd, 'QWEN.md'), path.join(cwd, '.qwen'), path.join(home, '.qwen')]) },
-    { name: 'Cline', command: 'cline', detected: existsAny([path.join(cwd, '.cline'), path.join(cwd, 'CLINE.md'), path.join(home, '.cline')]) },
-    { name: 'OpenCode', command: 'opencode', detected: existsAny([path.join(cwd, 'opencode.json'), path.join(cwd, '.opencode'), path.join(home, '.opencode')]) },
-    { name: 'OpenClaw', command: 'openclaw agent', detected: existsAny([path.join(cwd, 'openclaw.json'), path.join(home, '.openclaw')]) },
-    { name: 'MCP-compatible client', command: '<mcp-client>', detected: existsAny([path.join(cwd, '.mcp.json'), path.join(cwd, '.cursor', 'mcp.json'), path.join(cwd, '.claude', 'settings.json')]) },
-    { name: 'CI scripts', command: 'npm test', detected: existsAny([path.join(cwd, '.github', 'workflows'), path.join(cwd, '.gitlab-ci.yml'), path.join(cwd, 'package.json')]) },
+    { name: 'Codex', command: 'codex', detected: fs.existsSync(path.join(cwd, 'AGENTS.md')) || fs.existsSync(path.join(os.homedir(), '.codex')) },
+    { name: 'Claude Code', command: 'claude -p', detected: fs.existsSync(path.join(cwd, 'CLAUDE.md')) || fs.existsSync(path.join(os.homedir(), '.claude.json')) },
+    { name: 'Cursor', command: 'cursor', detected: fs.existsSync(path.join(cwd, '.cursor')) || fs.existsSync(path.join(os.homedir(), '.cursor')) },
+    { name: 'OpenCode', command: 'opencode', detected: fs.existsSync(path.join(cwd, 'opencode.json')) || fs.existsSync(path.join(os.homedir(), '.opencode')) },
+    { name: 'OpenClaw', command: 'openclaw agent', detected: fs.existsSync(path.join(os.homedir(), '.openclaw')) },
+    { name: 'CI script', command: 'npm test', detected: fs.existsSync(path.join(cwd, 'package.json')) },
     { name: 'Custom command', command: '<your-agent-command>', detected: true },
   ];
   return candidates;
@@ -791,6 +1047,112 @@ function renderGovernTui(state, options) {
   return lines.join('\n');
 }
 
+function buildFleetState(snapshot) {
+  return {
+    cursor: 0,
+    agentIndex: 0,
+    snapshot,
+    status: '',
+    lastResult: '',
+  };
+}
+
+function renderFleetTui(state) {
+  const snapshot = state.snapshot;
+  const selectedAgent = snapshot.agents[state.agentIndex] || { id: 'no agent returned', status: 'unknown', role: '' };
+  const degraded = snapshot.degraded_hooks.length ? snapshot.degraded_hooks.join(', ') : 'none';
+  const gateSummary = `deploy=${snapshot.gates.deploy} publish=${snapshot.gates.publish} merge=${snapshot.gates.merge}`;
+  const fixCommand = snapshot.fix_commands[0] || 'npx @getmarrow/install doctor';
+  const recent = snapshot.recent_decisions[0] || 'none reported yet';
+  const rows = [
+    {
+      label: 'Live agents',
+      value: `${snapshot.live_agents ?? 'unknown'} total; selected ${selectedAgent.id}`,
+      hint: 'Left/right changes the selected agent. Enter shows agent detail.',
+    },
+    {
+      label: 'Active workflows',
+      value: String(snapshot.active_workflows ?? 'unknown'),
+      hint: 'Current account-scoped workflow pressure from Marrow.',
+    },
+    {
+      label: 'Risky actions waiting for proof',
+      value: String(snapshot.proof_waiting),
+      hint: 'Deploy, publish, merge, migration, or sensitive actions waiting on proof packs.',
+    },
+    {
+      label: 'Failed/stale outcomes',
+      value: String(snapshot.failed_stale_outcomes),
+      hint: 'Outcome closure debt that can weaken fleet learning.',
+    },
+    {
+      label: 'Backpressure / capacity',
+      value: snapshot.backpressure_status,
+      hint: snapshot.capacity_next_action || 'Capacity contract loaded when available.',
+    },
+    {
+      label: 'Recent decisions',
+      value: recent,
+      hint: 'Latest fleet decision signal returned by Marrow.',
+    },
+    {
+      label: 'Degraded hooks',
+      value: degraded,
+      hint: degraded === 'none' ? 'No missing hooks reported.' : 'Repair hooks before trusting passive coverage.',
+    },
+    {
+      label: 'Deploy/publish/merge gates',
+      value: gateSummary,
+      hint: 'High-risk release surfaces should remain gated.',
+    },
+    {
+      label: 'Inspect agent',
+      value: selectedAgent.id,
+      hint: 'Press Enter to inspect agent.',
+    },
+    {
+      label: 'Copy exact fix command',
+      value: fixCommand,
+      hint: 'Press Enter to print this command back to the shell.',
+    },
+    {
+      label: 'Exit',
+      value: 'Return to shell',
+      hint: 'Press Enter, q, Esc, or Ctrl+C.',
+    },
+  ];
+  const lines = [
+    '\x1b[2J\x1b[H',
+    '+------------------------------------------------------------+',
+    '| Marrow Fleet Operator                                      |',
+    '| Live fleet health, proof debt, gates, and exact fixes       |',
+    '+------------------------------------------------------------+',
+    '',
+    `Agent: ${displayText(snapshot.agent_id, 36)}   Snapshot: ${displayText(snapshot.generated_at, 36)}`,
+    `API: ${displayText(snapshot.base_url, 60)}`,
+    '',
+    'Navigation: Up/Down move   Left/Right select agent   Enter inspect/print',
+    'Exit: q, Esc, or Ctrl+C',
+    '',
+  ];
+  rows.forEach((row, index) => {
+    lines.push(...renderOptionBox(row, index === state.cursor), '');
+  });
+  if (state.status) {
+    lines.push(`Status: ${displayText(state.status, 120)}`);
+  }
+  if (state.lastResult) {
+    lines.push('');
+    lines.push(displayText(state.lastResult, 700));
+  }
+  if (snapshot.source_errors.length) {
+    lines.push('');
+    lines.push('Partial data:');
+    for (const error of snapshot.source_errors.slice(0, 4)) lines.push(`- ${displayText(error, 120)}`);
+  }
+  return lines.join('\n');
+}
+
 function canUseInteractive(options, input = process.stdin, output = process.stdout) {
   if (options.interactive === false) return false;
   if (options.interactive === true) return Boolean(input.isTTY && output.isTTY);
@@ -980,6 +1342,99 @@ async function runGovernInteractive(options, input = process.stdin, output = pro
   }
 }
 
+async function runFleetInteractive(options, input = process.stdin, output = process.stdout) {
+  const snapshot = await fleetSnapshot(options);
+  if (options.json) return snapshot;
+  if (!canUseInteractive(options, input, output)) {
+    output.write(`${fleetPanel(snapshot)}\n`);
+    return snapshot;
+  }
+
+  const state = buildFleetState(snapshot);
+  readline.emitKeypressEvents(input);
+  input.setRawMode(true);
+  output.write('\x1b[?25l');
+
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (input.setRawMode) input.setRawMode(false);
+    output.write('\x1b[?25h');
+  };
+  const render = () => output.write(renderFleetTui(state));
+
+  render();
+  let keyHandler;
+  try {
+    await new Promise((resolve) => {
+      keyHandler = (str, key = {}) => {
+        if (key.ctrl && key.name === 'c') {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key.name === 'q' || key.name === 'escape' || str === 'q') {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key.name === 'up') {
+          state.cursor = (state.cursor + FLEET_TUI_ROW_COUNT - 1) % FLEET_TUI_ROW_COUNT;
+          render();
+        } else if (key.name === 'down') {
+          state.cursor = (state.cursor + 1) % FLEET_TUI_ROW_COUNT;
+          render();
+        } else if ((key.name === 'left' || key.name === 'right') && state.snapshot.agents.length) {
+          const direction = key.name === 'right' ? 1 : -1;
+          state.agentIndex = (state.agentIndex + direction + state.snapshot.agents.length) % state.snapshot.agents.length;
+          state.status = 'Agent selection changed.';
+          render();
+        } else if (key.name === 'return') {
+          if (state.cursor === 9) {
+            cleanup();
+            output.write(`\n${state.snapshot.fix_commands[0] || 'npx @getmarrow/install doctor'}\n`);
+            resolve();
+            return;
+          }
+          if (state.cursor === 10) {
+            cleanup();
+            resolve();
+            return;
+          }
+          const selectedAgent = state.snapshot.agents[state.agentIndex];
+          if (state.cursor === 0 || state.cursor === 8) {
+            state.lastResult = selectedAgent
+              ? `Agent ${selectedAgent.id}: status=${selectedAgent.status}${selectedAgent.role ? ` role=${selectedAgent.role}` : ''}${selectedAgent.last_seen_at ? ` last_seen=${selectedAgent.last_seen_at}` : ''}`
+              : 'No live agent roster returned yet. Check API key scope or wait for agents to log activity.';
+          } else if (state.cursor === 5) {
+            state.lastResult = state.snapshot.recent_decisions.length
+              ? state.snapshot.recent_decisions.map((decision, index) => `${index + 1}. ${decision}`).join('  ')
+              : 'No recent decisions returned yet.';
+          } else if (state.cursor === 6) {
+            state.lastResult = state.snapshot.degraded_hooks.length
+              ? `Degraded hooks: ${state.snapshot.degraded_hooks.join(', ')}. Fix: ${state.snapshot.fix_commands[0]}`
+              : 'No degraded hooks reported.';
+          } else if (state.cursor === 7) {
+            state.lastResult = `Release gates: deploy=${state.snapshot.gates.deploy}, publish=${state.snapshot.gates.publish}, merge=${state.snapshot.gates.merge}.`;
+          } else {
+            state.lastResult = fleetPanel(state.snapshot).replace(/\n/g, '  ');
+          }
+          state.status = 'Inspection updated.';
+          render();
+        }
+      };
+      input.on('keypress', keyHandler);
+    });
+  } finally {
+    if (keyHandler) input.off('keypress', keyHandler);
+    if (input.pause) input.pause();
+    cleanup();
+    output.write('\n');
+  }
+  return snapshot;
+}
+
 async function runCli(argv) {
   const parsed = parseArgs(argv);
   if (parsed.command === 'help') {
@@ -999,11 +1454,13 @@ async function runCli(argv) {
   else if (parsed.command === 'govern') {
     await runGovernInteractive(parsed.options);
     return;
+  } else if (parsed.command === 'fleet') {
+    result = await runFleetInteractive(parsed.options);
   }
 
   if (parsed.options?.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
   else if (result?.blocked) process.stderr.write(`BLOCKED: ${result.message || 'Marrow blocked this action.'}\n`);
-  else if (parsed.command !== 'run') process.stdout.write('Marrow command completed.\n');
+  else if (parsed.command !== 'run' && parsed.command !== 'fleet') process.stdout.write('Marrow command completed.\n');
 
   if (parsed.command === 'run' || result?.blocked) process.exitCode = result?.exitCode ?? (result?.ok === false ? 1 : 0);
 }
@@ -1016,7 +1473,6 @@ module.exports = {
   inferSurfaces,
   commandForSelection,
   buildGovernState,
-  detectHarnesses,
   detectProjectSignals,
   recommendGovernanceMode,
   recordGovernanceModeSelection,
@@ -1032,5 +1488,12 @@ module.exports = {
   runStatusCheck,
   runGateCheck,
   runGovernInteractive,
+  optionalRequestJson,
+  normalizeFleetSnapshot,
+  fleetSnapshot,
+  fleetPanel,
+  buildFleetState,
+  renderFleetTui,
+  runFleetInteractive,
   runCli,
 };

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
 `;
 }
 
@@ -166,7 +157,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 +183,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) || '';
@@ -335,79 +297,27 @@ 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.
 ${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',
     });
 
     runtime.install();
@@ -415,8 +325,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.');
 }
 `;
 }
@@ -536,82 +444,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 +548,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) {
@@ -1103,24 +838,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 +860,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 +869,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 +906,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 +946,7 @@ module.exports = {
   runSelfTest,
   runCli,
   passiveRuntimeSource,
-  resolveMarrowKeyMaterial,
   inspectNpmTokenConfig,
   inspectSdkDependency,
-  inspectPackageVersions,
-  runDoctorValidation,
   buildInstallValueMoment,
 };