@getmarrow/install 0.1.1 → 0.1.4

package/README.md

@@ -7,14 +7,17 @@ Use it when you want Marrow to detect the local agent/runtime environment and wi
 ```bash
 npx @getmarrow/install --dry-run
 npx @getmarrow/install --yes
+npx @getmarrow/install --repair
 npx @getmarrow/install doctor
 ```
 
-## What's New in v0.1.1
+## What's New in v0.1.4
 
-- `doctor` / `--doctor` checks whether Marrow is active without writing files.
-- Generated SDK passive runtime enables workflow gates and value summaries by default.
-- Doctor output reports missing env, missing hooks/config, self-test state, and recommended fix.
+- Installer self-test now finishes with a first-value summary: Marrow active state, captured surfaces, first useful lesson, value proof, and exact next action.
+- Generated SDK passive runtime enables one-call agent runtime checks by default with `MARROW_AGENT_RUNTIME=true`.
+- Self-test now verifies the runtime endpoint in addition to creating a harmless decision and committing its outcome.
+- `--repair` keeps dry-run behavior safe when `--dry-run` is present and reports whether one-call runtime was verified.
+- Doctor/repair output still gives exact safe setup and repair commands without printing credential values.
 
 ## What It Detects
 
@@ -48,7 +51,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, and reads `/v1/agent/status`.
+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
@@ -66,6 +69,12 @@ Doctor check:
 MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install doctor
 ```
 
+Repair missing hooks/config:
+
+```bash
+MARROW_API_KEY=mrw_live_xxx npx @getmarrow/install --repair
+```
+
 ## Trust Model
 
 This package is intended to be open source and auditable. It prints every file it will touch, requires `--yes` to write, does not store API keys in project files, and supports MCP-only, SDK-only, both, and markdown-only setups.

package/package.json

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

package/src/installer.js

@@ -12,6 +12,7 @@ function parseArgs(argv) {
     yes: false,
     dryRun: false,
     doctor: false,
+    repair: false,
     mode: 'auto',
     apiKey: process.env.MARROW_API_KEY || '',
     baseUrl: process.env.MARROW_BASE_URL || DEFAULT_BASE_URL,
@@ -23,6 +24,10 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--yes' || arg === '-y') options.yes = true;
+    else if (arg === '--repair' || arg === 'repair') {
+      options.repair = true;
+      options.yes = true;
+    }
     else if (arg === '--dry-run') options.dryRun = true;
     else if (arg === '--doctor' || arg === 'doctor' || arg === 'check') options.doctor = true;
     else if (arg === '--json') options.json = true;
@@ -58,6 +63,7 @@ function usage() {
   return `Usage:
   npx @getmarrow/install --dry-run
   npx @getmarrow/install --yes
+  npx @getmarrow/install --repair
   npx @getmarrow/install doctor
   npx @getmarrow/install --mcp --yes
   npx @getmarrow/install --sdk --yes
@@ -65,6 +71,7 @@ function usage() {
 Options:
   --dry-run          Print planned changes without writing
   --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.
@@ -135,6 +142,24 @@ function detectEnvironment(cwd = process.cwd(), env = process.env) {
   };
 }
 
+function findLikelyEnvFiles(detection, env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  const candidates = [
+    path.join(detection.root, '.env'),
+    path.join(detection.root, '.env.local'),
+    path.join(detection.root, '.marrow', 'env'),
+    path.join(detection.root, '.marrow', 'env.local'),
+    path.join(home, '.marrow', 'env'),
+    path.join(home, '.openclaw', 'credentials', 'marrow-mcp.env'),
+    path.join(home, '.openclaw', 'gateway.systemd.env'),
+  ];
+  return candidates.filter((filePath) => {
+    if (!exists(filePath)) return false;
+    const raw = safeRead(filePath);
+    return /\bMARROW_API_KEY\s*=/.test(raw) || /\bMARROW_KEY(_[A-Z0-9]+)?\s*=/.test(raw);
+  });
+}
+
 function passiveInstructions() {
   return `${MARROW_BLOCK_START}
 ## Marrow Passive Agent Memory
@@ -169,6 +194,7 @@ if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
   const runtime = marrow.createPassiveRuntime({
     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',
   });
 
@@ -185,6 +211,7 @@ MARROW_FLEET_AGENT_ID=agent-or-fleet-id
 MARROW_ENFORCEMENT_MODE=auto
 MARROW_PASSIVE_BRIEF=auto
 MARROW_PASSIVE_VALUE_REPORT=true
+MARROW_AGENT_RUNTIME=true
 MARROW_WORKFLOW_GATE=true
 `;
 }
