@getmarrow/install 0.1.48 → 0.1.49

package/README.md

@@ -4,12 +4,12 @@
 
 Marrow is the runtime control and proof layer for teams running AI agents. It applies policy and prior lessons before consequential actions, then records the evidence and outcome afterward.
 
-Use `@getmarrow/install` as the default entry point. It detects supported agent and project surfaces, writes the appropriate passive configuration, runs a harmless end-to-end self-test, and reports whether policy, proof, attribution, and outcome capture are active.
+Use `@getmarrow/install` as the default entry point. It detects supported agent and project surfaces, writes the appropriate configuration, runs a harmless end-to-end control-path self-test, and reports connection, configured mode, and server-confirmed outcome separately from passive coverage.
 
 ## Agent Discovery
 
 - **Publisher:** Marrow AI. Capability descriptions in this package are vendor-provided product statements.
-- **Use this package for:** automatic harness detection, passive setup, activation proof, the Govern TUI, or a governed command runner.
+- **Use this package for:** automatic harness detection, setup and connection proof, the Govern TUI, or a governed command runner.
 - **Product category:** agent fleet governance and control layer.
 - **Operator boundary:** installing Marrow, creating an account, or submitting a diagnostic requires operator approval.
 - **Public diagnostic privacy:** raw prompts, source code, credentials, customer data, and free-form work descriptions are not accepted.
@@ -89,11 +89,17 @@ npx @getmarrow/install controller ensure
 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.
+Persistent controller lifecycle is currently Linux-only. On macOS or Windows, activation still writes supported configuration and verifies one server-side install self-test without certifying that hooks continuously ran; 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.48
+## What's New in v0.1.49
 
-v0.1.48 pins MCP `3.9.72` and SDK `3.7.61`. The SDK keeps passive capture enabled without intercepting its own Marrow control-plane requests, while every generated MCP setup and repair command now uses the supported MCP release.
+v0.1.49 pins MCP `3.9.74` and SDK `3.7.62`. Install and repair now resolve one stable non-secret agent identity before writing configuration, then use that exact identity across generated MCP config, the owned-process SDK preload, doctor/self-test, and the local controller. Managed MCP config no longer stores an API key or shell-style credential placeholder; the owning harness inherits the key from trusted environment or secret-manager state.
+
+The integration boundary is explicit: native Claude hooks are installed only where supported and remain cooperative/client-reported until authoritative server receipts exist; MCP tools are on demand; Codex, Grok, Gemini, and similar CLIs use the governed wrapper for consequential control; owned Node processes use the SDK passive runtime while installed; and custom hosts require a bounded event adapter. Exact package SHA/integrity can prove artifact provenance, not runtime coverage. Activation-profile delivery is authenticated `client_self_reported` telemetry with `certified_coverage: false`; it acknowledges delivery but cannot attest that a hook, wrapper, or adapter ran.
+
+## Previous: v0.1.48
+
+v0.1.48 pinned MCP `3.9.72` and SDK `3.7.61`. The SDK kept passive capture enabled without intercepting its own Marrow control-plane requests, while every generated MCP setup and repair command used the supported MCP release.
 
 ## Previous: v0.1.47
 
@@ -220,7 +226,7 @@ It preserves the measurable passive-governance coverage introduced in v0.1.34:
 - the harness certification suite prevents support claims from overstating what is automatic;
 - unavailable coverage remains “insufficient data” instead of a synthetic percentage.
 
-It preserves agent-disagreement visibility from v0.1.33 and the server-verified first-run activation introduced in v0.1.29:
+It preserves agent-disagreement visibility from v0.1.33 and the server-confirmed first-run self-test introduced in v0.1.29:
 
 - GitHub and npm now advertise separate signed discovery placements;
 - package metadata identifies the installer as agent governance rather than a general memory utility;
@@ -228,8 +234,8 @@ It preserves agent-disagreement visibility from v0.1.33 and the server-verified
 - bounded positive and negative recommendation criteria stop agents from forcing Marrow into irrelevant workflows;
 - current evidence, integration paths, and published references are linked from one review-dated contract;
 - `npx @getmarrow/install activate` detects the current harness, writes supported passive controls, creates and closes a harmless decision, and asks Marrow to verify that exact outcome;
