@getmarrow/install 0.1.34 → 0.1.35

package/README.md

@@ -62,9 +62,31 @@ Required secret:
 export MARROW_API_KEY=mrw_live_...
 ```
 
-## What's New in v0.1.34
+## Keeping Marrow Current
 
-v0.1.34 verifies whether passive governance is actually active after install. Activation now registers a bounded capability profile, a one-way configuration fingerprint, expected and observed hook surfaces, and a server-accepted lifecycle receipt. The Fleet Operator shows activation state, capture coverage, outcome closure, intervention follow-through, drift, and the exact repair:
+Marrow's hosted API, website, and dashboard update automatically; local SDK dependencies, generated runtime files, MCP hooks/configuration, and pinned package versions do not silently rewrite themselves. Keeping them current delivers new client-side features, compatibility improvements, and any published security fixes. Supported clients report their package version during authenticated status/runtime activity, and Marrow returns a `client_update` notice with the exact action when the version is behind or unknown.
+
+```bash
+npx -y @getmarrow/install@latest activate
+npx -y @getmarrow/install@latest doctor
+
+# Use only when doctor reports drift
+npx -y @getmarrow/install@latest --repair
+```
+
+`activate` reconciles Marrow-managed entries while retaining unrelated user hooks and configuration. Detection and notification are automatic; local changes remain explicit and subject to the operator's normal change policy.
+
+## What's New in v0.1.35
+
+v0.1.35 turns server-side client update detection into a guided, low-friction operator workflow. Installer status, activation reports, and the Fleet Operator expose a request-specific advisory with the exact update and verification commands while keeping local mutation explicit:
+
+- official installer requests identify the installed `@getmarrow/install` version;
+- status, self-test, and Fleet Operator output show recommended, unrecognized, and security-required update states without conflating them;
+- generated agent instructions tell the agent to notify the operator and obey local change policy;
+- certified activation now pins MCP 3.9.51 and SDK 3.7.50, including the exact SDK registry integrity;
+- `activate`, `doctor`, and `--repair` remain explicit commands and preserve unrelated hooks and configuration.
+
+It preserves the passive-governance verification introduced in v0.1.34. Activation registers a bounded capability profile, a one-way configuration fingerprint, expected and observed hook surfaces, and a server-accepted lifecycle receipt. The Fleet Operator shows activation state, capture coverage, outcome closure, intervention follow-through, drift, and the exact repair:
 
 - Claude Code installation includes exact `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, and `Stop` hooks;
 - matching pre-action/result receipts use one tool correlation, and activation fingerprints the exact hook contract without uploading configuration contents;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmarrow/install",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Universal installer and governed runner for Marrow agent fleets.",
   "bin": {
     "marrow-install": "bin/marrow-install.js"

package/src/governed-runner.js

@@ -4,6 +4,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const readline = require('node:readline');
+const { version: INSTALLER_PACKAGE_VERSION } = require('../package.json');
 
 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;
@@ -343,6 +344,8 @@ function headers(options) {
     'X-Marrow-Agent-Id': options.agentId,
     'X-Marrow-Session-Id': options.sessionId,
     'X-Marrow-Client': sourceClient(options.client),
+    'X-Marrow-Package': '@getmarrow/install',
+    'X-Marrow-Package-Version': INSTALLER_PACKAGE_VERSION,
     'User-Agent': '@getmarrow/install governed-runner',
   };
   return h;
@@ -657,6 +660,31 @@ async function statusOnly(parsed) {
   return requestJson(parsed.options, 'GET', '/v1/agent/status');
 }
 
+function statusPanel(status = {}) {
+  const update = status.client_update && typeof status.client_update === 'object'
+    ? status.client_update
+    : null;
+  const lines = [
+    'Marrow runtime status',
+    `Health: ${displayText(firstDefined(status.health, status.status, status.ok === false ? 'degraded' : 'unknown'), 40)}`,
+  ];
+  const notification = update?.notification_state || update?.notification;
+  const priority = notification === 'security_required' || notification === 'recommended'
+    ? notification
+    : update?.version_status === 'unknown' || notification === 'unknown' || notification === 'version_unknown'
+    ? 'version_unknown'
+    : update?.priority || 'recommended';
+  if (update && (update.update_available === true || update.version_status === 'unknown' || notification === 'unknown' || notification === 'version_unknown' || priority === 'security_required')) {
+    lines.push(`Client update: ${displayText(priority, 32)}; installed=${displayText(update.installed_version || update.current_version || 'unknown', 32)}; latest=${displayText(update.latest_version || 'unknown', 32)}`);
+    lines.push('Automatic notification: yes; automatic local mutation: no; operator policy applies.');
+    if (update.update_command || update.exact_update_command) lines.push(`Update: ${displayText(update.update_command || update.exact_update_command, 240)}`);
+    if (update.verification_command || update.exact_verification_command) lines.push(`Verify: ${displayText(update.verification_command || update.exact_verification_command, 240)}`);
+  } else {
+    lines.push('Client update: current or unavailable.');
+  }
+  return lines.join('\n');
+}
+
 async function optionalRequestJson(options, method, route, body) {
   try {
     return { ok: true, data: await requestJson(options, method, route, body) };
@@ -809,6 +837,9 @@ function normalizeFixCommands(status, capacity) {
   add(status.activation_coverage?.exact_fix);
   add(status.activation_coverage?.drift?.repair_command, true);
   add(status.passive_activation?.exact_fix);
+  if (status.client_update?.update_available === true || status.client_update?.version_status === 'unknown' || status.client_update?.notification_state === 'unknown' || status.client_update?.notification === 'version_unknown') {
+    add(status.client_update?.update_command || status.client_update?.exact_update_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');
@@ -944,6 +975,7 @@ function normalizeFleetSnapshot(raw, options) {
     gates,
     arbitrations,
     activation_coverage: activationCoverage,
+    client_update: status.client_update || null,
     agents,
     fix_commands: fixCommands.length ? fixCommands : ['npx @getmarrow/install doctor'],
     source_errors: errors,
@@ -1003,6 +1035,9 @@ function fleetPanel(snapshot) {
     `Failed/stale outcomes: ${snapshot.failed_stale_outcomes}`,
     `Backpressure/capacity status: ${snapshot.backpressure_status}${snapshot.capacity_next_action ? ` - ${snapshot.capacity_next_action}` : ''}`,
     `Degraded hooks: ${degraded}`,
+    snapshot.client_update && (snapshot.client_update.update_available === true || snapshot.client_update.version_status === 'unknown' || snapshot.client_update.notification_state === 'unknown' || snapshot.client_update.notification === 'version_unknown')
+      ? `Marrow client update: ${displayText(snapshot.client_update.notification_state === 'security_required' ? 'security_required' : snapshot.client_update.notification_state === 'recommended' ? 'recommended' : snapshot.client_update.version_status === 'unknown' || snapshot.client_update.notification_state === 'unknown' || snapshot.client_update.notification === 'version_unknown' ? 'version_unknown' : snapshot.client_update.priority || 'recommended', 32)}; installed=${displayText(snapshot.client_update.installed_version || snapshot.client_update.current_version || 'unknown', 32)}; latest=${displayText(snapshot.client_update.latest_version || 'unknown', 32)}; operator approval required`
+      : 'Marrow client update: current or unavailable',
     `Deploy/publish/merge gates: deploy=${snapshot.gates.deploy} publish=${snapshot.gates.publish} merge=${snapshot.gates.merge}`,
     '',
     'Live agent roster:',
@@ -1839,6 +1874,7 @@ async function runCli(argv) {
 
   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 === 'status') process.stdout.write(`${statusPanel(result)}\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);
@@ -1868,6 +1904,7 @@ module.exports = {
   gateOnly,
   proofOnly,
   statusOnly,
+  statusPanel,
   runStatusCheck,
   runGateCheck,
   runGovernInteractive,

package/src/installer.js

@@ -2,14 +2,14 @@ const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const crypto = require('node:crypto');
+const { version: INSTALLER_ADAPTER_VERSION } = require('../package.json');
 
 const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
 const MARROW_BLOCK_START = '<!-- marrow:passive-start -->';
 const MARROW_BLOCK_END = '<!-- marrow:passive-end -->';
-const INSTALLER_ADAPTER_VERSION = '0.1.34';
-const MCP_ADAPTER_VERSION = '3.9.50';
-const SDK_ADAPTER_VERSION = '3.7.49';
-const SDK_ADAPTER_INTEGRITY = 'sha512-9a6pWWACubWTmulG7TwwgMNP/iSzoEh4wCH2oWUyO8XHeD2Eokj1GXrkCyX86md3bV7vGX6kyllfswZDlGj6WA==';
+const MCP_ADAPTER_VERSION = '3.9.51';
+const SDK_ADAPTER_VERSION = '3.7.50';
+const SDK_ADAPTER_INTEGRITY = 'sha512-TyCXUKZAaKRPdfVqXEuIvWnOt4GLcIUbwhpX+EopzdALNzq+t5wUGHrqJlkNSvopppPTTdFVLJ7O1vtwofqFqw==';
 const SDK_ADAPTER_TARBALL = `https://registry.npmjs.org/@getmarrow/sdk/-/sdk-${SDK_ADAPTER_VERSION}.tgz`;
 const MCP_PACKAGE_SPEC = `@getmarrow/mcp@${MCP_ADAPTER_VERSION}`;
 const MCP_CONTEXT_HOOK_COMMAND = `npx -y ${MCP_PACKAGE_SPEC} context-hook`;
@@ -380,6 +380,7 @@ Marrow should run passively after install:
 - Before risky work, use Marrow's decision brief or passive prompt hook.
 - After meaningful work, record the outcome so future agents learn from it.
 - Check health with \`marrow_agent_status\` or \`GET /v1/agent/status\`.
+- When status/runtime returns a \`client_update\` notice, tell the operator and use its exact update and verification commands only when local change policy permits.
 
 Required environment:
 
@@ -954,6 +955,8 @@ async function runSelfTest(options) {
     'content-type': 'application/json',
     'x-marrow-session-id': `install-${Date.now()}`,
     'x-marrow-client': options.client || sourceClient(),
+    'x-marrow-package': '@getmarrow/install',
+    'x-marrow-package-version': INSTALLER_ADAPTER_VERSION,
   };
   if (options.agentId) headers['x-marrow-agent-id'] = options.agentId;
 
@@ -1141,6 +1144,7 @@ async function runSelfTest(options) {
     first_value_signal: firstValueSignal,
     install_value_moment: installValueMoment,
     token_value_proof: tokenValueProof,
+    client_update: status.client_update || runtime.client_update || runtime.status?.client_update || null,
     performance_proof: performance && performance.ok !== false ? {
       avoided_mistakes: performance.avoided_mistakes ?? performance.avoided_repeated_mistakes ?? 0,
       reused_winning_decisions: performance.reused_winning_decisions ?? 0,
@@ -1299,6 +1303,18 @@ function printReport(report) {
     process.stdout.write(`- one-call runtime: ${report.selfTest.runtime_active ? 'active' : 'not verified'}\n`);
     if (report.selfTest.error) process.stdout.write(`- error: ${report.selfTest.error}\n`);
     if (report.selfTest.next_action) process.stdout.write(`- next action: ${report.selfTest.next_action}\n`);
+    const update = report.selfTest.client_update;
+    const notification = update?.notification_state || update?.notification;
+    if (update && (update.update_available === true || update.version_status === 'unknown' || notification === 'unknown' || notification === 'version_unknown' || notification === 'security_required')) {
+      process.stdout.write('\nMarrow client update:\n');
+      process.stdout.write(`- priority: ${notification === 'security_required' ? 'security_required' : notification === 'recommended' ? 'recommended' : update.version_status === 'unknown' || notification === 'unknown' || notification === 'version_unknown' ? 'version_unknown' : update.priority || 'recommended'}\n`);
+      process.stdout.write(`- installed: ${update.installed_version || update.current_version || 'unknown'}\n`);
+      process.stdout.write(`- latest: ${update.latest_version || 'unknown'}\n`);
+      process.stdout.write('- automatic notification: yes\n');
+      process.stdout.write('- automatic local mutation: no; operator policy applies\n');
+      if (update.update_command || update.exact_update_command) process.stdout.write(`- update: ${update.update_command || update.exact_update_command}\n`);
+      if (update.verification_command || update.exact_verification_command) process.stdout.write(`- verify: ${update.verification_command || update.exact_verification_command}\n`);
+    }
     if (report.selfTest.first_value_signal) {
       process.stdout.write('\nFirst value:\n');
       const valueMoment = report.selfTest.install_value_moment;