@getmarrow/install 0.1.24 → 0.1.25

package/README.md

@@ -1,40 +1,97 @@
 # @getmarrow/install
 
-Universal installer for Marrow agent governance, proof, and passive control setup.
+Universal installer for Marrow passive agent setup.
 
-Use it when you want Marrow to detect the local agent/runtime environment and wire the safest passive governance integration automatically.
+Use it when you want Marrow to detect the local agent/runtime environment and wire the safest passive integration automatically.
 
 ```bash
 npx @getmarrow/install --dry-run
 npx @getmarrow/install --yes
 npx @getmarrow/install --repair
 npx @getmarrow/install doctor
+npx @getmarrow/install fleet
+npx @getmarrow/install integrations
+npx @getmarrow/install hermes
+npx @getmarrow/install openclaw
 ```
 
-## What's New in v0.1.24
+## What's New in v0.1.25
 
-v0.1.24 aligns the installer docs with Marrow's control-plane direction.
+v0.1.25 adds first-class harness add-on paths for Hermes Agent and OpenClaw.
 
-- Marrow is positioned as an agent governance, proof, and intelligence layer, not a single-agent memory app.
-- The recommended setup path remains passive by default: install once, then let agents call runtime gates, completion contracts, and outcome closure as they work.
-- Hermes Agent is a supported client label and integration target; Marrow maps Hermes goals, verification evidence, learning, journey, and subagent outcomes into fleet governance proof.
-- New backend surfaces include governance control-plane proof, completion-contract evaluation, fleet governance timeline, and buyer-grade value proof.
+- `npx @getmarrow/install integrations` lists Marrow-supported harness add-ons.
+- `npx @getmarrow/install hermes` shows the Hermes attachment path and, when `MARROW_API_KEY` is present, verifies the backend integration contract.
+- `npx @getmarrow/install openclaw` shows the OpenClaw attachment path and verifies the backend integration contract.
+- `npx @getmarrow/install govern` now detects Hermes config files alongside Codex, Claude Code, Cursor, OpenCode, OpenClaw, CI scripts, and custom commands.
+- Hermes `/goal`, verification evidence, `/learn`, `/journey`, and background subagents map into Marrow runtime gates, proof packs, fleet lessons, governance timeline, and outcome closure.
+- OpenClaw sessions, handoff/result files, watchdog checkpoints, silent exits, and release supervisor results map into Marrow workflow sessions, proof packs, stale-outcome detection, and reusable handoff lessons.
 
-## What's New in v0.1.23
+This is the intended positioning: keep the harness your team already uses, and add Marrow as the governance, proof, and fleet-intelligence layer around it.
 
-v0.1.23 improves attribution quality so Marrow can produce cleaner per-agent, per-harness, and per-workflow value reports.
+Examples:
 
-- Installer self-tests and governed runner calls attach `source_meta.channel`, `source_meta.client`, and inferred workflow intent by default.
-- Generated passive runtime keeps using SDK defaults for `agent_id`, harness/client, source channel, and user intent attribution.
-- Set `MARROW_CLIENT`, `MARROW_HARNESS`, or `MARROW_AGENT_CLIENT` to labels such as `codex`, `claude-code`, `cursor`, `gemini`, `qwen`, `opencode`, `hermes`, `openclaw`, or `custom`.
-- Invalid or unknown client labels fall back to `custom` instead of breaking onboarding.
-- Marrow still does not store prompts, completions, tool stdout/stderr, plaintext API keys, or raw model output for this feature.
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install hermes
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install openclaw
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install integrations --json
+```
+
+## What's New in v0.1.20
+
+v0.1.20 adds the Fleet Operator TUI for teams running multiple agents under one Marrow account.
+
+- `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.
+
+Example:
+
+```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, `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.
+- Policy profiles are supported by the backend/SDK/MCP so businesses can define rules like local=passive, staging=pilot, production deploys=enforce.
+
+Example recommendation:
+
+```text
+Recommended mode: pilot
+Reason:
+- Node project detected
+- Cloudflare Worker detected
+- GitHub workflow detected
+- No owner approval policy configured yet
+```
+
+## What's New in v0.1.13
+
+v0.1.13 turns `npx @getmarrow/install govern` into an interactive terminal setup flow when run in a real TTY.
 