-- activation succeeds only when the API returns a tenant-scoped activation receipt;
-- the receipt reports capture, before-action intervention, outcome closure, and first-value state;
+- activation succeeds only when the API returns a tenant-scoped receipt bound to the exact test decision, agent, runtime gate, and closed successful outcome;
+- that receipt verifies only the install self-test; activation returns `activation_scope: server_self_test_only`, `coverage_verified: false`, `passive_live: false`, and `reload_required: true`;
 - existing setup, governed runner, and TUI commands remain compatible.
 
 Use `activate` when you want one command with an explicit success contract. Use `--yes` when an existing automation already handles setup prompts and verification output.
@@ -260,12 +266,12 @@ With a valid key, `activate`:
 4. closes its outcome;
 5. sends the exact self-test decision ID to Marrow for server-side verification;
 6. reads agent status and the one-call runtime;
-7. registers the detected capability, expected hooks, and one-way configuration fingerprint;
-8. returns an activation receipt with capture, intervention, closure, first-value state, and the exact next action.
+7. registers the detected capability, expected hooks, and one-way configuration fingerprint as authenticated client-reported telemetry;
+8. returns a server-confirmed self-test receipt plus an explicit restart and `doctor --self-test` next action.
 
-Healthy output confirms the exact decision outcome exists under the authenticated account and agent. A local file write or client-supplied `verified: true` value cannot produce an active receipt.
+Healthy output confirms the exact test decision outcome exists under the authenticated account and agent and passed a runtime/status check. It does not verify continuous passive interception or certify installed coverage. The owning harness must restart, then `npx @getmarrow/install@latest doctor --self-test` must pass. A local file write, integration event, or client-supplied `verified: true` value cannot elevate coverage.
 
-The installer does not claim identical automation for every harness. Native hooks provide the broadest automatic coverage; MCP covers MCP-routed actions; the SDK covers owned Node processes; the governed runner covers commands launched through it; custom harnesses must map their own lifecycle events.
+The installer does not claim identical automation for every harness. Configured native hooks remain cooperative/client-reported; MCP covers only on-demand MCP-routed actions; the SDK covers only owned Node processes where its runtime is installed; the governed runner covers only commands launched through it; custom harnesses must map their own lifecycle events.
 
 ## Govern TUI
 
@@ -333,7 +339,7 @@ The fleet view shows live agents, active workflows, agent disagreements and thei
 | --- | --- | --- |
 | Universal installer | You want Marrow to detect and wire the safest supported integration | Lowest |
 | Governed runner | You need control around existing shell, CI, deploy, publish, merge, or migration commands | Low |
-| MCP package | The agent client supports MCP and should use Marrow tools and hooks natively | Low |
+| MCP package | The agent client supports MCP and should use Marrow tools on demand | Low |
 | SDK | You own the Node.js/TypeScript runtime and need programmatic control | Advanced |
 | Event contract | You have a custom harness that must map its lifecycle into Marrow | Advanced |
 
@@ -345,16 +351,16 @@ Run `npx @getmarrow/install integrations --json` for the machine-readable matrix
 
 | 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 |
+| Claude Code | Configured native hooks where supported; cooperative/client-reported until authoritative receipts exist | Correlated when determinable; proof is evaluated and is advisory or enforced according to plan policy | 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 |
+| Codex, OpenCode, Gemini, Grok, DeepSeek, Qwen, Kimi, MiniMax, GLM | Automatic only inside governed runner | Automatic when result is known; proof is evaluated and is advisory or enforced according to plan policy | 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.
 
 ## Always-On Lifecycle
 
-Supported integrations capture a compact lifecycle without storing raw prompts, completions, command output, tool output, or credentials. Marrow recognizes prompt, goal, pre-action, tool/command result, verification evidence, workflow/session, subagent, handoff, proof-pack, and outcome events.
+When work actually passes through configured native hooks, an on-demand MCP call, an installed owned-process SDK runtime, the governed runner, or a bounded custom adapter, Marrow can capture a compact lifecycle without storing raw prompts, completions, command output, tool output, or credentials. Marrow recognizes prompt, goal, pre-action, tool/command result, verification evidence, workflow/session, subagent, handoff, proof-pack, and outcome events. Work that bypasses those paths is not observed.
 
 Meaningful work opens an outcome-closure item. A tool exit or workflow completion does not silently count as a successful business outcome; an explicit outcome receipt closes it. Transient delivery failures are held in an owner-only local spool and retried with the same event ID so retries do not create duplicate lifecycle records.
 