@@ -370,7 +397,13 @@ async function requestJson(url, options) {
 
 async function runSelfTest(options) {
   if (!options.selfTest) return { skipped: true, reason: 'disabled' };
-  if (!options.apiKey) return { skipped: true, reason: 'missing MARROW_API_KEY' };
+  if (!options.apiKey) {
+    return {
+      skipped: true,
+      reason: 'missing MARROW_API_KEY',
+      exact_fix: 'export MARROW_API_KEY=mrw_live_... && npx @getmarrow/install --repair',
+    };
+  }
 
   const headers = {
     authorization: `Bearer ${options.apiKey}`,
@@ -403,6 +436,29 @@ async function runSelfTest(options) {
   });
 
   const status = await requestJson(`${baseUrl}/v1/agent/status`, { headers });
+  const runtime = await requestJson(`${baseUrl}/v1/agent/runtime`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      action: 'Marrow passive install self-test: verify one-call agent runtime and outcome closure',
+      type: 'process',
+      role: 'general',
+      surfaces: ['workspace'],
+      proof: {
+        checks: ['installer self-test'],
+        outcome: 'self-test outcome committed',
+      },
+    }),
+  }).catch((error) => ({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+  }));
+  const performance = await requestJson(`${baseUrl}/v1/analytics/agent-performance?period=7`, { headers })
+    .catch((error) => ({
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  const firstValueSignal = buildFirstValueSignal(status, runtime, performance);
   return {
     skipped: false,
     decision_id: decisionId,
@@ -410,6 +466,55 @@ async function runSelfTest(options) {
     health: status.health || null,
     last_event_at: status.last_event_at || null,
     recommended_fix: status.recommended_fix || null,
+    next_action: status.next_action || null,
+    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,
+    first_value_signal: firstValueSignal,
+    performance_proof: performance && performance.ok !== false ? {
+      avoided_mistakes: performance.avoided_mistakes ?? performance.avoided_repeated_mistakes ?? 0,
+      reused_winning_decisions: performance.reused_winning_decisions ?? 0,
+      prevented_bad_actions: performance.prevented_bad_actions ?? 0,
+      estimated_tokens_saved: performance.token_time_saved_estimate?.estimated_tokens_saved ?? 0,
+      estimated_minutes_saved: performance.token_time_saved_estimate?.estimated_minutes_saved ?? 0,
+      reliability_score: performance.agent_reliability_score ?? null,
+    } : null,
+  };
+}
+
+function buildFirstValueSignal(status, runtime, performance) {
+  const capture = status.capture_coverage || {};
+  const closure = status.auto_outcome_closure || {};
+  const captured = [];
+  if (status.enabled || capture.decisions) captured.push('decisions');
+  if (capture.tools === 'detected') captured.push('tools');
+  if (capture.commands === 'detected') captured.push('commands');
+  if (capture.deploys === 'detected') captured.push('deploys');
+  if (capture.publishes === 'detected') captured.push('publishes');
+  if (closure.state) captured.push(`outcomes:${closure.state}`);
+
+  const proof = performance && performance.ok !== false ? performance : {};
+  const proofBits = [];
+  if (Number(proof.avoided_mistakes || proof.avoided_repeated_mistakes || 0) > 0) proofBits.push(`${proof.avoided_mistakes || proof.avoided_repeated_mistakes} avoided mistake(s)`);
+  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)`);
+  const tokens = proof.token_time_saved_estimate?.estimated_tokens_saved || 0;
+  if (tokens > 0) proofBits.push(`~${tokens} tokens saved`);
+
+  const firstLesson = runtime.before_you_act
+    || runtime.before_you_act_injection?.message
+    || runtime.exact_next_action
+    || status.recommended_fix
+    || 'Marrow will surface prior lessons before risky or repeated work.';
+
+  return {
+    active: Boolean(status.enabled ?? status.ok),
+    headline: `Marrow active: ${captured.length ? captured.join(', ') : 'decisions'} captured.`,
+    captured,
+    first_lesson: firstLesson,
+    value_proof: proofBits,
+    next_action: runtime.exact_next_action || status.next_action || 'Keep working; Marrow will capture outcomes and reuse lessons automatically.',
   };
 }
 
@@ -433,16 +538,37 @@ function printReport(report) {
   process.stdout.write('\nSelf-test:\n');
   if (report.selfTest.skipped) {
     process.stdout.write(`- skipped: ${report.selfTest.reason}\n`);
+    if (report.selfTest.exact_fix) process.stdout.write(`- exact fix: ${report.selfTest.exact_fix}\n`);
   } else {
     process.stdout.write(`- active: ${report.selfTest.active ? 'yes' : 'no'}\n`);
     process.stdout.write(`- decision_id: ${report.selfTest.decision_id}\n`);
     process.stdout.write(`- health: ${report.selfTest.health || 'unknown'}\n`);
+    process.stdout.write(`- one-call runtime: ${report.selfTest.runtime_active ? 'active' : 'not verified'}\n`);
+    if (report.selfTest.next_action) process.stdout.write(`- next action: ${report.selfTest.next_action}\n`);
+    if (report.selfTest.first_value_signal) {
+      process.stdout.write('\nFirst value:\n');
+      process.stdout.write(`- ${report.selfTest.first_value_signal.headline}\n`);
+      process.stdout.write(`- First useful lesson: ${report.selfTest.first_value_signal.first_lesson}\n`);
+      if (report.selfTest.first_value_signal.value_proof.length) {
+        process.stdout.write(`- Proof: ${report.selfTest.first_value_signal.value_proof.join('; ')}\n`);
+      }
+      process.stdout.write(`- Next: ${report.selfTest.first_value_signal.next_action}\n`);
+    }
+  }
+
+  if (report.remediation) {
+    process.stdout.write('\nRemediation:\n');
+    process.stdout.write(`- attempted: ${report.remediation.attempted ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- fixed config: ${report.remediation.fixedConfig ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- self-test passed: ${report.remediation.selfTestPassed ? 'yes' : 'no'}\n`);
+    if (report.remediation.message) process.stdout.write(`- result: ${report.remediation.message}\n`);
   }
 
   if (report.writeMode === 'doctor') {
     process.stdout.write('\nDoctor:\n');
     process.stdout.write(`- Marrow active: ${report.doctor.active ? 'yes' : 'no'}\n`);
     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.recommendedFix) process.stdout.write(`- recommended fix: ${report.doctor.recommendedFix}\n`);
   }
@@ -462,13 +588,30 @@ function printReport(report) {
 async function install(options) {
   const detection = detectEnvironment(options.cwd);
   const plan = buildPlan(detection, options);
-  const writeMode = options.doctor ? 'doctor' : options.yes && !options.dryRun ? 'write' : 'dry-run';
+  const writeMode = options.doctor ? 'doctor' : options.dryRun ? 'dry-run' : options.repair ? 'repair' : options.yes ? 'write' : 'dry-run';
   const changes = applyPlan(plan, options);
+  const envHints = options.apiKey ? [] : findLikelyEnvFiles(detection);
   const selfTest = await runSelfTest(options).catch((error) => ({
     skipped: false,
     active: false,
     error: error instanceof Error ? error.message : String(error),
   }));
+  const changedConfig = changes.some((change) => change.changed);
+  const selfTestPassed = Boolean(!selfTest.skipped && selfTest.active && !selfTest.error);
+  const remediation = options.repair
+    ? {
+      attempted: true,
+      fixedConfig: changedConfig,
+      selfTestPassed,
+      message: selfTestPassed
+        ? selfTest.health === 'healthy'
+          ? 'I fixed Marrow passive config, one-call runtime is active, and self-test passed.'
+          : `I fixed Marrow passive config and self-test passed; status is ${selfTest.health || 'unknown'}${selfTest.next_action ? `. Next action: ${selfTest.next_action}` : ''}.`
+        : selfTest.skipped
+        ? `Config repair ran, but self-test skipped: ${selfTest.reason}.`
+        : `Config repair ran, but self-test failed: ${selfTest.error || 'unknown error'}.`,
+    }
+    : null;
 
   return {
     root: detection.root,
@@ -487,9 +630,15 @@ async function install(options) {
     doctor: {
       active: Boolean(!selfTest.skipped && selfTest.active),
       missingEnv: options.apiKey ? [] : ['MARROW_API_KEY'],
+      envHints,
       missingHooks: changes.filter((change) => change.changed).map((change) => change.label),
-      recommendedFix: selfTest.recommended_fix || (!options.apiKey ? 'Set MARROW_API_KEY, then run npx @getmarrow/install doctor.' : null),
+      recommendedFix: selfTest.recommended_fix || (!options.apiKey
+        ? envHints.length
+          ? `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,
     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.']