-Business value: dashboards and reports can show which agents, harnesses, and workflow types are improving instead of grouping too much work into "unknown."
+- Select Codex, Claude Code, Cursor, OpenCode, OpenClaw, CI scripts, or a custom command with arrow keys.
+- Choose passive setup, governed pilot mode, or governed enforce mode.
+- Run passive setup + self-test from the TUI after explicit confirmation.
+- Check Marrow status and test the before-action gate from the same screen.
+- Print the exact command for the selected harness/mode so users know what to run next.
+- Exit cleanly with `q`, `Esc`, or `Ctrl+C`.
+- CI/non-TTY usage remains stable with `npx @getmarrow/install govern --no-interactive`.
 
-## Governed Runner
+This keeps Marrow passive-first: install once, verify Marrow is active, then let agents use the runtime/gate path automatically for risky work.
 
-The Marrow governed runner is for businesses that want agent governance without replacing their existing harness.
+## What's New in v0.1.12
+
+v0.1.12 adds the Marrow governed runner for businesses that want agent governance without replacing their existing harness.
 
 - `npx @getmarrow/install govern` prints a setup panel for detected harnesses and recommended protected commands.
 - `npx @getmarrow/install run --agent <agent-id> -- <command>` wraps existing agent, deploy, merge, publish, migration, and verification commands with Marrow's pre-action runtime gate.
@@ -53,6 +110,12 @@ Preview the detected harnesses and protected command examples:
 npx @getmarrow/install govern
 ```
 
+In a real terminal, this opens the interactive setup flow. In CI or scripts, use:
+
+```bash
+npx @getmarrow/install govern --no-interactive
+```
+
 Run a harmless command through Marrow:
 
 ```bash
@@ -78,6 +141,15 @@ MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run \
 
 Use `--policy warn` for pilot mode and `--fail-open` only for non-production local workflows where Marrow should never block execution.
 
+## What's New in v0.1.10
+
+- First-run output now explains the value in agent/user language: your agent is no longer starting from zero.
+- Self-test prints first proof: setup decision captured, outcome closed, runtime gate active, and risky work now gets a pre-action brief.
+- Fresh accounts get a guided prompt to try immediately: "I am about to deploy to production. What should I check first?"
+- Existing accounts/fleets show stronger proof when available: avoided mistakes, reused winning decisions, prevented risky actions, and token/time savings.
+- Generated SDK passive runtime now fails soft if `@getmarrow/sdk` is missing and the installer prints the exact dependency fix.
+- Docs now make the universal installer the default path; SDK and MCP are advanced/manual integration paths.
+
 ## Which Install Path Should I Use?
 
 Start here unless you already know you need a lower-level integration:
@@ -95,14 +167,6 @@ Use the lower-level packages only when you need direct control:
 
 The three packages are not three competing onboarding paths. `@getmarrow/install` is the front door; SDK and MCP are the implementation paths underneath it.
 
-For cleaner attribution, set an agent id and optional client label before install:
-
-```bash
-export MARROW_FLEET_AGENT_ID=codex-deploy-agent
-export MARROW_CLIENT=codex
-npx @getmarrow/install --yes
-```
-
 ## Agent Value Proof Quickstart
 
 One command should prove Marrow is active and useful:
@@ -118,9 +182,7 @@ Expected result:
 - `/v1/agent/status` confirms capture health and missing hooks.
 - `/v1/agent/runtime` verifies the one-call runtime gate and returns the before-action intervention contract.
 - `/v1/agent/first-value` returns the five-minute proof payload used by installer, SDK, and MCP clients.