@@ -384,6 +390,8 @@ See the [Trust Center](https://getmarrow.ai/trust/) for implemented controls, cu
 | `MARROW_BASE_URL` | No | API base override |
 | `MARROW_FLEET_AGENT_ID` | No | Default agent identity |
 
+Install and repair resolve one stable, non-secret agent identity before writing configuration. The managed MCP entry and owned-process SDK preload use that same identity and API base as doctor/self-test. The installer never copies `MARROW_API_KEY` into MCP configuration or generated runtime source; the owning harness must inherit the key from trusted environment or secret-manager configuration. Pass `--agent-id <id>` when an operator-approved identity must override the stable generated value.
+
 Use the host's secret manager first. The shared resolver can also check documented Marrow and project env files for owned development environments. Run `doctor` when a key or hook cannot be found.
 
 ## Documentation

package/package.json

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

package/src/installer.js

@@ -9,11 +9,10 @@ const { firstCapturePath, harnessReloadPlan } = require('./first-hour');
 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.72';
-const MCP_ADAPTER_SOURCE_SHA = '5203f96388849dfda12cb05d476b36b542639e16';
-const MCP_ADAPTER_INTEGRITY = 'sha512-FTs9ORn4WVwDIeJEjovriDK4X8WZVSGbbe8iz6GGYFy62jBRJOXOZ4aW8B4Ll+10i71o8RcEBJ0Px38Pc6v/qw==';
-const SDK_ADAPTER_VERSION = '3.7.61';
-const SDK_ADAPTER_INTEGRITY = 'sha512-1dXf/Px4mMN4lOehrRkBOF/dC6N9kjQ5R4eb8ohAACx5CvLTS32zSTelfMNjnRcdOknSKMjLnbh7aGFhulVo/Q==';
+const MCP_ADAPTER_VERSION = '3.9.74';
+const MCP_ADAPTER_SOURCE_SHA = 'a34a87ee1d6ea16d8ebcc26aa0e66bf7dcb5e23f';
+const SDK_ADAPTER_VERSION = '3.7.62';
+const SDK_ADAPTER_INTEGRITY = 'sha512-n1i6Be09TpAQ9BPNRKY7aCvA2iSUPpJfw8djw2MELwpNbBCtKiZ29Jji77BK/6EFLUpSIcTW/Gmdf/ccf0JRYQ==';
 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 ADAPTER_PROVENANCE = Object.freeze({
@@ -21,7 +20,8 @@ const ADAPTER_PROVENANCE = Object.freeze({
     package: '@getmarrow/mcp',
     version: MCP_ADAPTER_VERSION,
     source_sha: MCP_ADAPTER_SOURCE_SHA,
-    integrity: MCP_ADAPTER_INTEGRITY,
+    integrity: null,
+    integrity_state: 'registry_unavailable_until_publish',
   }),
   sdk: Object.freeze({
     package: '@getmarrow/sdk',
@@ -340,7 +340,7 @@ 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
-  update             Same as --repair: refresh certified MCP/SDK/install pins after owner approval
+  update             Same as --repair: refresh exact MCP/SDK/install package pins after owner approval
   --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.
@@ -642,14 +642,18 @@ Required environment:
 ${MARROW_BLOCK_END}`;
 }
 
-function passiveRuntimeSource() {
+function passiveRuntimeSource(options = {}) {
+  const installedAgentId = String(options.agentId || '').trim();
+  const installedBaseUrl = String(options.baseUrl || DEFAULT_BASE_URL).trim() || DEFAULT_BASE_URL;
   return `const apiKey = process.env.MARROW_API_KEY;
+const installedAgentId = ${JSON.stringify(installedAgentId)};
+const installedBaseUrl = ${JSON.stringify(installedBaseUrl)};
 if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
   try {
     const { MarrowClient } = await import('@getmarrow/sdk');
     const marrow = new MarrowClient(apiKey, {
-      baseUrl: process.env.MARROW_BASE_URL,
-      agentId: process.env.MARROW_FLEET_AGENT_ID || process.env.MARROW_AGENT_ID,
+      baseUrl: installedBaseUrl,
+      agentId: installedAgentId || process.env.MARROW_FLEET_AGENT_ID || process.env.MARROW_AGENT_ID,
       sessionId: process.env.MARROW_SESSION_ID,
       mode: process.env.MARROW_ENFORCEMENT_MODE || 'auto',
     });
@@ -672,11 +676,14 @@ if (apiKey && !globalThis.__MARROW_PASSIVE_RUNTIME__) {
 `;
 }
 
-function envExample() {
+function envExample(options = {}) {
+  const agentId = String(options.agentId || 'agent-or-fleet-id').trim() || 'agent-or-fleet-id';
+  const client = String(options.client || 'custom').trim() || 'custom';
+  const baseUrl = String(options.baseUrl || DEFAULT_BASE_URL).trim() || DEFAULT_BASE_URL;
   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_BASE_URL=${JSON.stringify(baseUrl)}
+MARROW_FLEET_AGENT_ID=${JSON.stringify(agentId)}
+MARROW_CLIENT=${JSON.stringify(client)}
 MARROW_ENFORCEMENT_MODE=auto
 MARROW_PASSIVE_BRIEF=auto
 MARROW_PASSIVE_VALUE_REPORT=true
@@ -941,12 +948,18 @@ function activationProfile(detection, plan, changes, client) {
     config_fingerprint: configFingerprint,
     expected_hooks: expectedHooks,
     observed_hooks: observedHooks,
+    evidence_authority: 'client_self_reported',
+    coverage_verified: false,
+    configuration_complete: complete,
     complete,
     exact_fix: exactFix,
   };
 }
 
-function upsertMcpServerConfig(filePath) {
+function upsertMcpServerConfig(filePath, options = {}) {
+  const agentId = String(options.agentId || '').trim();
+  if (!agentId) throw new Error('Refusing to generate Marrow MCP config without an agent identity');
+  const baseUrl = String(options.baseUrl || DEFAULT_BASE_URL).trim() || DEFAULT_BASE_URL;
   const config = parseJsonObject(filePath);
   const servers = config.mcpServers && typeof config.mcpServers === 'object' && !Array.isArray(config.mcpServers)
     ? config.mcpServers
@@ -955,9 +968,8 @@ function upsertMcpServerConfig(filePath) {
     command: 'npx',
     args: ['-y', `--package=${MCP_PACKAGE_SPEC}`, 'marrow-mcp'],
     env: {
-      MARROW_API_KEY: '${MARROW_API_KEY}',
-      MARROW_BASE_URL: '${MARROW_BASE_URL}',
-      MARROW_FLEET_AGENT_ID: '${MARROW_FLEET_AGENT_ID}',
+      MARROW_BASE_URL: baseUrl,
+      MARROW_FLEET_AGENT_ID: agentId,
     },
   };
   config.mcpServers = servers;
@@ -1076,7 +1088,8 @@ function defaultHarnessInstallMatrix(detection = detectEnvironment(process.cwd()
         native_hooks: entry.capability_level === 'native_hooks' && Boolean(detection.claudeCode),
         governed_wrapper: entry.capability_level === 'governed_wrapper',
       },
-      verified_passive: detected && entry.automatic.length > 0,
+      configured_locally: detected && entry.automatic.length > 0,
+      verified_passive: false,
       unsupported_claim: entry.capability_level === 'event_contract'
         ? 'Needs a bounded event adapter. MCP tools remain on demand.'
         : null,
@@ -1085,6 +1098,9 @@ function defaultHarnessInstallMatrix(detection = detectEnvironment(process.cwd()
 }
 
 function buildPlan(detection, options) {
+  const client = options.client || detectedClient(detection);
+  const agentId = String(options.agentId || '').trim() || stableAgentId(detection.root, client);
+  const baseUrl = String(options.baseUrl || DEFAULT_BASE_URL).trim() || DEFAULT_BASE_URL;
   const mode = options.mode === 'auto'
     ? detection.node ? 'both' : 'mcp'
     : options.mode;
@@ -1095,13 +1111,13 @@ function buildPlan(detection, options) {
       type: 'file',
       path: detection.paths.passiveRuntime,
       label: 'SDK passive runtime preload',
-      content: passiveRuntimeSource(),
+      content: passiveRuntimeSource({ agentId, baseUrl }),
     });
     writes.push({
       type: 'file',
       path: detection.paths.passiveEnv,
       label: 'Marrow passive env example',
-      content: envExample(),
+      content: envExample({ agentId, baseUrl, client }),
       overwrite: false,
     });
   }
@@ -1119,14 +1135,14 @@ function buildPlan(detection, options) {
       type: 'json-transform',
       path: detection.paths.mcpJson,
       label: 'Project MCP server config',
-      transform: upsertMcpServerConfig,
+      transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl }),
     });
     if (detection.cursor) {
       writes.push({
         type: 'json-transform',
         path: detection.paths.cursorMcp,
         label: 'Cursor MCP server config',
-        transform: upsertMcpServerConfig,
+        transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl }),
       });
     }
   }
@@ -1412,60 +1428,51 @@ async function runSelfTest(options) {
     if (!receiptValid) {
       throw new Error('activation receipt did not verify the exact self-test decision, agent, runtime gate, and closed successful outcome');
     }
-    activationProfileReceipt = await requestJson(`${baseUrl}/v1/agent/integrations/events`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        event_id: `activation-${activationConfigFingerprint.slice(0, 32)}`,
-        event_type: 'activation_profile_registered',
-        harness: options.activation.harness,
-        agent_id: options.agentId,
-        session_id: headers['x-marrow-session-id'],
-        adapter_version: activationAdapterVersion,
-        capability_level: activationCapabilityLevel,
-        config_fingerprint: activationConfigFingerprint,
-        expected_hooks: activationExpectedHooks,
-        action: 'passive integration activation profile registered',
-        occurred_at: new Date().toISOString(),
-      }),
-    });
-    const profileCoverage = activationProfileReceipt?.activation_coverage;
-    const profileReceipt = profileCoverage?.profile_receipt;
-    const accountBindingId = profileCoverage?.account_binding_id;
-    const expectedConfigurationBindingId = typeof accountBindingId === 'string'
-      ? crypto.createHash('sha256')
-        .update(`agent-config-receipt:v2:${accountBindingId}:${activationConfigFingerprint}`)
-        .digest('hex')
-      : null;
-    const expectedHooksMatch = Array.isArray(profileCoverage?.capture_coverage?.expected_hooks)
-      && [...profileCoverage.capture_coverage.expected_hooks].sort().join(',') === [...activationExpectedHooks].sort().join(',');
-    const profileBound = Boolean(
-      activationProfileReceipt?.accepted === true
-      && profileCoverage?.agent_id === options.agentId
-      && profileCoverage?.harness === options.activation.harness
-      && profileCoverage?.activation?.adapter_version === activationAdapterVersion
-      && profileCoverage?.activation?.capability_level === activationCapabilityLevel
-      && profileReceipt?.agent_id === options.agentId
-      && profileReceipt?.harness === options.activation.harness
-      && profileReceipt?.adapter_version === activationAdapterVersion
-      && profileReceipt?.capability_level === activationCapabilityLevel
-      && typeof accountBindingId === 'string'
-      && accountBindingId.length === 64
-      && profileReceipt?.account_binding_id === accountBindingId
-      && profileReceipt?.config_fingerprint_verified === true
-      && profileReceipt?.configuration_binding_id === expectedConfigurationBindingId
-      && profileReceipt?.expected_hooks_verified === true
-      && expectedHooksMatch
+    let activationTelemetry;
+    try {
+      activationTelemetry = await requestJson(`${baseUrl}/v1/agent/integrations/events`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          event_id: `activation-${activationConfigFingerprint.slice(0, 32)}`,
+          event_type: 'activation_profile_registered',
+          harness: options.activation.harness,
+          agent_id: options.agentId,
+          session_id: headers['x-marrow-session-id'],
+          adapter_version: activationAdapterVersion,
+          capability_level: activationCapabilityLevel,
+          config_fingerprint: activationConfigFingerprint,
+          expected_hooks: activationExpectedHooks,
+          action: 'integration activation profile registered as client self-reported telemetry',
+          occurred_at: new Date().toISOString(),
+        }),
+      });
+    } catch {
+      throw new Error('activation telemetry delivery failed; retry activate after the integration-events endpoint accepts authenticated client_self_reported telemetry');
+    }
+    const telemetryAccepted = Boolean(
+      activationTelemetry?.accepted === true
+      && activationTelemetry?.evidence_authority === 'client_self_reported'
     );
+    if (!telemetryAccepted) {
+      throw new Error('activation telemetry was not acknowledged as authenticated client_self_reported delivery; update the backend/client compatibility pair, then retry activate');
+    }
+    // Never project response-supplied coverage or profile receipts into the install
+    // result. This endpoint acknowledges bounded, authenticated client telemetry;
+    // it does not certify that hooks, wrappers, or adapters continuously ran.
+    activationProfileReceipt = {
+      accepted: true,
+      evidence_authority: 'client_self_reported',
+      certified_coverage: false,
+    };
     activationVerified = Boolean(
       firstValue.active
       && runtimeGateVerified(runtime)
       && (status.enabled ?? status.ok)
-      && options.activation.complete === true
-      && profileBound,
+      && telemetryAccepted,
     );
     if (!activationVerified) {
-      throw new Error('activation prerequisites were not all verified by the server');
+      throw new Error('activation self-test prerequisites were not all verified by the server');
     }
   }
   return {
@@ -1481,9 +1488,16 @@ async function runSelfTest(options) {
     runtime_exact_next_action: runtime.exact_next_action || null,
     runtime_before_you_act: runtime.before_you_act || null,
     activation_verified: activationVerified,
+    activation_scope: options.activation ? 'server_self_test_only' : null,
+    coverage_verified: false,
+    passive_live: false,
+    reload_required: Boolean(options.activation),
+    activation_next_action: options.activation
+      ? 'Restart the owning harness, then run npx @getmarrow/install@latest doctor --self-test.'
+      : null,
     activation_receipt: activationReceipt,
     activation_profile_receipt: activationProfileReceipt,
-    activation_coverage: status.activation_coverage || firstValue.activation_coverage || null,
+    activation_coverage: null,
     first_value: firstValue && firstValue.ok !== false ? firstValue : null,
     first_value_signal: firstValueSignal,
     install_value_moment: installValueMoment,
@@ -1636,7 +1650,13 @@ function printReport(report) {
   if (report.activation?.requested) {
     process.stdout.write('Activation:\n');
     process.stdout.write(`- agent: ${report.activation.agent_id}\n`);
-    process.stdout.write(`- server confirmed: ${report.activation.server_confirmed ? 'yes' : 'no'}\n\n`);
+    process.stdout.write(`- self-test server confirmed: ${report.activation.server_confirmed ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- scope: ${report.activation.activation_scope}\n`);
+    process.stdout.write(`- coverage verified: ${report.activation.coverage_verified ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- passive live in this process: ${report.activation.passive_live ? 'yes' : 'no'}\n`);
+    process.stdout.write(`- reload required: ${report.activation.reload_required ? 'yes' : 'no'}\n`);
+    if (report.activation.next_action) process.stdout.write(`- next action: ${report.activation.next_action}\n`);
+    process.stdout.write('\n');
   }
 
   process.stdout.write('Detected:\n');
@@ -1814,12 +1834,12 @@ async function install(options) {
     throw new Error('repair requires explicit write authorization (--yes)');
   }
   const detection = detectEnvironment(options.cwd);
+  const client = detectedClient(detection);
+  options.client = client;
+  options.agentId = String(options.agentId || '').trim() || stableAgentId(detection.root, client);
   const plan = buildPlan(detection, options);
   const writeMode = options.doctor ? 'doctor' : options.dryRun ? 'dry-run' : options.repair ? 'repair' : options.yes ? 'write' : 'dry-run';
   const changes = applyPlan(plan, options);
-  const client = detectedClient(detection);
-  options.client = client;
-  if (!options.agentId) options.agentId = stableAgentId(detection.root, client);
   const profile = activationProfile(detection, plan, changes, client);
   options.activation = options.activate ? {
     harness: client,
@@ -1830,7 +1850,10 @@ async function install(options) {
       .filter((change) => change.changed && change.applied && /hook|runtime|rule|instruction|config/i.test(change.label))
       .map((change) => change.label)
       .slice(0, 20),
-    capture_verified: changes.every((change) => change.applied || change.already_present),
+    capture_verified: false,
+    configuration_complete: changes.every((change) => change.applied || change.already_present),
+    evidence_authority: 'client_self_reported',
+    coverage_verified: false,
     adapter_version: profile.adapter_version,
     capability_level: profile.capability_level,
     config_fingerprint: profile.config_fingerprint,
@@ -1932,6 +1955,11 @@ async function install(options) {
       requested: options.activate,
       agent_id: options.agentId,
       server_confirmed: Boolean(selfTest.activation_verified),
+      activation_scope: selfTest.activation_scope || null,
+      coverage_verified: false,
+      passive_live: false,
+      reload_required: Boolean(options.activate),
+      next_action: selfTest.activation_next_action || null,
       receipt: selfTest.activation_receipt || null,
       profile,
     },