@getmarrow/install 0.1.38 → 0.1.40

package/README.md

@@ -70,6 +70,9 @@ Marrow's hosted API, website, and dashboard update automatically; local SDK depe
 npx -y @getmarrow/install@latest activate
 npx -y @getmarrow/install@latest doctor
 
+# Measured API read health and local backlog
+npx -y @getmarrow/mcp@latest ping
+
 # Use only when doctor reports drift
 npx -y @getmarrow/install@latest --repair
 ```
@@ -88,7 +91,22 @@ npx @getmarrow/install controller stop
 
 Persistent controller lifecycle is currently Linux-only. On macOS or Windows, activation still installs and verifies the supported hooks without starting or signaling a background process; run `npx @getmarrow/install sidecar` under an owner-managed service and pass `--no-controller`. The controller does not silently upgrade packages, change governance policy, rotate credentials, or modify unrelated project configuration.
 
-## What's New in v0.1.38
+## What's New in v0.1.40
+
+v0.1.40 binds governed runs to a privacy-safe workspace fingerprint and separates observed execution from verified completion:
+
+- ordinary prompts receive one compact context read; risky or mutating prompts receive one fresh runtime gate instead;
+- passive prompt telemetry is buffered locally rather than delaying the agent turn;
+- transient read failures can use clearly labeled owner-only last-known guidance, while authentication failures never use cache;
+- `doctor` prints the exact `npx -y @getmarrow/mcp@latest ping` command for measured current/p50/p99 latency, last success, and backlog health;
+- certified hook commands pin MCP `3.9.56` and SDK `3.7.55` so advertised behavior matches the deployed server contract;
+- governed runtime requests attach a stable privacy-safe project fingerprint and harness label without sending the raw working-directory path;
+- successful command exit remains observed execution, not verified business completion, unless a verification command or explicit proof file supplies evidence;
+- the integration matrix now reports prompt injection, pre-action, action result, closure, proof, cached brief, restart survival, evidence adapter, and safe repair separately.
+
+It preserves the intervention receipts introduced in v0.1.38.
+
+## Previous: v0.1.38
 
 v0.1.38 makes a meaningful Marrow intervention visible without adding manual work to routine agent sessions:
 
@@ -265,12 +283,12 @@ These are integration surfaces for one Marrow product, not separate products.
 
 Run `npx @getmarrow/install integrations --json` for the machine-readable matrix. The table below intentionally distinguishes full automatic interception from MCP-routed, wrapper-bounded, and adapter-required coverage.
 
-| Harnesses | Pre-action | Result | Outcome closure | Proof enforcement | Safe repair |
-| --- | --- | --- | --- | --- | --- |
-| Claude Code | Automatic native hook | Automatic native hook | Correlated when determinable | Automatic for protected actions | Managed config after activation |
-| Cursor, Composer, Cline, Windsurf | MCP-routed | MCP-routed | MCP-routed | Explicit or governed runner | Managed config after activation |
-| Codex, OpenCode, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM | Automatic inside governed runner | Automatic inside governed runner | Automatic when result is known | Automatic for protected actions | Managed config after activation |
-| Hermes, OpenClaw, custom harnesses | Adapter required | Adapter required | Adapter required | Adapter required | Adapter owned |
+| Harnesses | Prompt / pre-action / result | Closure and proof | Cached brief | Restart survival | Evidence adapter | Safe repair |
+| --- | --- | --- | --- | --- | --- | --- |
+| Claude Code | Automatic native hooks | Correlated when determinable; protected proof enforced | Owner-only bounded cache | Installed config and durable spool | Native hook evidence | Managed config after activation |
+| Cursor, Composer, Cline, Windsurf | MCP-routed only | MCP-routed; explicit or governed proof | Owner-only MCP cache | MCP config and durable spool | MCP lifecycle evidence | Managed config after activation |
+| Codex, OpenCode, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM | Automatic only inside governed runner | Automatic when result is known; protected proof enforced | Runner/runtime cache | Activated controller and durable buffer | Command, test, deployment, or owner evidence | Managed config after activation |
+| Hermes, OpenClaw, custom harnesses | Lifecycle adapter required | Adapter or governed runner required | Adapter dependent | Adapter dependent | Adapter supplied | Adapter owned |
 
 For native hooks, a successful tool exit is not treated as a successful business outcome when proof is missing. MCP coverage includes only actions routed through that MCP client. Governed-runner coverage includes only commands launched through the runner. Event-contract integrations must emit the documented lifecycle themselves.
 

package/package.json

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

package/src/governed-runner.js

@@ -319,7 +319,7 @@ function detectProjectSignals(cwd = process.cwd()) {
     }
   }
 
-  return {
+  const project = {
     name: packageJson?.name || path.basename(cwd),
     key: packageJson?.name || path.basename(cwd),
     type: packageJson ? 'node' : fs.existsSync(path.join(cwd, 'pyproject.toml')) ? 'python' : 'workspace',
@@ -328,6 +328,15 @@ function detectProjectSignals(cwd = process.cwd()) {
     package_scripts: packageScripts.slice(0, 30),
     config_files: configFiles.slice(0, 30),
   };
+  project.fingerprint = crypto.createHash('sha256').update(JSON.stringify({
+    name: project.name,
+    type: project.type,
+    frameworks: [...project.frameworks].sort(),
+    signals: [...project.signals].sort(),
+    package_scripts: [...project.package_scripts].sort(),
+    config_files: [...project.config_files].sort(),
+  })).digest('hex');
+  return project;
 }
 
 function isRisky(text, type) {
@@ -525,12 +534,25 @@ function proofFromFile(filePath) {
 
 function defaultProof(input) {
   const proof = proofFromFile(input.options.proofFile) || {};
+  const command = redactedCommand(input.childCommand || []);
+  const verificationCommand = /\b(test|smoke|check|verify|lint|typecheck|audit)\b/i.test(command);
+  const suppliedChecks = Array.isArray(proof.checks) && proof.checks.length > 0;
+  const evidenceState = typeof proof.evidence_state === 'string'
+    ? proof.evidence_state
+    : input.success && (suppliedChecks || verificationCommand)
+    ? 'verified'
+    : input.success
+    ? 'observed_only'
+    : 'failed';
   return {
     summary: proof.summary || `Marrow governed runner completed ${input.action}.`,
-    checks: Array.isArray(proof.checks) ? proof.checks : ['marrow runtime gate', 'command exit captured'],
+    checks: suppliedChecks ? proof.checks : [`command_exit_code=${Number(input.exitCode)}`],
+    evidence_source: proof.evidence_source || (verificationCommand ? 'verification_command_result' : 'governed_command_result'),
+    evidence_state: evidenceState,
+    verified_completion: evidenceState === 'verified',
     outcome: proof.outcome || (input.success ? 'success' : 'failure'),
     blockers: Array.isArray(proof.blockers) ? proof.blockers : [],
-    command: redactedCommand(input.childCommand || []),
+    command,
     exit_code: input.exitCode,
     runner: '@getmarrow/install run',
     profile: input.options.profile,
@@ -544,11 +566,14 @@ async function preflightRuntime(options, action, type, commandText) {
   const target = options.target || commandText || action;
   const surfaces = inferSurfaces(commandText || action);
   const meta = sourceMeta(options, 'runtime', { action, command: commandText, action_type: type });
+  const project = detectProjectSignals(options.root || process.cwd());
   return requestJson(options, 'POST', '/v1/agent/runtime', {
     action,
     type,
     target,
     surfaces,
+    harness: sourceClient(options.client),
+    project: { ...project, harness: sourceClient(options.client) },
     source_meta: meta,
     context: {
       runner: '@getmarrow/install run',
@@ -1398,6 +1423,15 @@ function integrationCoverageMatrix() {
       harness: entry.client,
       capability_level: entry.capability_level,
       install_surface: entry.install_surface,
+      prompt_injection: native
+        ? 'automatic_native_hook'
+        : wrapper
+          ? 'automatic_in_governed_runner'
+          : sdk
+            ? 'automatic_in_sdk_runtime'
+            : routed
+              ? 'mcp_routed'
+              : 'adapter_required',
       pre_action: native
         ? 'automatic_native_hook'
         : wrapper
@@ -1429,6 +1463,15 @@ function integrationCoverageMatrix() {
           ? 'explicit_or_governed_wrapper'
           : 'adapter_required',
       automatic_repair: native || routed || sdk || wrapper ? 'installer_managed_config_only' : 'adapter_owned',
+      cached_brief: native || routed ? 'mcp_local_last_known' : wrapper || sdk ? 'server_cache_only' : 'adapter_owned',
+      restart_survival: native || routed || sdk || wrapper ? 'installer_managed_credentials_and_hooks' : 'adapter_owned',
+      evidence_adapter: native
+        ? 'tool_result_and_explicit_verification'
+        : routed
+          ? 'mcp_tool_and_explicit_verification'
+          : wrapper || sdk
+            ? 'command_exit_and_verification_command'
+            : 'adapter_owned',
       limitation: native
         ? 'A successful tool exit is not treated as a successful business outcome when the result cannot be proven.'
         : routed
@@ -2272,6 +2315,7 @@ module.exports = {
   commandForSelection,
   buildGovernState,
   detectProjectSignals,
+  defaultProof,
   recommendGovernanceMode,
   recordGovernanceModeSelection,
   gateDecision,

package/src/installer.js

@@ -8,9 +8,9 @@ const { controllerStatus, controllerSupportedPlatform, ensureGovernanceControlle
 const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
 const MARROW_BLOCK_START = '<!-- marrow:passive-start -->';
 const MARROW_BLOCK_END = '<!-- marrow:passive-end -->';
-const MCP_ADAPTER_VERSION = '3.9.54';
-const SDK_ADAPTER_VERSION = '3.7.53';
-const SDK_ADAPTER_INTEGRITY = 'sha512-CKPVR9gf24mNvZIcFvKhHGZSsUhxa0uDg/bN4dktLlttB/EU/p6CEVWmGqZmxDTnfp4I+qqdJUpzuQSnkNhaIA==';
+const MCP_ADAPTER_VERSION = '3.9.56';
+const SDK_ADAPTER_VERSION = '3.7.55';
+const SDK_ADAPTER_INTEGRITY = 'sha512-aq8g3srJ9EFZVvskSQVE9MLUS8SSkvx3xY3Mr9G0ZkpKxiiDBQaa3r2pb/u74BYGVvJRP6EP/oV/D9jbKb2lBA==';
 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`;
@@ -1531,6 +1531,7 @@ function printReport(report) {
     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`);
+    process.stdout.write(`- live health: ${report.doctor.healthCommand}\n`);
   }
 
   if (report.writeMode === 'dry-run') {
@@ -1685,6 +1686,7 @@ async function install(options) {
           ? `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.'
         : controller.exact_fix || selfTest.recommended_fix || null),
+      healthCommand: 'npx -y @getmarrow/mcp@latest ping',
     },
     remediation,
     configDiagnostics,