-- `/v1/agent/value/proof` returns token value proof from passive model-usage capture.
 - The installer prints: "Your agent is no longer starting from zero."
-- The installer prints: "Token value proof" with capture status, observed model calls, token totals, estimated savings, confidence, and exact next action.
 - Fresh accounts get a first useful action to try immediately.
 - Accounts with history get proof such as avoided mistakes, reused winning decisions, prevented risky actions, or estimated time/token savings.
 
@@ -134,9 +196,43 @@ 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
+- Hermes Agent config files
 - Codex/agent instruction files such as `AGENTS.md`
 - Claude Code settings and hooks
 - Cursor project folders
@@ -166,7 +262,7 @@ npx @getmarrow/install --md --dry-run
 
 ## Self-Test
 
-When `MARROW_API_KEY` is present, the installer creates a harmless test decision, commits the outcome, reads `/v1/agent/status`, calls the one-call runtime, reads `/v1/agent/value/proof`, and prints the first useful Marrow signal plus token value proof.
+When `MARROW_API_KEY` is present, the installer creates a harmless test decision, commits the outcome, reads `/v1/agent/status`, calls the one-call runtime, and prints the first useful Marrow signal.
 
 ```bash
 MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install --yes
@@ -200,34 +296,6 @@ npm install @getmarrow/sdk
 
 The generated runtime now fails soft with an explicit warning if the SDK package is missing, so onboarding does not crash a user process.
 
-## Passive Token Value Proof
-
-Token value proof is default-on when the installer writes `.marrow/passive-runtime.mjs`.
-
-In supported Node/TypeScript agents, the SDK passive runtime wraps outbound model-provider `fetch` responses and captures compact `usage` blocks when providers return them. MCP and harness integrations can also attach `model_usage` to `marrow_commit` or call `marrow_model_usage` when the harness exposes usage metadata.
-
-Captured fields are intentionally narrow:
-
-- provider and model
-- input, output, cached, and total token counts
-- optional cost and latency estimates
-- agent, workflow, session, and decision linkage
-- Marrow intervention type, such as `runtime_gate`, `proof_pack`, or `before_you_act`
-
-Marrow does not capture prompt text, completion text, raw tool output, command output, full environment values, or plaintext secrets for token value proof.
-
-Disable capture only when a project requires it:
-
-```bash
-MARROW_PASSIVE_TOKEN_USAGE=false
-```
-
-Day-one behavior:
-
-- Fresh install: `Token usage capture is ready; no model calls have been reported yet.`
-- After observed usage: Marrow reports model calls, total tokens, estimated tokens saved, confidence, trend, and next action.
-- After workflows complete: agents should show the returned `token_value_signal` or value proof in owner updates so users see savings without opening a dashboard.
-
 
 ## Trust and Data Boundaries
 

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', 'fleet']);
+const governedCommands = new Set(['run', 'gate', 'proof', 'status', 'govern', 'fleet', 'hermes', 'openclaw', 'integrations']);
 const runCli = governedCommands.has(argv[0]) ? governedRunner.runCli : installer.runCli;
 
 runCli(argv).catch((error) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@getmarrow/install",
-  "version": "0.1.24",
-  "description": "Universal installer for Marrow agent governance, proof, and passive control setup.",
+  "version": "0.1.25",
+  "description": "Universal installer for Marrow passive agent setup.",
   "bin": {
     "marrow-install": "bin/marrow-install.js"
   },
@@ -15,10 +15,9 @@
     "marrow",
     "mcp",
     "installer",
-    "passive-runtime",
     "governance",
-    "proof-packs",
-    "agent-control-plane"
+    "runner",
+    "passive-runtime"
   ],
   "repository": {
     "type": "git",

package/src/governed-runner.js

@@ -9,36 +9,6 @@ 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;
-const SOURCE_CLIENTS = new Set(['claude-code', 'cursor', 'windsurf', 'openclaw', 'codex', 'gemini', 'grok', 'deepseek', 'qwen', 'kimi', 'minimax', 'cline', 'opencode', 'hermes', 'glm', 'custom', 'unknown']);
-
-function sourceClient() {
-  const raw = String(process.env.MARROW_CLIENT || process.env.MARROW_HARNESS || process.env.MARROW_AGENT_CLIENT || '').trim().toLowerCase().replace(/\s+/g, '-').replace(/^@/, '');
-  const aliases = {
-    claude: 'claude-code',
-    claude_code: 'claude-code',
-    'claude-code': 'claude-code',
-    cursor: 'cursor',
-    windsurf: 'windsurf',
-    openclaw: 'openclaw',
-    codex: 'codex',
-    'openai-codex': 'codex',
-    gemini: 'gemini',
-    google: 'gemini',
-    grok: 'grok',
-    deepseek: 'deepseek',
-    qwen: 'qwen',
-    kimi: 'kimi',
-    minimax: 'minimax',
-    cline: 'cline',
-    opencode: 'opencode',
-    'open-code': 'opencode',
-    hermes: 'hermes',
-    'hermes-agent': 'hermes',
-    glm: 'glm',
-  };
-  return aliases[raw] || (SOURCE_CLIENTS.has(raw) ? raw : 'custom');
-}
-
 function usage() {
   return `Usage:
   npx @getmarrow/install run --agent deploy-agent -- npm test
@@ -49,6 +19,9 @@ function usage() {
   npx @getmarrow/install govern
   npx @getmarrow/install govern --no-interactive
   npx @getmarrow/install fleet
+  npx @getmarrow/install integrations
+  npx @getmarrow/install hermes
+  npx @getmarrow/install openclaw
 
 Commands:
   run       Run a command through Marrow pre-action gate and automatic outcome closure
@@ -57,6 +30,9 @@ Commands:
   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
+  integrations List Marrow-supported harness add-ons
+  hermes    Show and verify the Marrow add-on path for Hermes Agent
+  openclaw  Show and verify the Marrow add-on path for OpenClaw
 
 Options:
   --agent <id>            Agent identity. Defaults to MARROW_FLEET_AGENT_ID, MARROW_AGENT_ID, or local user
@@ -185,6 +161,12 @@ function detectProjectSignals(cwd = process.cwd()) {
   addFile('CLAUDE.md', 'agent_instructions');
   addFile('.mcp.json', 'mcp_config');
   addFile('.cursor', 'cursor_project');
+  addFile('hermes.json', 'hermes_config');
+  addFile('hermes.yaml', 'hermes_config');
+  addFile('hermes.yml', 'hermes_config');
+  addFile('.hermes', 'hermes_config');
+  addFile('openclaw.json', 'openclaw_config');
+  addFile('.openclaw', 'openclaw_config');
 
   for (const script of packageScripts) {
     if (/\b(deploy|publish|release|migrate|migration|smoke|check|test)\b/i.test(script)) {
@@ -298,7 +280,7 @@ function parseArgs(argv) {
     return { command, options };
   }
 
-  if (command === 'status' || command === 'govern' || command === 'fleet') {
+  if (command === 'status' || command === 'govern' || command === 'fleet' || command === 'hermes' || command === 'openclaw' || command === 'integrations') {
     const parsed = parseBaseOptions(argv, 1);
     if (parsed.options.help) return { command: 'help' };
     return { command, options: parsed.options };
@@ -313,7 +295,6 @@ function headers(options) {
     'Content-Type': 'application/json',
     'X-Marrow-Agent-Id': options.agentId,
     'X-Marrow-Session-Id': options.sessionId,
-    'X-Marrow-Client': sourceClient(),
     'User-Agent': '@getmarrow/install governed-runner',
   };
   return h;
@@ -480,11 +461,6 @@ async function createDecision(options, action, type) {
       profile: options.profile,
       governed: true,
     },
-    source_meta: {
-      channel: 'cli',
-      client: sourceClient(),
-      user_intent: type === 'deploy' ? 'deploy' : 'operate',
-    },
   });
 }
 
@@ -724,13 +700,10 @@ function normalizeFixCommands(status, capacity) {
   add(status.route_contract?.exact_fix);
   add(status.auto_outcome_closure?.exact_fix);
   add(status.capture_coverage?.exact_fix);
-  add(status.token_capture?.exact_fix);
-  add(status.token_capture?.fix_command, true);
   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');
-  if (status.token_capture?.detected === false) add('npx @getmarrow/install --repair');
   return commands.slice(0, 6);
 }
 
@@ -884,6 +857,7 @@ function detectHarnesses(cwd = process.cwd()) {
     { 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: 'Hermes Agent', command: 'hermes', detected: fs.existsSync(path.join(cwd, 'hermes.json')) || fs.existsSync(path.join(cwd, '.hermes')) || fs.existsSync(path.join(os.homedir(), '.hermes')) || fs.existsSync(path.join(os.homedir(), '.hermes-agent')) },
     { 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 },
@@ -891,6 +865,140 @@ function detectHarnesses(cwd = process.cwd()) {
   return candidates;
 }
 
+function localIntegrationManifest(name) {
+  const key = String(name || '').toLowerCase().replace(/\s+/g, '-');
+  if (key === 'hermes' || key === 'hermes-agent') {
+    return {
+      integration: 'hermes-agent',
+      title: 'Marrow + Hermes Agent',
+      client_label: 'hermes',
+      command: 'hermes',
+      install_command: 'MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install hermes',
+      governed_command: 'MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run --agent hermes-prod --profile production --policy enforce -- hermes',
+      capture_points: [
+        '/goal -> Marrow completion contract',
+        'verification evidence -> Marrow proof pack',
+        '/learn -> outcome-ranked fleet lesson',
+        '/journey -> governance timeline',
+        'background subagents -> agent_id + source_meta.client=hermes',
+      ],
+      exact_next_action: 'Run the Hermes add-on, then call Marrow runtime before deploy, merge, publish, migration, credential, or customer-facing work.',
+    };
+  }
+  if (key === 'openclaw' || key === 'open-claw') {
+    return {
+      integration: 'openclaw',
+      title: 'Marrow + OpenClaw',
+      client_label: 'openclaw',
+      command: 'openclaw agent',
+      install_command: 'MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install openclaw',
+      governed_command: 'MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install run --agent openclaw-release --profile production --policy enforce -- openclaw agent',
+      capture_points: [
+        'agent sessions -> workflow sessions',
+        'handoff/result files -> proof packs',
+        'timeouts/silent quits -> failed or stale outcomes',
+        'release supervisor results -> deploy proof',
+        'watchdog checkpoints -> fleet handoff lessons',
+      ],
+      exact_next_action: 'Run the OpenClaw add-on, then wrap release and handoff commands with the Marrow governed runner.',
+    };
+  }
+  return null;
+}
+
+async function integrationManifest(options, name) {
+  const local = localIntegrationManifest(name);
+  if (!local) throw new Error(`Unsupported integration: ${name}`);
+  if (!options.apiKey) return { source: 'local', manifest: local };
+  const route = name === 'openclaw' ? '/v1/agent/integrations/openclaw' : '/v1/agent/integrations/hermes';
+  try {
+    const remote = await requestJson(options, 'GET', route);
+    return { source: 'api', manifest: remote };
+  } catch (error) {
+    return { source: 'local', manifest: { ...local, api_warning: error instanceof Error ? error.message : String(error) } };
+  }
+}
+
+function renderIntegrationPanel(name, manifest, source = 'local', detectedHarnesses = detectHarnesses()) {
+  const title = manifest.title || (manifest.integration === 'openclaw' ? 'Marrow + OpenClaw' : 'Marrow + Hermes Agent');
+  const capturePoints = Array.isArray(manifest.capture_points)
+    ? manifest.capture_points.map((point) => {
+      if (typeof point === 'string') return point;
+      return `${point.harness_surface || point.hermes_surface || 'harness event'} -> ${point.marrow_mapping || 'Marrow event'}`;
+    })
+    : [];
+  const installCommands = Array.isArray(manifest.install_commands)
+    ? manifest.install_commands
+    : [manifest.install_command, manifest.governed_command].filter(Boolean);
+  const detected = detectedHarnesses.find((harness) => harness.name.toLowerCase().includes(name === 'openclaw' ? 'openclaw' : 'hermes'))?.detected;
+  const lines = [
+    title,
+    '',
+    `Status: ${manifest.status || 'supported'} (${source})`,
+    `Detected locally: ${detected ? 'yes' : 'not yet'}`,
+    `Client label: ${manifest.client_label}`,
+    '',
+    'What Marrow captures:',
+    ...capturePoints.map((point) => `  - ${displayText(point, 110)}`),
+    '',
+    'Install / run:',
+    ...installCommands.map((command) => `  ${displayText(command, 140)}`),
+    '',
+    'Why this matters:',
+    `  ${displayText(manifest.marrow_positioning || 'Keep the harness. Add Marrow governance, proof packs, outcomes, and buyer-grade fleet value.', 140)}`,
+    '',
+    `Next: ${displayText(manifest.exact_next_action, 140)}`,
+  ];
+  if (manifest.api_warning) lines.push('', `API warning: ${displayText(manifest.api_warning, 120)}`);
+  return lines.join('\n');
+}
+
+async function integrationOnly(parsed, name) {
+  const result = await integrationManifest(parsed.options, name);
+  const panel = renderIntegrationPanel(name, result.manifest, result.source);
+  if (parsed.options.json) {
+    return {
+      ok: true,
+      source: result.source,
+      integration: result.manifest,
+      panel,
+    };
+  }
+  process.stdout.write(`${panel}\n`);
+  return { ok: true, source: result.source, integration: result.manifest };
+}
+
+async function integrationsOnly(parsed) {
+  const local = {
+    integration_registry_version: 'local.harness-addons-v1',
+    supported_harnesses: ['hermes', 'openclaw'].map((name) => localIntegrationManifest(name)),
+    exact_next_action: 'Run npx @getmarrow/install hermes or npx @getmarrow/install openclaw for a harness-specific setup path.',
+  };
+  let registry = local;
+  let source = 'local';
+  if (parsed.options.apiKey) {
+    try {
+      registry = await requestJson(parsed.options, 'GET', '/v1/agent/integrations');
+      source = 'api';
+    } catch (error) {
+      registry = { ...local, api_warning: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  if (parsed.options.json) return { ok: true, source, registry };
+  const harnesses = Array.isArray(registry.supported_harnesses) ? registry.supported_harnesses : [];
+  process.stdout.write([
+    'Marrow Harness Integrations',
+    '',
+    `Source: ${source}`,
+    'Supported add-ons:',
+    ...harnesses.map((harness) => `  - ${displayText(harness.client_label || harness.integration || harness.title, 40)}  ${displayText(harness.install_command || harness.install_commands?.[0] || '', 120)}`),
+    '',
+    `Next: ${displayText(registry.exact_next_action, 140)}`,
+    registry.api_warning ? `API warning: ${displayText(registry.api_warning, 120)}` : '',
+  ].filter(Boolean).join('\n') + '\n');
+  return { ok: true, source, registry };
+}
+
 function governPanel(options) {
   const rows = detectHarnesses();
   const project = detectProjectSignals();
@@ -1495,11 +1603,17 @@ async function runCli(argv) {
     return;
   } else if (parsed.command === 'fleet') {
     result = await runFleetInteractive(parsed.options);
+  } else if (parsed.command === 'hermes') {
+    result = await integrationOnly(parsed, 'hermes');
+  } else if (parsed.command === 'openclaw') {
+    result = await integrationOnly(parsed, 'openclaw');
+  } else if (parsed.command === 'integrations') {
+    result = await integrationsOnly(parsed);
   }
 
   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' && parsed.command !== 'fleet') process.stdout.write('Marrow command completed.\n');
+  else if (!['run', 'fleet', 'hermes', 'openclaw', 'integrations'].includes(parsed.command)) process.stdout.write('Marrow command completed.\n');
 
   if (parsed.command === 'run' || result?.blocked) process.exitCode = result?.exitCode ?? (result?.ok === false ? 1 : 0);
 }
@@ -1534,5 +1648,9 @@ module.exports = {
   buildFleetState,
   renderFleetTui,
   runFleetInteractive,
+  localIntegrationManifest,
+  renderIntegrationPanel,
+  integrationOnly,
+  integrationsOnly,
   runCli,
 };

package/src/installer.js

@@ -6,35 +6,6 @@ const crypto = require('node:crypto');
 const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
 const MARROW_BLOCK_START = '<!-- marrow:passive-start -->';
 const MARROW_BLOCK_END = '<!-- marrow:passive-end -->';
-const SOURCE_CLIENTS = new Set(['claude-code', 'cursor', 'windsurf', 'openclaw', 'codex', 'gemini', 'grok', 'deepseek', 'qwen', 'kimi', 'minimax', 'cline', 'opencode', 'hermes', 'glm', 'custom', 'unknown']);
-
-function sourceClient() {
-  const raw = String(process.env.MARROW_CLIENT || process.env.MARROW_HARNESS || process.env.MARROW_AGENT_CLIENT || '').trim().toLowerCase().replace(/\s+/g, '-').replace(/^@/, '');
-  const aliases = {
-    claude: 'claude-code',
-    claude_code: 'claude-code',
-    'claude-code': 'claude-code',
-    cursor: 'cursor',
-    windsurf: 'windsurf',
-    openclaw: 'openclaw',
-    codex: 'codex',
-    'openai-codex': 'codex',
-    gemini: 'gemini',
-    google: 'gemini',
-    grok: 'grok',
-    deepseek: 'deepseek',
-    qwen: 'qwen',
-    kimi: 'kimi',
-    minimax: 'minimax',
-    cline: 'cline',
-    opencode: 'opencode',
-    'open-code': 'opencode',
-    hermes: 'hermes',
-    'hermes-agent': 'hermes',
-    glm: 'glm',
-  };
-  return aliases[raw] || (SOURCE_CLIENTS.has(raw) ? raw : 'custom');
-}
 
 function parseArgs(argv) {
   const options = {
@@ -134,6 +105,12 @@ 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);
 }
@@ -312,16 +289,14 @@ 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()\`.
-- 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.
+- Before risky work, use Marrow's before-action intervention from \`GET /v1/agent/status\` or \`POST /v1/agent/runtime\`.
 - After meaningful work, record the outcome so future agents learn from it.
 - Check health with \`marrow_agent_status\` or \`GET /v1/agent/status\`.
 
 Required environment:
 
 - \`MARROW_API_KEY\`
-- Optional: \`MARROW_BASE_URL\`, \`MARROW_FLEET_AGENT_ID\`, \`MARROW_CLIENT\`
-- Optional: \`MARROW_PASSIVE_TOKEN_USAGE=false\` disables compact provider usage capture when needed.
+- Optional: \`MARROW_BASE_URL\`, \`MARROW_FLEET_AGENT_ID\`
 ${MARROW_BLOCK_END}`;
 }
 
@@ -343,7 +318,6 @@ if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
       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();
@@ -359,14 +333,12 @@ function envExample() {
   return `MARROW_API_KEY=mrw_live_replace_me
 MARROW_BASE_URL=${DEFAULT_BASE_URL}
 MARROW_FLEET_AGENT_ID=agent-or-fleet-id
-MARROW_CLIENT=codex
 MARROW_ENFORCEMENT_MODE=auto
 MARROW_PASSIVE_BRIEF=auto
 MARROW_PASSIVE_VALUE_REPORT=true
 MARROW_AGENT_RUNTIME=true
 MARROW_WORKFLOW_GATE=true
 MARROW_REQUIRE_OUTCOME_CLOSURE=true
-MARROW_PASSIVE_TOKEN_USAGE=true
 `;
 }
 
@@ -595,7 +567,6 @@ async function runSelfTest(options) {
     authorization: `Bearer ${options.apiKey}`,
     'content-type': 'application/json',
     'x-marrow-session-id': `install-${Date.now()}`,
-    'x-marrow-client': sourceClient(),
   };
   if (options.agentId) headers['x-marrow-agent-id'] = options.agentId;
 
@@ -606,11 +577,6 @@ async function runSelfTest(options) {
     body: JSON.stringify({
       type: 'process',
       action: 'Marrow passive install self-test: verify SDK/MCP hooks can record a harmless setup event',
-      source_meta: {
-        channel: 'cli',
-        client: sourceClient(),
-        user_intent: 'operate',
-      },
     }),
   });
 
@@ -667,14 +633,8 @@ async function runSelfTest(options) {
     ok: false,
     error: error instanceof Error ? error.message : String(error),
   }));
-  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);
+  const firstValueSignal = buildFirstValueSignal(status, runtime, performance, firstValue);
+  const installValueMoment = buildInstallValueMoment(firstValueSignal, status, runtime, performance, firstValue);
   return {
     skipped: false,
     decision_id: decisionId,
@@ -686,11 +646,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.before_you_act || null,
+    runtime_before_you_act: runtime.intervention?.agent_copy || runtime.intervention?.before_action || runtime.before_you_act || null,
+    runtime_intervention: runtime.intervention || 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,
@@ -702,30 +662,11 @@ async function runSelfTest(options) {
   };
 }
 
-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) {
+function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {}, performance = {}, firstValue = {}) {
   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,
+      proof: Array.isArray(firstValue.first_value.proof) ? firstValue.first_value.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.',
@@ -735,7 +676,9 @@ function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {
 
   const proof = firstValueSignal.value_proof || [];
   const hasFleetSignal = proof.length > 0;
-  const runtimeLesson = runtime.before_you_act
+  const runtimeLesson = runtime.intervention?.agent_copy
+    || runtime.intervention?.before_action
+    || runtime.before_you_act
     || runtime.before_you_act_injection?.message
     || runtime.exact_next_action
     || firstValueSignal.first_lesson;
@@ -746,19 +689,18 @@ function buildInstallValueMoment(firstValueSignal = {}, status = {}, runtime = {
       'Captured this setup decision',
       'Closed the outcome successfully',
       'Runtime gate is ' + (firstValueSignal.active ? 'active' : 'installed'),
-      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',
+      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',
     ],
     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 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.',
+    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.',
   };
 }
 
-function buildFirstValueSignal(status, runtime, performance, firstValue = {}, tokenValueProof = null) {
+function buildFirstValueSignal(status, runtime, performance, firstValue = {}) {
   if (firstValue && firstValue.ok !== false && firstValue.first_value) {
     const capture = firstValue.capture || {};
     const proof = firstValue.value_proof || {};
@@ -767,13 +709,11 @@ function buildFirstValueSignal(status, runtime, performance, firstValue = {}, to
     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,
+      first_lesson: firstValue.first_value.first_lesson || runtime?.intervention?.agent_copy,
       value_proof: proofBits,
       next_action: firstValue.next_action?.reason || 'Keep working; Marrow will capture outcomes and reuse lessons automatically.',
     };
@@ -796,8 +736,6 @@ function buildFirstValueSignal(status, runtime, performance, firstValue = {}, to
   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
@@ -861,20 +799,6 @@ 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) {
@@ -1025,5 +949,4 @@ module.exports = {
   inspectNpmTokenConfig,
   inspectSdkDependency,
   buildInstallValueMoment,
-  buildTokenValueProof,
 };