@getmarrow/install 0.1.52 → 0.1.54

package/src/installer.js

@@ -5,12 +5,14 @@ const crypto = require('node:crypto');
 const { version: INSTALLER_ADAPTER_VERSION } = require('../package.json');
 const { controllerStatus, controllerSupportedPlatform, ensureGovernanceController } = require('./controller-manager');
 const { firstCapturePath, harnessReloadPlan } = require('./first-hour');
+const { evidence: localControlEvidence } = require('./control-state');
 
 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.74';
-const MCP_ADAPTER_SOURCE_SHA = 'a34a87ee1d6ea16d8ebcc26aa0e66bf7dcb5e23f';
+const MCP_ADAPTER_VERSION = '3.9.77';
+const MCP_ADAPTER_SOURCE_SHA = '1e782d8ba6bbb54bfaa322f0300565c7176f1969';
+const MCP_ADAPTER_INTEGRITY = 'sha512-4SVvnyTaDh/mhVUry1LaGCYKXSB/mt5NCHijIOLP336jILSqe7ezjZ5/EwEOMTQ2JvLm6w0QE/jmGbcksqe86w==';
 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`;
@@ -20,8 +22,8 @@ const ADAPTER_PROVENANCE = Object.freeze({
     package: '@getmarrow/mcp',
     version: MCP_ADAPTER_VERSION,
     source_sha: MCP_ADAPTER_SOURCE_SHA,
-    integrity: null,
-    integrity_state: 'registry_unavailable_until_publish',
+    integrity: MCP_ADAPTER_INTEGRITY,
+    integrity_state: 'sealed_local_candidate',
   }),
   sdk: Object.freeze({
     package: '@getmarrow/sdk',
@@ -33,21 +35,97 @@ const MCP_CONTEXT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mc
 const MCP_PRE_ACTION_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp pre-action-hook`;
 const MCP_ACTION_RESULT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp hook`;
 const MCP_SESSION_END_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp session-hook`;
+const CODEX_CONTEXT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp codex-context-hook`;
+const CODEX_PRE_ACTION_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp codex-pre-action-hook`;
+const CODEX_ACTION_RESULT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp codex-hook`;
+const CODEX_SESSION_END_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp codex-session-hook`;
+const CURSOR_PRE_ACTION_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cursor-pre-action-hook`;
+const CURSOR_ACTION_RESULT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cursor-hook`;
+const CURSOR_SESSION_END_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cursor-session-hook`;
+const CLINE_PRE_ACTION_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cline-pre-action-hook`;
+const CLINE_ACTION_RESULT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cline-hook`;
+const CLINE_SESSION_END_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cline-session-hook`;
+const WINDSURF_PRE_ACTION_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp windsurf-pre-action-hook`;
+const WINDSURF_ACTION_RESULT_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp windsurf-hook`;
+const WINDSURF_SESSION_END_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp windsurf-session-hook`;
+const WINDSURF_LAUNCH_FAILURE = 'Marrow governance adapter was unavailable; this action is blocked.';
+const WINDSURF_PRE_ACTION_HOOK_COMMAND = `sh -c 'stderr="$(${WINDSURF_PRE_ACTION_ENTRYPOINT} 2>&1 >/dev/null)"; status=$?; if [ "$status" -eq 0 ]; then exit 0; fi; if [ "$status" -eq 2 ]; then printf "%s\\n" "$stderr" >&2; exit 2; fi; printf "%s\\n" "${WINDSURF_LAUNCH_FAILURE}" >&2; exit 2'`;
+const WINDSURF_ACTION_RESULT_HOOK_COMMAND = `sh -c '${WINDSURF_ACTION_RESULT_ENTRYPOINT} >/dev/null 2>&1 || :; exit 0'`;
+const WINDSURF_SESSION_END_HOOK_COMMAND = `sh -c '${WINDSURF_SESSION_END_ENTRYPOINT} >/dev/null 2>&1 || :; exit 0'`;
+const GEMINI_PRE_ACTION_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp gemini-pre-action-hook`;
+const GEMINI_ACTION_RESULT_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp gemini-hook`;
+const GEMINI_SESSION_END_ENTRYPOINT = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp gemini-session-hook`;
+const GEMINI_FIXED_DENIAL = 'Marrow blocked this action because required governance approval or proof is unavailable.';
+const GEMINI_LAUNCH_FAILURE = 'Marrow governance adapter was unavailable; this action is blocked.';
+const GEMINI_PRE_ACTION_HOOK_COMMAND = `sh -c 'output="$(${GEMINI_PRE_ACTION_ENTRYPOINT} 2>/dev/null)" && { case "$output" in "{\\"decision\\":\\"allow\\"}"|"{\\"decision\\":\\"deny\\",\\"reason\\":\\"${GEMINI_FIXED_DENIAL}\\"}") printf "%s\\n" "$output"; exit 0 ;; esac; }; printf "%s\\n" "${GEMINI_LAUNCH_FAILURE}" >&2; exit 2'`;
+const GEMINI_ACTION_RESULT_HOOK_COMMAND = `sh -c '${GEMINI_ACTION_RESULT_ENTRYPOINT} >/dev/null 2>&1 || :; printf "%s\\n" "{}"; exit 0'`;
+const GEMINI_SESSION_END_HOOK_COMMAND = `sh -c '${GEMINI_SESSION_END_ENTRYPOINT} >/dev/null 2>&1 || :; printf "%s\\n" "{}"; exit 0'`;
+const GROK_CONTEXT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp grok-context-hook`;
+const GROK_ACTION_RESULT_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp grok-hook`;
+const GROK_SESSION_END_HOOK_COMMAND = `npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp grok-session-hook`;
+const GROK_FIXED_DENIAL = 'Marrow blocked this protected action.';
+const GROK_LAUNCH_FAILURE = 'Marrow governance adapter was unavailable; this action is blocked.';
+const GROK_PRE_ACTION_GUARD_SOURCE = [
+  'const {spawn}=require("node:child_process");',
+  `const valid=new Set([${JSON.stringify('{"decision":"allow"}')},${JSON.stringify(`{"decision":"deny","reason":"${GROK_FIXED_DENIAL}"}`)}]);`,
+  'let child=null,timer=null,done=false,input=[],inputBytes=0,output="",outputBytes=0;',
+  `const fail=()=>{if(done)return;done=true;if(timer)clearTimeout(timer);if(child&&!child.killed)child.kill("SIGKILL");process.stderr.write(${JSON.stringify(`${GROK_LAUNCH_FAILURE}\n`)});process.exitCode=2;process.stdin.destroy();};`,
+  'process.stdin.on("error",fail);',
+  'process.stdin.on("data",chunk=>{const value=Buffer.from(chunk);inputBytes+=value.length;if(inputBytes>65536){fail();return;}input.push(value);});',
+  'process.stdin.on("end",()=>{if(done)return;try{',
+  `child=spawn(process.platform==="win32"?"npx.cmd":"npx",${JSON.stringify(['-y', `--package=${MCP_PACKAGE_SPEC}`, 'marrow-mcp', 'grok-pre-action-hook'])},{stdio:["pipe","pipe","ignore"]});`,
+  'timer=setTimeout(fail,5000);',
+  'child.stdout.on("data",chunk=>{if(done)return;outputBytes+=chunk.length;if(outputBytes>512){fail();return;}output+=chunk.toString("utf8");});',
+  'child.on("error",fail);child.stdin.on("error",fail);',
+  'child.on("close",code=>{if(done)return;if(code!==0||!valid.has(output)){fail();return;}done=true;if(timer)clearTimeout(timer);process.stdout.write(output);});',
+  'child.stdin.end(Buffer.concat(input));}catch{fail();}});',
+].join('');
+const GROK_PRE_ACTION_HOOK_COMMAND = `node -e '${GROK_PRE_ACTION_GUARD_SOURCE}'`;
 const NATIVE_HOOK_MATCHER = 'Bash|Edit|Write|MultiEdit|mcp__(?!marrow_).*';
+const CODEX_NATIVE_HOOK_MATCHER = 'Bash|apply_patch|Edit|Write|MultiEdit|mcp__(?!marrow__marrow_).*|functions\\.(?!marrow_).*';
+const CURSOR_NATIVE_HOOK_MATCHER = 'Shell|Write|Delete|Task|MCP:(?!marrow(?:_.*|:marrow_.*)$).*';
+const GEMINI_NATIVE_HOOK_MATCHER = '^(?:run_shell_command|write_file|replace|edit_file|delete_file|mcp_(?!marrow_marrow_)[A-Za-z0-9_]{1,192})$';
+const GROK_NATIVE_HOOK_MATCHER = 'run_terminal_command|search_replace|write|spawn_subagent|use_tool|workflow|image_gen|image_edit|image_to_video|reference_to_video';
+const CODEX_HOOK_TIMEOUT_SECONDS = 5;
+const CODEX_SESSION_TIMEOUT_SECONDS = 3;
+const GEMINI_HOOK_TIMEOUT_MS = 5000;
+const GEMINI_CLOSEOUT_TIMEOUT_MS = 3000;
 const NATIVE_EXPECTED_HOOKS = ['prompt', 'pre_action', 'action_result', 'session_end'];
 const SOURCE_CLIENTS = new Set(['claude-code', 'cursor', 'composer', 'windsurf', 'openclaw', 'codex', 'gemini', 'grok', 'deepseek', 'qwen', 'kimi', 'minimax', 'cline', 'opencode', 'hermes', 'glm', 'mcp', 'ci', 'custom', 'unknown']);
+const TOOL_PROFILES = new Set(['primary', 'core', 'full']);
+const TOOL_PROFILE_EXPECTED_COUNTS = Object.freeze({ primary: 17, core: 7, full: null });
+const TOOL_PROFILE_EXACT_FIX = 'Unset MARROW_TOOL_PROFILE to use primary, or set MARROW_TOOL_PROFILE=core or MARROW_TOOL_PROFILE=full, then restart the owning harness and run npx @getmarrow/install@latest doctor --self-test.';
+const PRIMARY_TOOL_NAMES = Object.freeze([
+  'marrow_agent_runtime',
+  'marrow_arbitrate',
+  'marrow_coordinate',
+  'marrow_replay_compare',
+  'marrow_decision_brief',
+  'marrow_think',
+  'marrow_commit',
+  'marrow_workflow_gate',
+  'marrow_completion_contracts',
+  'marrow_evaluate_completion_contract',
+  'marrow_agent_status',
+  'marrow_value_report',
+  'marrow_buyer_proof',
+  'marrow_governance_timeline',
+  'marrow_decision_trace',
+  'marrow_fleet_lessons',
+  'marrow_model_usage',
+]);
 const HARNESS_CAPABILITY_REGISTRY = Object.freeze([
   { client: 'claude-code', capability_level: 'native_hooks', automatic: ['prompt', 'pre_action', 'action_result', 'session_end'], install_surface: 'mcp' },
-  { client: 'cursor', capability_level: 'mcp', automatic: ['mcp_tool_calls'], install_surface: 'mcp' },
-  { client: 'composer', capability_level: 'mcp', automatic: ['mcp_tool_calls'], install_surface: 'mcp' },
-  { client: 'cline', capability_level: 'mcp', automatic: ['mcp_tool_calls'], install_surface: 'mcp' },
-  { client: 'windsurf', capability_level: 'mcp', automatic: ['mcp_tool_calls'], install_surface: 'mcp' },
-  { client: 'codex', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
+  { client: 'cursor', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'mcp' },
+  { client: 'composer', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'mcp' },
+  { client: 'cline', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'cancel_closeout'], install_surface: 'mcp' },
+  { client: 'windsurf', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'response_closeout'], install_surface: 'mcp' },
+  { client: 'codex', capability_level: 'native_hooks', automatic: ['prompt', 'pre_action', 'action_result', 'session_end'], install_surface: 'mcp' },
   { client: 'opencode', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
   { client: 'hermes', capability_level: 'event_contract', automatic: [], install_surface: 'addon' },
   { client: 'openclaw', capability_level: 'event_contract', automatic: [], install_surface: 'addon' },
-  { client: 'gemini', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
-  { client: 'grok', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
+  { client: 'gemini', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'turn_closeout'], install_surface: 'mcp' },
+  { client: 'grok', capability_level: 'native_hooks', automatic: ['pre_action', 'action_result', 'turn_closeout'], install_surface: 'mcp' },
   { client: 'deepseek', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
   { client: 'qwen', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
   { client: 'kimi', capability_level: 'governed_wrapper', automatic: ['pre_action', 'action_result', 'outcome_closure'], install_surface: 'runner' },
@@ -63,6 +141,148 @@ function explicitMcpVersion(command) {
   return match ? match[1] : null;
 }
 
+function resolveToolProfile(value) {
+  const structured = value !== null && typeof value === 'object' && !Array.isArray(value);
+  const candidate = structured
+    ? value.configured_profile
+    : value;
+  const absent = !structured && candidate === undefined;
+  const structuredUnset = structured && candidate === 'unset';
+  const configuredProfile = absent || structuredUnset
+    ? 'unset'
+    : candidate;
+  if (!absent && !structuredUnset && !TOOL_PROFILES.has(configuredProfile)) {
+    throw new Error(`Invalid MARROW_TOOL_PROFILE. ${TOOL_PROFILE_EXACT_FIX}`);
+  }
+  const effectiveProfile = configuredProfile === 'unset' ? 'primary' : configuredProfile;
+  return {
+    configured_profile: configuredProfile,
+    effective_profile: effectiveProfile,
+    expected_visible_count: TOOL_PROFILE_EXPECTED_COUNTS[effectiveProfile],
+  };
+}
+
+function normalizePrimaryToolAvailability(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || value.profile !== 'primary') return null;
+  const evidence = value.entitlement_evidence;
+  const counts = value.counts;
+  const tools = Array.isArray(value.tools) ? value.tools : [];
+  if (!evidence || typeof evidence !== 'object' || evidence.authorizing !== false) return null;
+  if (!['available', 'unavailable'].includes(evidence.state)) return null;
+  if (!counts || counts.total !== 17 || !Number.isInteger(counts.entitled) || !Number.isInteger(counts.upgrade_required)) return null;
+  if (counts.entitled + counts.upgrade_required !== counts.total || tools.length !== counts.total) return null;
+  const normalizedTools = [];
+  const seen = new Set();
+  for (const tool of tools) {
+    if (!tool || typeof tool !== 'object' || !PRIMARY_TOOL_NAMES.includes(tool.name) || seen.has(tool.name)) return null;
+    if (!['entitled', 'upgrade_required'].includes(tool.state) || typeof tool.always_available !== 'boolean') return null;
+    seen.add(tool.name);
+    normalizedTools.push({
+      name: tool.name,
+      state: tool.state,
+      always_available: tool.always_available,
+      plan_feature: typeof tool.plan_feature === 'string' ? tool.plan_feature : null,
+      minimum_plan: typeof tool.minimum_plan === 'string' ? tool.minimum_plan : null,
+      owner_management_url: typeof tool.owner_management_url === 'string' ? tool.owner_management_url : '',
+    });
+  }
+  if (PRIMARY_TOOL_NAMES.some((name) => !seen.has(name))) return null;
+  const entitled = normalizedTools.filter((tool) => tool.state === 'entitled').length;
+  const upgradeRequired = normalizedTools.filter((tool) => tool.state === 'upgrade_required').length;
+  if (entitled !== counts.entitled || upgradeRequired !== counts.upgrade_required) return null;
+  return {
+    profile: 'primary',
+    current_plan: typeof value.current_plan === 'string' ? value.current_plan : null,
+    owner_management_url: typeof value.owner_management_url === 'string' ? value.owner_management_url : '',
+    entitlement_evidence: {
+      state: evidence.state,
+      source: typeof evidence.source === 'string' ? evidence.source : 'entitlement_read_unavailable',
+      authoritative: evidence.authoritative === true,
+      authorizing: false,
+    },
+    counts: { total: 17, entitled, upgrade_required: upgradeRequired },
+    tools: normalizedTools,
+  };
+}
+
+function backendEntitlementProjection(statusProfile, contextProjection) {
+  const freshProjection = normalizePrimaryToolAvailability(contextProjection);
+  if (freshProjection) {
+    return {
+      evidence_state: freshProjection.entitlement_evidence.state,
+      source: 'authenticated_backend',
+      authorizes_calls: false,
+      primary_tool_availability: freshProjection,
+    };
+  }
+  const envelope = statusProfile?.backend_entitlement_projection;
+  const projected = normalizePrimaryToolAvailability(envelope?.primary_tool_availability);
+  const source = ['authenticated_backend', 'cached_or_stale_status', 'backend_projection_not_provided'].includes(envelope?.source)
+    ? envelope.source
+    : 'backend_projection_not_provided';
+  const available = envelope?.authorizes_calls === false
+    && envelope?.evidence_state === 'available'
+    && source === 'authenticated_backend'
+    && projected?.entitlement_evidence.state === 'available';
+  return {
+    evidence_state: available ? 'available' : 'unavailable',
+    source,
+    authorizes_calls: false,
+    primary_tool_availability: projected,
+  };
+}
+
+function buildMcpToolProfileReport(value, statusProfile = null, contextProjection = null, forceReload = false) {
+  const expected = resolveToolProfile(value);
+  const reportedNames = Array.isArray(statusProfile?.visible_tool_names)
+    ? statusProfile.visible_tool_names.filter((name) => typeof name === 'string')
+    : [];
+  const reportedCount = statusProfile?.visible_tool_count;
+  const reportedConfigured = statusProfile?.configured_profile;
+  const reportedEffective = statusProfile?.effective_profile;
+  const uniqueNames = new Set(reportedNames);
+  const profileIdentityMatches = reportedConfigured === expected.configured_profile
+    && reportedEffective === expected.effective_profile;
+  const reportedCatalogIsConsistent = Number.isInteger(reportedCount)
+    && reportedCount >= 0
+    && reportedNames.length === reportedCount
+    && uniqueNames.size === reportedCount;
+  const expectedCount = expected.effective_profile === 'full'
+    && profileIdentityMatches
+    && reportedCatalogIsConsistent
+    ? reportedCount
+    : expected.expected_visible_count;
+  const expectedPrimaryNames = expected.effective_profile !== 'primary'
+    || (reportedNames.length === PRIMARY_TOOL_NAMES.length
+      && PRIMARY_TOOL_NAMES.every((name) => uniqueNames.has(name)));
+  const visibilityLive = !forceReload
+    && profileIdentityMatches
+    && statusProfile?.local_visibility_grants_entitlement === false
+    && reportedCatalogIsConsistent
+    && reportedCount === expectedCount
+    && expectedPrimaryNames;
+  return {
+    configured_profile: expected.configured_profile,
+    effective_profile: expected.effective_profile,
+    expected_visible_count: expectedCount,
+    visible_tool_count: visibilityLive ? reportedCount : null,
+    actual_visible_count: visibilityLive ? reportedCount : null,
+    visible_tool_names: visibilityLive ? reportedNames : [],
+    local_visibility_grants_entitlement: false,
+    visibility_live: visibilityLive,
+    reload_required: !visibilityLive,
+    reported_configured_profile: typeof reportedConfigured === 'string' ? reportedConfigured : null,
+    reported_effective_profile: typeof reportedEffective === 'string' ? reportedEffective : null,
+    backend_entitlement_projection: backendEntitlementProjection(statusProfile, contextProjection),
+  };
+}
+
+function initialToolProfileReport(value) {
+  return {
+    ...buildMcpToolProfileReport(value),
+  };
+}
+
 function readMcpPackageVersion(packageRoot) {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
@@ -252,7 +472,7 @@ function sourceClient() {
   return aliases[raw] || (SOURCE_CLIENTS.has(raw) ? raw : 'custom');
 }
 
-function parseArgs(argv) {
+function parseArgs(argv, env = process.env) {
   const options = {
     cwd: process.cwd(),
     yes: false,
@@ -260,50 +480,79 @@ function parseArgs(argv) {
     doctor: false,
     repair: false,
     mode: 'auto',
-    apiKey: process.env.MARROW_API_KEY || '',
-    baseUrl: process.env.MARROW_BASE_URL || DEFAULT_BASE_URL,
-    agentId: process.env.MARROW_FLEET_AGENT_ID || process.env.MARROW_AGENT_ID || '',
+    apiKey: env.MARROW_API_KEY || '',
+    baseUrl: env.MARROW_BASE_URL || DEFAULT_BASE_URL,
+    agentId: env.MARROW_FLEET_AGENT_ID || env.MARROW_AGENT_ID || '',
+    toolProfile: resolveToolProfile(env.MARROW_TOOL_PROFILE),
     selfTest: true,
     selfTestExplicitlyDisabled: false,
     json: false,
     activate: false,
     controller: true,
   };
+  let explicitOperation = false;
 
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === 'activate' || arg === '--activate') {
+      explicitOperation = true;
       options.activate = true;
       options.yes = true;
       options.selfTest = true;
     }
-    else if (arg === '--yes' || arg === '-y') options.yes = true;
+    else if (arg === '--yes' || arg === '-y') {
+      explicitOperation = true;
+      options.yes = true;
+    }
     else if (arg === '--repair' || arg === 'repair' || arg === 'update' || arg === '--update') {
+      explicitOperation = true;
       options.repair = true;
       options.yes = true;
       options.update = true;
     }
-    else if (arg === '--dry-run') options.dryRun = true;
-    else if (arg === '--doctor' || arg === 'doctor' || arg === 'check') options.doctor = true;
+    else if (arg === '--dry-run') {
+      explicitOperation = true;
+      options.dryRun = true;
+    }
+    else if (arg === '--doctor' || arg === 'doctor' || arg === 'check') {
+      explicitOperation = true;
+      options.doctor = true;
+    }
     else if (arg === '--json') options.json = true;
     else if (arg === '--no-self-test') {
+      explicitOperation = true;
       options.selfTest = false;
       options.selfTestExplicitlyDisabled = true;
     }
     else if (arg === '--no-controller') options.controller = false;
     else if (arg === '--self-test') options.selfTest = true;
     else if (arg === '--cwd') options.cwd = path.resolve(argv[++i] || options.cwd);
-    else if (arg === '--mode') options.mode = argv[++i] || options.mode;
+    else if (arg === '--mode') {
+      explicitOperation = true;
+      options.mode = argv[++i] || options.mode;
+    }
     else if (arg === '--key') {
       options.apiKey = argv[++i] || options.apiKey;
       options.keyFromArg = true;
     }
     else if (arg === '--base-url') options.baseUrl = argv[++i] || options.baseUrl;
     else if (arg === '--agent-id') options.agentId = argv[++i] || options.agentId;
-    else if (arg === '--mcp') options.mode = 'mcp';
-    else if (arg === '--sdk') options.mode = 'sdk';
-    else if (arg === '--md' || arg === '--instructions') options.mode = 'md';
-    else if (arg === '--both') options.mode = 'both';
+    else if (arg === '--mcp') {
+      explicitOperation = true;
+      options.mode = 'mcp';
+    }
+    else if (arg === '--sdk') {
+      explicitOperation = true;
+      options.mode = 'sdk';
+    }
+    else if (arg === '--md' || arg === '--instructions') {
+      explicitOperation = true;
+      options.mode = 'md';
+    }
+    else if (arg === '--both') {
+      explicitOperation = true;
+      options.mode = 'both';
+    }
     else if (arg === '--help' || arg === '-h') {
       options.help = true;
     } else {
@@ -314,6 +563,12 @@ function parseArgs(argv) {
   if (!['auto', 'mcp', 'sdk', 'both', 'md'].includes(options.mode)) {
     throw new Error('--mode must be one of auto, mcp, sdk, both, md');
   }
+  if (!explicitOperation) {
+    options.activate = true;
+    options.yes = true;
+    options.selfTest = true;
+  }
+  if (options.dryRun) options.selfTest = false;
   if (options.activate && options.selfTestExplicitlyDisabled) {
     throw new Error('activate cannot be combined with --no-self-test because server verification is required');
   }
@@ -326,6 +581,7 @@ function parseArgs(argv) {
 
 function usage() {
   return `Usage:
+  npx @getmarrow/install
   npx @getmarrow/install --dry-run
   npx @getmarrow/install activate
   npx @getmarrow/install --yes
@@ -336,6 +592,7 @@ function usage() {
   npx @getmarrow/install --sdk --yes
 
 Options:
+  (no command)       Detect, install, self-test, and start the supported persistent controller
   activate           Detect, install, self-test, and return a server-confirmed activation receipt
   --dry-run          Print planned changes without writing
   --doctor           Check install health without writing
@@ -348,6 +605,10 @@ Options:
   --agent-id <id>    Agent/fleet id for self-test headers
   --no-controller    Do not start the local background controller during install/repair
   --no-self-test     Skip API smoke/self-test
+
+Environment:
+  MARROW_TOOL_PROFILE  Leave unset for primary (17 tools), or explicitly set primary, core, or full.
+                       Visibility never grants entitlement; backend plans and permissions authorize calls.
 `;
 }
 
@@ -361,6 +622,9 @@ function detectedClient(detection) {
   if (detection.openclaw) return 'openclaw';
   if (detection.claudeCode) return 'claude-code';
   if (detection.cursor) return 'cursor';
+  if (detection.cline) return 'cline';
+  if (detection.windsurf) return 'windsurf';
+  if (detection.gemini) return 'gemini';
   if (detection.codex) return 'codex';
   return 'custom';
 }
@@ -402,6 +666,14 @@ function detectEnvironment(cwd = process.cwd(), env = process.env) {
     requirements: path.join(root, 'requirements.txt'),
     setupPy: path.join(root, 'setup.py'),
     claudeSettings: path.join(root, '.claude', 'settings.json'),
+    codexHooks: path.join(root, '.codex', 'hooks.json'),
+    cursorHooks: path.join(root, '.cursor', 'hooks.json'),
+    windsurfHooks: path.join(root, '.windsurf', 'hooks.json'),
+    geminiSettings: path.join(root, '.gemini', 'settings.json'),
+    grokHooks: path.join(home, '.grok', 'hooks', 'marrow.json'),
+    clinePreToolUseHook: path.join(root, '.clinerules', 'hooks', 'PreToolUse'),
+    clinePostToolUseHook: path.join(root, '.clinerules', 'hooks', 'PostToolUse'),
+    clineTaskCancelHook: path.join(root, '.clinerules', 'hooks', 'TaskCancel'),
     claudeMd: path.join(root, 'CLAUDE.md'),
     agentsMd: path.join(root, 'AGENTS.md'),
     cursorRules: path.join(root, '.cursor', 'rules', 'marrow.mdc'),
@@ -420,6 +692,10 @@ function detectEnvironment(cwd = process.cwd(), env = process.env) {
     python: exists(paths.pyproject) || exists(paths.requirements) || exists(paths.setupPy),
     claudeCode: exists(paths.claudeSettings) || exists(paths.claudeMd),
     cursor: exists(path.join(root, '.cursor')),
+    cline: exists(path.join(root, '.clinerules')),
+    windsurf: exists(path.join(root, '.windsurf')),
+    gemini: exists(path.join(root, '.gemini')),
+    grok: exists(path.join(home, '.grok')) || exists(path.join(root, '.grok')),
     codex: exists(paths.agentsMd) || exists(path.join(root, '.codex')),
     mcpConfig: exists(paths.mcpJson) || exists(paths.cursorMcp) || exists(paths.claudeSettings),
     openclaw: exists(paths.openclawJson) || Boolean(env.OPENCLAW_HOME || env.OPENCLAW_AGENT_ID),
@@ -621,13 +897,14 @@ function passiveInstructions() {
 Marrow should run passively after install:
 
 - Use MCP plus these instructions in every workspace: \`npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp setup\`.
+- Leave \`MARROW_TOOL_PROFILE\` unset for the 17-tool primary surface. Set \`MARROW_TOOL_PROFILE=core\` or \`MARROW_TOOL_PROFILE=full\` only as an explicit opt-in; backend plans and permissions still enforce access to every visible tool.
 - Use SDK passive runtime in owned Node processes: \`createPassiveRuntime().install()\`.
-- Native Claude hooks install only when \`.claude\` is present. Cursor, Composer, Cline, and Windsurf get MCP tools on demand. Codex, Grok, Gemini, and similar CLI harnesses use the governed wrapper. Hermes, OpenClaw, and custom hosts need a bounded event adapter.
+- Native Claude hooks install only when \`.claude\` is present. Codex native hooks install into \`.codex/hooks.json\`; Cursor and Composer use \`.cursor/hooks.json\`; Cline uses non-overwriting executable files under \`.clinerules/hooks/\`; Windsurf uses \`.windsurf/hooks.json\`; Gemini CLI uses \`.gemini/settings.json\`; Grok uses trusted global \`~/.grok/hooks/marrow.json\`. Restart the host, enable/review hooks, disable Windsurf Restricted Mode where native hooks are required, and trust the workspace before claiming runtime coverage. The governed wrapper remains an explicit bounded fallback. Hermes, OpenClaw, and custom hosts need a bounded event adapter.
 - Keep passive token/model usage proof enabled. Empty savings stay zero until observed model usage lands. Do not invent token, cost, or time savings.
 - Before risky work, use Marrow's decision brief or passive prompt hook.
 - After activate writes MCP or hooks, restart this harness, then run \`npx @getmarrow/install@latest doctor --self-test\`. Do not claim Marrow is live in a process that has not reloaded.
 - First turn: tell the owner the gate is live and empty savings are honest. The next deploy, merge, or publish must go through Marrow.
-- Cursor, Composer, Cline, and Windsurf: call \`marrow_agent_runtime\` before those actions. Codex, Grok, Gemini, and similar CLIs: wrap them with \`npx @getmarrow/install run --agent <agent-id> -- -- <command>\`.
+- Cursor and Composer use configured native hooks after restart and \`/hooks\` trust review. Cline uses its configured PreToolUse, PostToolUse, and TaskCancel hooks only after Enable Hooks, restart, executable trust, and workspace trust; TaskComplete is not claimed as current coverage. Windsurf uses configured native pre-action, success-result, and response-closeout hooks only after restart, trust review, and leaving Restricted Mode. Gemini CLI uses configured BeforeTool, AfterTool, and AfterAgent hooks only after restart and project fingerprint review and approval in \`/hooks panel\`; explicit user disablement is preserved. Grok uses global native PreToolUse, PostToolUse/PostToolUseFailure, and one nonblocking Stop closeout only after restart and \`/hooks\` inspection; Grok hooks remain user-toggleable. MCP tools remain on demand. Codex uses configured native hooks after restart and \`/hooks\` trust review. The governed wrapper remains an explicit bounded fallback.
 - Before the session ends, close open work with session-end auto-commit or \`marrow_commit\`. Record model usage only when the host response includes counts.
 - After meaningful work, record the outcome so future agents learn from it.
 - After Marrow blocks, warns, or requires review, use the decision trace receipt to tell the operator what changed and which recorded workflow or proof is required. Stay quiet for routine low-risk work.
@@ -684,6 +961,7 @@ function envExample(options = {}) {
 MARROW_BASE_URL=${JSON.stringify(baseUrl)}
 MARROW_FLEET_AGENT_ID=${JSON.stringify(agentId)}
 MARROW_CLIENT=${JSON.stringify(client)}
+# MARROW_TOOL_PROFILE is intentionally unset: ordinary setup uses primary. Set core or full only as an explicit opt-in.
 MARROW_ENFORCEMENT_MODE=auto
 MARROW_PASSIVE_BRIEF=auto
 MARROW_PASSIVE_VALUE_REPORT=true
@@ -757,12 +1035,12 @@ function exactHookDescriptors(settings, eventName, command, matcher) {
 function marrowHookSubcommand(command) {
   if (typeof command !== 'string') return null;
   const match = command.trim().match(
-    /^npx\s+(?:-y\s+)?(?:--package=@getmarrow\/mcp(?:@[^\s]+)?\s+marrow-mcp|@getmarrow\/mcp(?:@[^\s]+)?)\s+(context-hook|pre-action-hook|hook|session-hook)$/,
+    /^npx\s+(?:-y\s+)?(?:--package=@getmarrow\/mcp(?:@[^\s]+)?\s+marrow-mcp|@getmarrow\/mcp(?:@[^\s]+)?)\s+(?:(?:claude|codex|cursor|grok)-)?(context-hook|pre-action-hook|hook|session-hook)$/,
   );
   return match?.[1] || null;
 }
 
-function reconcileMarrowCommandHook(settings, eventName, subcommand, command, matcher) {
+function reconcileMarrowCommandHook(settings, eventName, subcommand, command, matcher, handlerOptions = {}) {
   const original = Array.isArray(settings?.hooks?.[eventName]) ? settings.hooks[eventName] : [];
   let preferredHandler = null;
   const retained = [];
@@ -786,7 +1064,7 @@ function reconcileMarrowCommandHook(settings, eventName, subcommand, command, ma
     }
     if (remaining.length > 0) retained.push({ ...entry, hooks: remaining });
   }
-  const canonical = { hooks: [{ ...(preferredHandler || {}), type: 'command', command }] };
+  const canonical = { hooks: [{ ...(preferredHandler || {}), ...handlerOptions, type: 'command', command }] };
   if (matcher != null) canonical.matcher = matcher;
   retained.push(canonical);
   return retained;
@@ -882,6 +1160,439 @@ function upsertClaudeHooks(settingsPath) {
   return JSON.stringify(settings, null, 2) + '\n';
 }
 
+function codexNativeHookFingerprint(settings) {
+  const contract = {
+    schema: 'marrow-codex-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    expected_hooks: NATIVE_EXPECTED_HOOKS,
+    configured: {
+      prompt: exactHookConfigured(settings, 'UserPromptSubmit', CODEX_CONTEXT_HOOK_COMMAND),
+      pre_action: exactHookConfigured(settings, 'PreToolUse', CODEX_PRE_ACTION_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER),
+      action_result: exactHookConfigured(settings, 'PostToolUse', CODEX_ACTION_RESULT_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER),
+      session_end: exactHookConfigured(settings, 'SessionEnd', CODEX_SESSION_END_HOOK_COMMAND),
+    },
+    descriptors: {
+      prompt: exactHookDescriptors(settings, 'UserPromptSubmit', CODEX_CONTEXT_HOOK_COMMAND),
+      pre_action: exactHookDescriptors(settings, 'PreToolUse', CODEX_PRE_ACTION_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER),
+      action_result: exactHookDescriptors(settings, 'PostToolUse', CODEX_ACTION_RESULT_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER),
+      session_end: exactHookDescriptors(settings, 'SessionEnd', CODEX_SESSION_END_HOOK_COMMAND),
+    },
+    active_marrow_handlers: {
+      prompt: marrowHookDescriptors(settings, 'UserPromptSubmit'),
+      pre_action: marrowHookDescriptors(settings, 'PreToolUse'),
+      action_result: marrowHookDescriptors(settings, 'PostToolUse'),
+      session_end: marrowHookDescriptors(settings, 'SessionEnd'),
+    },
+  };
+  return crypto.createHash('sha256').update(JSON.stringify(contract)).digest('hex');
+}
+
+function upsertCodexHooks(hooksPath) {
+  const settings = parseJsonObject(hooksPath);
+  const hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)
+    ? settings.hooks
+    : {};
+  settings.hooks = {
+    ...hooks,
+    UserPromptSubmit: reconcileMarrowCommandHook(
+      settings, 'UserPromptSubmit', 'context-hook', CODEX_CONTEXT_HOOK_COMMAND, undefined,
+      { timeout: CODEX_HOOK_TIMEOUT_SECONDS },
+    ),
+    PreToolUse: reconcileMarrowCommandHook(
+      settings, 'PreToolUse', 'pre-action-hook', CODEX_PRE_ACTION_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER,
+      { timeout: CODEX_HOOK_TIMEOUT_SECONDS, async: false },
+    ),
+    PostToolUse: reconcileMarrowCommandHook(
+      settings, 'PostToolUse', 'hook', CODEX_ACTION_RESULT_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER,
+      { timeout: CODEX_HOOK_TIMEOUT_SECONDS },
+    ),
+    SessionEnd: reconcileMarrowCommandHook(
+      settings, 'SessionEnd', 'session-hook', CODEX_SESSION_END_HOOK_COMMAND, undefined,
+      { timeout: CODEX_SESSION_TIMEOUT_SECONDS },
+    ),
+  };
+  return JSON.stringify(settings, null, 2) + '\n';
+}
+
+function reconcileCursorHook(settings, eventName, subcommand, canonical) {
+  const original = Array.isArray(settings?.hooks?.[eventName]) ? settings.hooks[eventName] : [];
+  const retained = original.filter((entry) => !(
+    entry && typeof entry === 'object' && !Array.isArray(entry)
+    && marrowHookSubcommand(entry.command)
+  ));
+  return [...retained, canonical];
+}
+
+function exactCursorHookConfigured(settings, eventName, command, matcher, required = {}) {
+  const entries = settings?.hooks?.[eventName];
+  if (!Array.isArray(entries)) return false;
+  return entries.some((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
+    && entry.command === command
+    && (matcher === undefined ? entry.matcher === undefined : entry.matcher === matcher)
+    && Object.entries(required).every(([key, value]) => entry[key] === value));
+}
+
+function cursorHookDescriptors(settings, eventName) {
+  const entries = settings?.hooks?.[eventName];
+  if (!Array.isArray(entries)) return [];
+  return entries.flatMap((entry) => {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry) || !marrowHookSubcommand(entry.command)) return [];
+    return [{
+      matcher: typeof entry.matcher === 'string' ? entry.matcher : null,
+      command: String(entry.command).trim(),
+      timeout: typeof entry.timeout === 'number' && Number.isFinite(entry.timeout) ? entry.timeout : null,
+      failClosed: entry.failClosed === true,
+      async: entry.async === false ? false : null,
+    }];
+  });
+}
+
+function cursorNativeHookFingerprint(settings) {
+  const contract = {
+    schema: 'marrow-cursor-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    expected_hooks: ['pre_action', 'action_result', 'outcome_closure'],
+    configured: {
+      pre_action: exactCursorHookConfigured(settings, 'preToolUse', CURSOR_PRE_ACTION_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+        failClosed: true,
+        async: false,
+      }),
+      action_result_success: exactCursorHookConfigured(settings, 'postToolUse', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+      }),
+      action_result_failure: exactCursorHookConfigured(settings, 'postToolUseFailure', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+      }),
+      outcome_closure: exactCursorHookConfigured(settings, 'stop', CURSOR_SESSION_END_HOOK_COMMAND, undefined, {
+        timeout: CODEX_SESSION_TIMEOUT_SECONDS,
+      }),
+    },
+    descriptors: {
+      pre_action: cursorHookDescriptors(settings, 'preToolUse'),
+      action_result_success: cursorHookDescriptors(settings, 'postToolUse'),
+      action_result_failure: cursorHookDescriptors(settings, 'postToolUseFailure'),
+      outcome_closure: cursorHookDescriptors(settings, 'stop'),
+    },
+  };
+  return crypto.createHash('sha256').update(JSON.stringify(contract)).digest('hex');
+}
+
+function upsertCursorHooks(hooksPath) {
+  const settings = parseJsonObject(hooksPath);
+  const hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)
+    ? settings.hooks
+    : {};
+  settings.version = 1;
+  settings.hooks = {
+    ...hooks,
+    preToolUse: reconcileCursorHook(settings, 'preToolUse', 'pre-action-hook', {
+      command: CURSOR_PRE_ACTION_HOOK_COMMAND,
+      matcher: CURSOR_NATIVE_HOOK_MATCHER,
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+      failClosed: true,
+      async: false,
+    }),
+    postToolUse: reconcileCursorHook(settings, 'postToolUse', 'hook', {
+      command: CURSOR_ACTION_RESULT_HOOK_COMMAND,
+      matcher: CURSOR_NATIVE_HOOK_MATCHER,
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+    }),
+    postToolUseFailure: reconcileCursorHook(settings, 'postToolUseFailure', 'hook', {
+      command: CURSOR_ACTION_RESULT_HOOK_COMMAND,
+      matcher: CURSOR_NATIVE_HOOK_MATCHER,
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+    }),
+    stop: reconcileCursorHook(settings, 'stop', 'session-hook', {
+      command: CURSOR_SESSION_END_HOOK_COMMAND,
+      timeout: CODEX_SESSION_TIMEOUT_SECONDS,
+    }),
+  };
+  return JSON.stringify(settings, null, 2) + '\n';
+}
+
+const WINDSURF_PRE_EVENTS = ['pre_write_code', 'pre_run_command', 'pre_mcp_tool_use'];
+const WINDSURF_POST_EVENTS = ['post_write_code', 'post_run_command', 'post_mcp_tool_use'];
+
+function windsurfMarrowHookEntrypoint(command) {
+  if (typeof command !== 'string') return null;
+  const match = command.match(/@getmarrow\/mcp(?:@[^\s]+)?\s+marrow-mcp\s+windsurf-(pre-action-hook|hook|session-hook)(?:\s|['"]|$)/);
+  return match?.[1] || null;
+}
+
+function reconcileWindsurfHook(settings, eventName, command) {
+  const original = Array.isArray(settings?.hooks?.[eventName]) ? settings.hooks[eventName] : [];
+  const retained = original.filter((entry) => !(
+    entry && typeof entry === 'object' && !Array.isArray(entry)
+    && windsurfMarrowHookEntrypoint(entry.command)
+  ));
+  return [...retained, { command, show_output: false }];
+}
+
+function exactWindsurfHookConfigured(settings, eventName, command) {
+  const entries = settings?.hooks?.[eventName];
+  return Array.isArray(entries) && entries.some((entry) => (
+    entry && typeof entry === 'object' && !Array.isArray(entry)
+    && entry.command === command
+    && entry.show_output === false
+  ));
+}
+
+function windsurfNativeHookFingerprint(settings) {
+  const configured = Object.fromEntries([
+    ...WINDSURF_PRE_EVENTS.map((event) => [event, exactWindsurfHookConfigured(settings, event, WINDSURF_PRE_ACTION_HOOK_COMMAND)]),
+    ...WINDSURF_POST_EVENTS.map((event) => [event, exactWindsurfHookConfigured(settings, event, WINDSURF_ACTION_RESULT_HOOK_COMMAND)]),
+    ['post_cascade_response', exactWindsurfHookConfigured(settings, 'post_cascade_response', WINDSURF_SESSION_END_HOOK_COMMAND)],
+  ]);
+  return crypto.createHash('sha256').update(JSON.stringify({
+    schema: 'marrow-windsurf-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    expected_hooks: ['pre_action', 'action_result', 'response_closeout'],
+    restricted_mode_disables_hooks: true,
+    configured,
+  })).digest('hex');
+}
+
+function upsertWindsurfHooks(hooksPath) {
+  const settings = parseJsonObject(hooksPath);
+  const hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)
+    ? settings.hooks
+    : {};
+  settings.hooks = { ...hooks };
+  for (const eventName of WINDSURF_PRE_EVENTS) {
+    settings.hooks[eventName] = reconcileWindsurfHook(
+      settings, eventName, WINDSURF_PRE_ACTION_HOOK_COMMAND,
+    );
+  }
+  for (const eventName of WINDSURF_POST_EVENTS) {
+    settings.hooks[eventName] = reconcileWindsurfHook(
+      settings, eventName, WINDSURF_ACTION_RESULT_HOOK_COMMAND,
+    );
+  }
+  settings.hooks.post_cascade_response = reconcileWindsurfHook(
+    settings, 'post_cascade_response', WINDSURF_SESSION_END_HOOK_COMMAND,
+  );
+  return JSON.stringify(settings, null, 2) + '\n';
+}
+
+function geminiMarrowHookEntrypoint(command) {
+  if (typeof command !== 'string') return null;
+  const match = command.match(/@getmarrow\/mcp(?:@[^\s]+)?\s+marrow-mcp\s+gemini-(pre-action-hook|hook|session-hook)(?:\s|['"]|$)/);
+  return match?.[1] || null;
+}
+
+function reconcileGeminiHook(settings, eventName, canonical) {
+  const original = Array.isArray(settings?.hooks?.[eventName]) ? settings.hooks[eventName] : [];
+  const retained = [];
+  for (const group of original) {
+    if (!group || typeof group !== 'object' || Array.isArray(group) || !Array.isArray(group.hooks)) {
+      retained.push(group);
+      continue;
+    }
+    const hooks = group.hooks.filter((handler) => !(
+      handler && typeof handler === 'object' && !Array.isArray(handler)
+      && (String(handler.name || '').startsWith('marrow-') || geminiMarrowHookEntrypoint(handler.command))
+    ));
+    if (hooks.length > 0) retained.push({ ...group, hooks });
+  }
+  return [...retained, canonical];
+}
+
+function exactGeminiHookConfigured(settings, eventName, name, command, matcher, timeout) {
+  const groups = settings?.hooks?.[eventName];
+  if (!Array.isArray(groups)) return false;
+  return groups.some((group) => (
+    group && typeof group === 'object' && !Array.isArray(group)
+    && (matcher === undefined ? group.matcher === undefined : group.matcher === matcher)
+    && Array.isArray(group.hooks)
+    && group.hooks.some((handler) => (
+      handler && typeof handler === 'object' && !Array.isArray(handler)
+      && handler.name === name
+      && handler.type === 'command'
+      && handler.command === command
+      && handler.timeout === timeout
+    ))
+  ));
+}
+
+function geminiHooksExplicitlyDisabled(settings) {
+  return settings?.hooksConfig?.enabled === false;
+}
+
+function geminiNativeHookFingerprint(settings) {
+  return crypto.createHash('sha256').update(JSON.stringify({
+    schema: 'marrow-gemini-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    expected_hooks: ['pre_action', 'action_result', 'turn_closeout'],
+    explicitly_enabled: settings?.hooksConfig?.enabled === true,
+    explicitly_disabled: geminiHooksExplicitlyDisabled(settings),
+    configured: {
+      pre_action: exactGeminiHookConfigured(
+        settings, 'BeforeTool', 'marrow-before-tool', GEMINI_PRE_ACTION_HOOK_COMMAND,
+        GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+      ),
+      action_result: exactGeminiHookConfigured(
+        settings, 'AfterTool', 'marrow-after-tool', GEMINI_ACTION_RESULT_HOOK_COMMAND,
+        GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+      ),
+      turn_closeout: exactGeminiHookConfigured(
+        settings, 'AfterAgent', 'marrow-after-agent', GEMINI_SESSION_END_HOOK_COMMAND,
+        undefined, GEMINI_CLOSEOUT_TIMEOUT_MS,
+      ),
+    },
+    session_end_claimed: false,
+  })).digest('hex');
+}
+
+function exactGrokHookConfigured(settings, eventName, command, matcher, timeout) {
+  const entries = settings?.hooks?.[eventName];
+  if (!Array.isArray(entries)) return false;
+  return entries.some((entry) => (
+    entry && typeof entry === 'object' && !Array.isArray(entry)
+    && (matcher === undefined ? entry.matcher === undefined : entry.matcher === matcher)
+    && Array.isArray(entry.hooks)
+    && entry.hooks.some((handler) => (
+      handler && typeof handler === 'object' && !Array.isArray(handler)
+      && handler.type === 'command'
+      && handler.command === command
+      && handler.timeout === timeout
+    ))
+  ));
+}
+
+function grokHasDuplicateSessionEnd(settings) {
+  const entries = settings?.hooks?.SessionEnd;
+  if (!Array.isArray(entries)) return false;
+  return entries.some((entry) => Array.isArray(entry?.hooks) && entry.hooks.some((handler) => (
+    handler && typeof handler === 'object' && !Array.isArray(handler)
+    && typeof handler.command === 'string'
+    && /marrow-mcp\s+grok-session-hook(?:\s|['"]|$)/.test(handler.command)
+  )));
+}
+
+function grokNativeHookFingerprint(settings) {
+  return crypto.createHash('sha256').update(JSON.stringify({
+    schema: 'marrow-grok-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    expected_hooks: ['pre_action', 'action_result', 'turn_closeout'],
+    configured: {
+      context: exactGrokHookConfigured(settings, 'UserPromptSubmit', GROK_CONTEXT_HOOK_COMMAND, undefined, 5),
+      pre_action: exactGrokHookConfigured(settings, 'PreToolUse', GROK_PRE_ACTION_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 7),
+      action_result_success: exactGrokHookConfigured(settings, 'PostToolUse', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5),
+      action_result_failure: exactGrokHookConfigured(settings, 'PostToolUseFailure', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5),
+      turn_closeout: exactGrokHookConfigured(settings, 'Stop', GROK_SESSION_END_HOOK_COMMAND, undefined, 3),
+      duplicate_session_end: grokHasDuplicateSessionEnd(settings),
+    },
+  })).digest('hex');
+}
+
+function upsertGeminiHooks(settingsPath) {
+  const settings = parseJsonObject(settingsPath);
+  const hooks = settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)
+    ? settings.hooks
+    : {};
+  settings.hooks = {
+    ...hooks,
+    BeforeTool: reconcileGeminiHook(settings, 'BeforeTool', {
+      matcher: GEMINI_NATIVE_HOOK_MATCHER,
+      hooks: [{
+        name: 'marrow-before-tool',
+        type: 'command',
+        command: GEMINI_PRE_ACTION_HOOK_COMMAND,
+        timeout: GEMINI_HOOK_TIMEOUT_MS,
+      }],
+    }),
+    AfterTool: reconcileGeminiHook(settings, 'AfterTool', {
+      matcher: GEMINI_NATIVE_HOOK_MATCHER,
+      hooks: [{
+        name: 'marrow-after-tool',
+        type: 'command',
+        command: GEMINI_ACTION_RESULT_HOOK_COMMAND,
+        timeout: GEMINI_HOOK_TIMEOUT_MS,
+      }],
+    }),
+    AfterAgent: reconcileGeminiHook(settings, 'AfterAgent', {
+      hooks: [{
+        name: 'marrow-after-agent',
+        type: 'command',
+        command: GEMINI_SESSION_END_HOOK_COMMAND,
+        timeout: GEMINI_CLOSEOUT_TIMEOUT_MS,
+      }],
+    }),
+  };
+  return JSON.stringify(settings, null, 2) + '\n';
+}
+
+function clinePreToolUseHookSource() {
+  return `#!/bin/sh
+output="$(npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp cline-pre-action-hook 2>/dev/null)" || output=""
+if [ -n "$output" ]; then
+  validated="$(printf '%s' "$output" | NODE_OPTIONS= node -e 'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",c=>s+=c);process.stdin.on("end",()=>{try{const v=JSON.parse(s);const keys=Object.keys(v).sort();const allow=v.cancel===false&&keys.length===1&&keys[0]==="cancel";const deny=v.cancel===true&&typeof v.errorMessage==="string"&&v.errorMessage.length>0&&v.errorMessage.length<=500&&keys.length===2&&keys[0]==="cancel"&&keys[1]==="errorMessage";if(!allow&&!deny)process.exit(1);process.stdout.write(JSON.stringify(v));}catch{process.exit(1);}});' 2>/dev/null)" || validated=""
+  if [ -n "$validated" ]; then
+    printf '%s\n' "$validated"
+    exit 0
+  fi
+fi
+printf '%s\n' '{"cancel":true,"errorMessage":"Marrow governance did not return a valid decision. Restore trusted configuration and retry."}'
+exit 0
+`;
+}
+
+function clineTelemetryHookSource(entrypoint) {
+  return `#!/bin/sh
+npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp ${entrypoint} >/dev/null 2>&1 || :
+exit 0
+`;
+}
+
+function clineHookContract(detection) {
+  return [
+    {
+      stage: 'pre_action',
+      path: detection.paths.clinePreToolUseHook,
+      label: 'Cline PreToolUse native hook',
+      content: clinePreToolUseHookSource(),
+    },
+    {
+      stage: 'action_result',
+      path: detection.paths.clinePostToolUseHook,
+      label: 'Cline PostToolUse native hook',
+      content: clineTelemetryHookSource('cline-hook'),
+    },
+    {
+      stage: 'cancel_closeout',
+      path: detection.paths.clineTaskCancelHook,
+      label: 'Cline TaskCancel native hook',
+      content: clineTelemetryHookSource('cline-session-hook'),
+    },
+  ];
+}
+
+function exactExecutableFile(filePath, content) {
+  try {
+    const stat = fs.lstatSync(filePath);
+    return stat.isFile() && !stat.isSymbolicLink() && (stat.mode & 0o111) !== 0 && safeRead(filePath) === content;
+  } catch {
+    return false;
+  }
+}
+
+function clineNativeHookFingerprint(detection) {
+  const hooks = clineHookContract(detection).map((hook) => ({
+    stage: hook.stage,
+    configured: exactExecutableFile(hook.path, hook.content),
+    content_sha256: exactExecutableFile(hook.path, hook.content)
+      ? crypto.createHash('sha256').update(hook.content).digest('hex')
+      : null,
+  }));
+  return crypto.createHash('sha256').update(JSON.stringify({
+    schema: 'marrow-cline-native-hooks.v1',
+    adapter_version: MCP_ADAPTER_VERSION,
+    task_complete_support: 'coming_soon_not_configured',
+    hooks,
+  })).digest('hex');
+}
+
 function activationProfile(detection, plan, changes, client) {
   const registry = HARNESS_CAPABILITY_REGISTRY.find((entry) => entry.client === client)
     || HARNESS_CAPABILITY_REGISTRY.find((entry) => entry.client === 'custom');
@@ -899,15 +1610,78 @@ function activationProfile(detection, plan, changes, client) {
     : INSTALLER_ADAPTER_VERSION;
   const observedHooks = [];
   const claudeSettings = safeJsonObject(detection.paths.claudeSettings);
-  if (capabilityLevel === 'native_hooks'
-    && exactHookConfigured(claudeSettings, 'UserPromptSubmit', MCP_CONTEXT_HOOK_COMMAND)) observedHooks.push('prompt');
-  if (capabilityLevel === 'native_hooks'
-    && exactHookConfigured(claudeSettings, 'PreToolUse', MCP_PRE_ACTION_HOOK_COMMAND, NATIVE_HOOK_MATCHER)) observedHooks.push('pre_action');
-  if (capabilityLevel === 'native_hooks'
-    && exactHookConfigured(claudeSettings, 'PostToolUse', MCP_ACTION_RESULT_HOOK_COMMAND, NATIVE_HOOK_MATCHER)
-    && exactHookConfigured(claudeSettings, 'PostToolUseFailure', MCP_ACTION_RESULT_HOOK_COMMAND, NATIVE_HOOK_MATCHER)) observedHooks.push('action_result');
-  if (capabilityLevel === 'native_hooks'
-    && exactHookConfigured(claudeSettings, 'Stop', MCP_SESSION_END_HOOK_COMMAND)) observedHooks.push('session_end');
+  const codexSettings = safeJsonObject(detection.paths.codexHooks);
+  const cursorSettings = safeJsonObject(detection.paths.cursorHooks);
+  const windsurfSettings = safeJsonObject(detection.paths.windsurfHooks);
+  const geminiSettings = safeJsonObject(detection.paths.geminiSettings);
+  const grokSettings = safeJsonObject(detection.paths.grokHooks);
+  if (client === 'codex') {
+    if (exactHookConfigured(codexSettings, 'UserPromptSubmit', CODEX_CONTEXT_HOOK_COMMAND)) observedHooks.push('prompt');
+    if (exactHookConfigured(codexSettings, 'PreToolUse', CODEX_PRE_ACTION_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER)) observedHooks.push('pre_action');
+    if (exactHookConfigured(codexSettings, 'PostToolUse', CODEX_ACTION_RESULT_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER)) observedHooks.push('action_result');
+    if (exactHookConfigured(codexSettings, 'SessionEnd', CODEX_SESSION_END_HOOK_COMMAND)) observedHooks.push('session_end');
+  } else if (client === 'cursor' || client === 'composer') {
+    if (exactCursorHookConfigured(cursorSettings, 'preToolUse', CURSOR_PRE_ACTION_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS, failClosed: true, async: false,
+    })) observedHooks.push('pre_action');
+    if (exactCursorHookConfigured(cursorSettings, 'postToolUse', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+    }) && exactCursorHookConfigured(cursorSettings, 'postToolUseFailure', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+      timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+    })) observedHooks.push('action_result');
+    if (exactCursorHookConfigured(cursorSettings, 'stop', CURSOR_SESSION_END_HOOK_COMMAND, undefined, {
+      timeout: CODEX_SESSION_TIMEOUT_SECONDS,
+    })) observedHooks.push('outcome_closure');
+  } else if (client === 'cline') {
+    for (const hook of clineHookContract(detection)) {
+      if (exactExecutableFile(hook.path, hook.content)) observedHooks.push(hook.stage);
+    }
+  } else if (client === 'windsurf') {
+    if (WINDSURF_PRE_EVENTS.every((event) => exactWindsurfHookConfigured(
+      windsurfSettings, event, WINDSURF_PRE_ACTION_HOOK_COMMAND,
+    ))) observedHooks.push('pre_action');
+    if (WINDSURF_POST_EVENTS.every((event) => exactWindsurfHookConfigured(
+      windsurfSettings, event, WINDSURF_ACTION_RESULT_HOOK_COMMAND,
+    ))) observedHooks.push('action_result');
+    if (exactWindsurfHookConfigured(
+      windsurfSettings, 'post_cascade_response', WINDSURF_SESSION_END_HOOK_COMMAND,
+    )) observedHooks.push('response_closeout');
+  } else if (client === 'gemini' && !geminiHooksExplicitlyDisabled(geminiSettings)) {
+    if (exactGeminiHookConfigured(
+      geminiSettings, 'BeforeTool', 'marrow-before-tool', GEMINI_PRE_ACTION_HOOK_COMMAND,
+      GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+    )) observedHooks.push('pre_action');
+    if (exactGeminiHookConfigured(
+      geminiSettings, 'AfterTool', 'marrow-after-tool', GEMINI_ACTION_RESULT_HOOK_COMMAND,
+      GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+    )) observedHooks.push('action_result');
+    if (exactGeminiHookConfigured(
+      geminiSettings, 'AfterAgent', 'marrow-after-agent', GEMINI_SESSION_END_HOOK_COMMAND,
+      undefined, GEMINI_CLOSEOUT_TIMEOUT_MS,
+    )) observedHooks.push('turn_closeout');
+  } else if (client === 'grok') {
+    if (exactGrokHookConfigured(
+      grokSettings, 'PreToolUse', GROK_PRE_ACTION_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 7,
+    )) observedHooks.push('pre_action');
+    if (exactGrokHookConfigured(
+      grokSettings, 'PostToolUse', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5,
+    ) && exactGrokHookConfigured(
+      grokSettings, 'PostToolUseFailure', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5,
+    )) observedHooks.push('action_result');
+    if (exactGrokHookConfigured(
+      grokSettings, 'Stop', GROK_SESSION_END_HOOK_COMMAND, undefined, 3,
+    ) && !grokHasDuplicateSessionEnd(grokSettings)) observedHooks.push('turn_closeout');
+  } else {
+    if (capabilityLevel === 'native_hooks'
+      && exactHookConfigured(claudeSettings, 'UserPromptSubmit', MCP_CONTEXT_HOOK_COMMAND)) observedHooks.push('prompt');
+    if (capabilityLevel === 'native_hooks'
+      && exactHookConfigured(claudeSettings, 'PreToolUse', MCP_PRE_ACTION_HOOK_COMMAND, NATIVE_HOOK_MATCHER)) observedHooks.push('pre_action');
+    if (capabilityLevel === 'native_hooks'
+      && exactHookConfigured(claudeSettings, 'PostToolUse', MCP_ACTION_RESULT_HOOK_COMMAND, NATIVE_HOOK_MATCHER)
+      && exactHookConfigured(claudeSettings, 'PostToolUseFailure', MCP_ACTION_RESULT_HOOK_COMMAND, NATIVE_HOOK_MATCHER)) observedHooks.push('action_result');
+    if (capabilityLevel === 'native_hooks'
+      && exactHookConfigured(claudeSettings, 'Stop', MCP_SESSION_END_HOOK_COMMAND)) observedHooks.push('session_end');
+  }
   const passiveRuntime = safeRead(detection.paths.passiveRuntime);
   if (capabilityLevel === 'sdk_passive_runtime'
     && sdkDependency.present
@@ -930,17 +1704,40 @@ function activationProfile(detection, plan, changes, client) {
     .sort()
     .join('|');
   const configFingerprint = capabilityLevel === 'native_hooks'
-    ? claudeNativeHookFingerprint(claudeSettings)
+    ? client === 'codex' ? codexNativeHookFingerprint(codexSettings)
+      : client === 'cursor' || client === 'composer' ? cursorNativeHookFingerprint(cursorSettings)
+      : client === 'cline' ? clineNativeHookFingerprint(detection)
+      : client === 'windsurf' ? windsurfNativeHookFingerprint(windsurfSettings)
+      : client === 'gemini' ? geminiNativeHookFingerprint(geminiSettings)
+      : client === 'grok' ? grokNativeHookFingerprint(grokSettings)
+      : claudeNativeHookFingerprint(claudeSettings)
     : crypto.createHash('sha256')
       .update(`${client}:${capabilityLevel}:${expectedHooks.join(',')}:${fingerprintMaterial}`)
       .digest('hex');
   const complete = expectedHooks.length > 0 && expectedHooks.every((hook) => observedHooks.includes(hook));
+  const clineConflicts = changes
+    .filter((change) => change.hook_conflict)
+    .map((change) => change.label);
   const exactFix = complete
-    ? null
+    ? client === 'cline'
+      ? 'Enable Hooks in Cline, trust the project hook executables and workspace, then restart Cline. TaskComplete remains unverified and is not configured.'
+      : client === 'windsurf'
+      ? 'Restart Windsurf, trust the workspace hook configuration, and leave Restricted Mode before expecting hooks to run. MCP tools remain on demand.'
+      : client === 'gemini'
+      ? 'Restart Gemini CLI, open /hooks panel, and review and approve the project hook fingerprints. MCP tools remain on demand.'
+      : client === 'grok'
+      ? 'Restart Grok, inspect the installed global hooks with /hooks, and confirm they are enabled. Configuration remains client-self-reported and does not verify observed coverage.'
+      : null
     : capabilityLevel === 'sdk_passive_runtime' && !sdkDependency.present
     ? `${sdkDependency.install_command} && npx @getmarrow/install --repair`
     : capabilityLevel === 'governed_wrapper'
     ? `npx @getmarrow/install run --agent <agent-id> -- ${client}`
+    : client === 'cline' && clineConflicts.length > 0
+    ? 'Move or remove the conflicting owner-managed Cline hook file after owner review, then run npx @getmarrow/install --repair. Marrow will never overwrite or compose it.'
+    : client === 'gemini' && geminiHooksExplicitlyDisabled(geminiSettings)
+    ? 'Hooks are explicitly disabled. After owner review, run /hooks enable-all, open /hooks panel, review and approve the project hook fingerprints, then restart Gemini CLI.'
+    : client === 'grok'
+    ? `Run npx -y --package=${MCP_PACKAGE_SPEC} marrow-mcp setup, restart Grok, then inspect /hooks and confirm the global hooks are enabled.`
     : 'npx @getmarrow/install --repair';
   return {
     adapter_version: adapterVersion,
@@ -950,9 +1747,42 @@ function activationProfile(detection, plan, changes, client) {
     observed_hooks: observedHooks,
     evidence_authority: 'client_self_reported',
     coverage_verified: false,
+    passive_live: false,
     configuration_complete: complete,
     complete,
     exact_fix: exactFix,
+    ...(client === 'cline' ? {
+      hook_conflicts: clineConflicts,
+      task_complete_support: 'coming_soon_not_configured',
+      task_completion_closure_verified: false,
+      enable_hooks_required: true,
+      executable_trust_required: true,
+    } : {}),
+    ...(client === 'windsurf' ? {
+      restricted_mode_disables_hooks: true,
+      restart_required: true,
+      workspace_trust_required: true,
+      mcp_tools: 'on_demand',
+    } : {}),
+    ...(client === 'gemini' ? {
+      hooks_enabled: !geminiHooksExplicitlyDisabled(geminiSettings),
+      explicit_disable_preserved: geminiHooksExplicitlyDisabled(geminiSettings),
+      trust_review_required: true,
+      restart_required: true,
+      mcp_tools: 'on_demand',
+      session_end_delivery_claimed: false,
+      deterministic_closeout: 'AfterAgent',
+    } : {}),
+    ...(client === 'grok' ? {
+      hooks_user_toggleable: true,
+      hook_review_required: true,
+      restart_required: true,
+      global_hook_path: detection.paths.grokHooks,
+      mcp_tools: 'on_demand',
+      duplicate_session_end_configured: grokHasDuplicateSessionEnd(grokSettings),
+      deterministic_closeout: 'Stop',
+      governed_wrapper_fallback: 'explicit_bounded_only',
+    } : {}),
   };
 }
 
@@ -964,13 +1794,18 @@ function upsertMcpServerConfig(filePath, options = {}) {
   const servers = config.mcpServers && typeof config.mcpServers === 'object' && !Array.isArray(config.mcpServers)
     ? config.mcpServers
     : {};
+  const existingProfile = resolveToolProfile(servers.marrow?.env?.MARROW_TOOL_PROFILE).configured_profile;
+  const requestedProfile = resolveToolProfile(options.toolProfile).configured_profile;
+  const configuredProfile = requestedProfile === 'unset' ? existingProfile : requestedProfile;
+  const env = {
+    MARROW_BASE_URL: baseUrl,
+    MARROW_FLEET_AGENT_ID: agentId,
+  };
+  if (configuredProfile !== 'unset') env.MARROW_TOOL_PROFILE = configuredProfile;
   servers.marrow = {
     command: 'npx',
     args: ['-y', `--package=${MCP_PACKAGE_SPEC}`, 'marrow-mcp'],
-    env: {
-      MARROW_BASE_URL: baseUrl,
-      MARROW_FLEET_AGENT_ID: agentId,
-    },
+    env,
   };
   config.mcpServers = servers;
   return JSON.stringify(config, null, 2) + '\n';
@@ -1075,7 +1910,74 @@ function defaultHarnessInstallMatrix(detection = detectEnvironment(process.cwd()
     const detected = detectedClient(detection) === entry.client
       || (entry.client === 'claude-code' && detection.claudeCode)
       || (entry.client === 'cursor' && detection.cursor)
+      || (entry.client === 'cline' && detection.cline)
+      || (entry.client === 'windsurf' && detection.windsurf)
+      || (entry.client === 'gemini' && detection.gemini)
+      || (entry.client === 'grok' && detection.grok)
       || (entry.client === 'codex' && detection.codex);
+    const codexSettings = entry.client === 'codex' ? safeJsonObject(detection.paths.codexHooks) : null;
+    const codexConfigured = Boolean(codexSettings
+      && exactHookConfigured(codexSettings, 'UserPromptSubmit', CODEX_CONTEXT_HOOK_COMMAND)
+      && exactHookConfigured(codexSettings, 'PreToolUse', CODEX_PRE_ACTION_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER)
+      && exactHookConfigured(codexSettings, 'PostToolUse', CODEX_ACTION_RESULT_HOOK_COMMAND, CODEX_NATIVE_HOOK_MATCHER)
+      && exactHookConfigured(codexSettings, 'SessionEnd', CODEX_SESSION_END_HOOK_COMMAND));
+    const cursorSettings = ['cursor', 'composer'].includes(entry.client) ? safeJsonObject(detection.paths.cursorHooks) : null;
+    const cursorConfigured = Boolean(cursorSettings
+      && exactCursorHookConfigured(cursorSettings, 'preToolUse', CURSOR_PRE_ACTION_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS, failClosed: true, async: false,
+      })
+      && exactCursorHookConfigured(cursorSettings, 'postToolUse', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+      })
+      && exactCursorHookConfigured(cursorSettings, 'postToolUseFailure', CURSOR_ACTION_RESULT_HOOK_COMMAND, CURSOR_NATIVE_HOOK_MATCHER, {
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS,
+      })
+      && exactCursorHookConfigured(cursorSettings, 'stop', CURSOR_SESSION_END_HOOK_COMMAND, undefined, {
+        timeout: CODEX_SESSION_TIMEOUT_SECONDS,
+      }));
+    const clineConfigured = entry.client === 'cline'
+      && clineHookContract(detection).every((hook) => exactExecutableFile(hook.path, hook.content));
+    const windsurfSettings = entry.client === 'windsurf' ? safeJsonObject(detection.paths.windsurfHooks) : null;
+    const windsurfConfigured = Boolean(windsurfSettings
+      && WINDSURF_PRE_EVENTS.every((event) => exactWindsurfHookConfigured(
+        windsurfSettings, event, WINDSURF_PRE_ACTION_HOOK_COMMAND,
+      ))
+      && WINDSURF_POST_EVENTS.every((event) => exactWindsurfHookConfigured(
+        windsurfSettings, event, WINDSURF_ACTION_RESULT_HOOK_COMMAND,
+      ))
+      && exactWindsurfHookConfigured(
+        windsurfSettings, 'post_cascade_response', WINDSURF_SESSION_END_HOOK_COMMAND,
+      ));
+    const geminiSettings = entry.client === 'gemini' ? safeJsonObject(detection.paths.geminiSettings) : null;
+    const geminiConfigured = Boolean(geminiSettings
+      && !geminiHooksExplicitlyDisabled(geminiSettings)
+      && exactGeminiHookConfigured(
+        geminiSettings, 'BeforeTool', 'marrow-before-tool', GEMINI_PRE_ACTION_HOOK_COMMAND,
+        GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+      )
+      && exactGeminiHookConfigured(
+        geminiSettings, 'AfterTool', 'marrow-after-tool', GEMINI_ACTION_RESULT_HOOK_COMMAND,
+        GEMINI_NATIVE_HOOK_MATCHER, GEMINI_HOOK_TIMEOUT_MS,
+      )
+      && exactGeminiHookConfigured(
+        geminiSettings, 'AfterAgent', 'marrow-after-agent', GEMINI_SESSION_END_HOOK_COMMAND,
+        undefined, GEMINI_CLOSEOUT_TIMEOUT_MS,
+      ));
+    const grokSettings = entry.client === 'grok' ? safeJsonObject(detection.paths.grokHooks) : null;
+    const grokConfigured = Boolean(grokSettings
+      && exactGrokHookConfigured(
+        grokSettings, 'PreToolUse', GROK_PRE_ACTION_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 7,
+      )
+      && exactGrokHookConfigured(
+        grokSettings, 'PostToolUse', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5,
+      )
+      && exactGrokHookConfigured(
+        grokSettings, 'PostToolUseFailure', GROK_ACTION_RESULT_HOOK_COMMAND, GROK_NATIVE_HOOK_MATCHER, 5,
+      )
+      && exactGrokHookConfigured(
+        grokSettings, 'Stop', GROK_SESSION_END_HOOK_COMMAND, undefined, 3,
+      )
+      && !grokHasDuplicateSessionEnd(grokSettings));
     return {
       client: entry.client,
       capability_level: entry.capability_level,
@@ -1085,12 +1987,35 @@ function defaultHarnessInstallMatrix(detection = detectEnvironment(process.cwd()
         mcp: true,
         instructions: true,
         sdk_passive_runtime: node,
-        native_hooks: entry.capability_level === 'native_hooks' && Boolean(detection.claudeCode),
+        native_hooks: entry.capability_level === 'native_hooks' && Boolean(
+          entry.client === 'claude-code' ? detection.claudeCode
+            : entry.client === 'codex' ? detection.codex
+            : ['cursor', 'composer'].includes(entry.client) ? detection.cursor
+            : entry.client === 'cline' ? detection.cline
+            : entry.client === 'windsurf' ? detection.windsurf
+            : entry.client === 'gemini' ? detection.gemini
+            : entry.client === 'grok' ? detection.grok
+            : false,
+        ),
         governed_wrapper: entry.capability_level === 'governed_wrapper',
       },
-      configured_locally: detected && entry.automatic.length > 0,
+      configured_locally: entry.client === 'codex' ? codexConfigured
+        : ['cursor', 'composer'].includes(entry.client) ? cursorConfigured
+        : entry.client === 'cline' ? clineConfigured
+        : entry.client === 'windsurf' ? windsurfConfigured
+        : entry.client === 'gemini' ? geminiConfigured
+        : entry.client === 'grok' ? grokConfigured
+        : detected && entry.automatic.length > 0,
       verified_passive: false,
-      unsupported_claim: entry.capability_level === 'event_contract'
+      unsupported_claim: entry.client === 'cline'
+        ? 'TaskComplete is documented as coming soon and is not configured or counted as observed coverage.'
+        : entry.client === 'windsurf'
+        ? 'Restricted Mode disables hooks; configuration requires restart and trust review and never verifies passive coverage.'
+        : entry.client === 'gemini'
+        ? 'Project hooks require restart and project fingerprint review and approval in /hooks panel; explicit hooksConfig.enabled=false is preserved and SessionEnd delivery is not claimed.'
+        : entry.client === 'grok'
+        ? 'Global hooks are user-toggleable; restart and /hooks inspection are required, configuration remains client-self-reported, and duplicate SessionEnd closeout is forbidden.'
+        : entry.capability_level === 'event_contract'
         ? 'Needs a bounded event adapter. MCP tools remain on demand.'
         : null,
     };
@@ -1131,18 +2056,60 @@ function buildPlan(detection, options) {
         transform: upsertClaudeHooks,
       });
     }
+    if (detection.codex) {
+      writes.push({
+        type: 'json-transform',
+        path: detection.paths.codexHooks,
+        label: 'Codex native hooks',
+        transform: upsertCodexHooks,
+      });
+    }
+    if (detection.cline) {
+      for (const hook of clineHookContract(detection)) {
+        writes.push({
+          type: 'owned-executable',
+          path: hook.path,
+          label: hook.label,
+          content: hook.content,
+          mode: 0o755,
+          conflict_fix: 'Move or remove the existing owner-managed Cline hook after owner review, then run npx @getmarrow/install --repair.',
+        });
+      }
+    }
+    if (detection.windsurf) {
+      writes.push({
+        type: 'json-transform',
+        path: detection.paths.windsurfHooks,
+        label: 'Windsurf native hooks',
+        transform: upsertWindsurfHooks,
+      });
+    }
+    if (detection.gemini) {
+      writes.push({
+        type: 'json-transform',
+        path: detection.paths.geminiSettings,
+        label: 'Gemini CLI native hooks',
+        transform: upsertGeminiHooks,
+      });
+    }
     writes.push({
       type: 'json-transform',
       path: detection.paths.mcpJson,
       label: 'Project MCP server config',
-      transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl }),
+      transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl, toolProfile: options.toolProfile }),
     });
     if (detection.cursor) {
+      writes.push({
+        type: 'json-transform',
+        path: detection.paths.cursorHooks,
+        label: 'Cursor native hooks',
+        transform: upsertCursorHooks,
+      });
       writes.push({
         type: 'json-transform',
         path: detection.paths.cursorMcp,
         label: 'Cursor MCP server config',
-        transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl }),
+        transform: (filePath) => upsertMcpServerConfig(filePath, { agentId, baseUrl, toolProfile: options.toolProfile }),
       });
     }
   }
@@ -1229,8 +2196,10 @@ function applyPlan(plan, options) {
   const root = path.resolve(plan.root || path.dirname(plan.writes[0].path));
   for (const write of plan.writes) assertContainedManagedTarget(root, write.path);
   const prepared = plan.writes.map((write) => {
+    const fileExists = exists(write.path);
     const before = safeRead(write.path);
     let after;
+    let hookConflict = false;
     if (write.type === 'file') {
       if (write.overwrite === false && before) {
         after = before;
@@ -1241,27 +2210,43 @@ function applyPlan(plan, options) {
       after = upsertBlock(before, write.block);
     } else if (write.type === 'json-transform') {
       after = write.transform(write.path);
+    } else if (write.type === 'owned-executable') {
+      if (fileExists && before !== write.content) {
+        after = before;
+        hookConflict = true;
+      } else {
+        after = write.content;
+      }
     } else {
       throw new Error(`Unknown write type: ${write.type}`);
     }
 
-    return { write, before, after };
+    const beforeMode = fileExists ? fs.lstatSync(write.path).mode & 0o777 : null;
+    const modeChanged = !hookConflict && typeof write.mode === 'number' && beforeMode !== write.mode;
+    return { write, before, after, hookConflict, modeChanged };
   });
 
   const changes = [];
-  for (const { write, before, after } of prepared) {
-    const changed = before !== after;
-    const writeApplied = Boolean(options.yes && !options.dryRun && !options.doctor);
+  for (const { write, before, after, hookConflict, modeChanged } of prepared) {
+    const contentChanged = before !== after;
+    const changed = !hookConflict && (contentChanged || modeChanged);
+    const writeApplied = Boolean(options.yes && !options.dryRun && !options.doctor && !hookConflict);
     changes.push({
       path: write.path,
       label: write.label,
       changed,
       applied: changed && writeApplied,
-      already_present: !changed,
+      already_present: !changed && !hookConflict,
+      hook_conflict: hookConflict,
+      ...(hookConflict ? { exact_fix: write.conflict_fix } : {}),
     });
-    if (changed && writeApplied) {
+    if (contentChanged && writeApplied) {
       atomicWriteManagedFile(root, write.path, after);
     }
+    if (modeChanged && writeApplied) {
+      assertContainedManagedTarget(root, write.path);
+      fs.chmodSync(write.path, write.mode);
+    }
   }
   return changes;
 }
@@ -1298,12 +2283,14 @@ function runtimeGateVerified(runtime) {
 }
 
 async function runSelfTest(options) {
-  if (!options.selfTest) return { skipped: true, reason: 'disabled' };
+  const initialProfile = initialToolProfileReport(options.toolProfile);
+  if (!options.selfTest) return { skipped: true, reason: 'disabled', mcp_tool_profile: initialProfile };
   if (!options.apiKey) {
     return {
       skipped: true,
       reason: 'missing MARROW_API_KEY',
       exact_fix: 'export MARROW_API_KEY=mrw_live_... && npx @getmarrow/install --repair',
+      mcp_tool_profile: initialProfile,
     };
   }
 
@@ -1349,6 +2336,14 @@ async function runSelfTest(options) {
   });
 
   const status = await requestJson(`${baseUrl}/v1/agent/status`, { headers });
+  const context = await requestJson(`${baseUrl}/v1/agent/context`, { headers })
+    .catch(() => null);
+  const toolProfile = buildMcpToolProfileReport(
+    options.toolProfile,
+    status.mcp_tool_profile,
+    context?.primary_tool_availability,
+    Boolean(options.activation),
+  );
   const runtime = await requestJson(`${baseUrl}/v1/agent/runtime`, {
     method: 'POST',
     headers,
@@ -1483,6 +2478,7 @@ async function runSelfTest(options) {
   }
   return {
     skipped: false,
+    mcp_tool_profile: toolProfile,
     decision_id: decisionId,
     active: Boolean(status.enabled ?? status.ok),
     health: status.health || null,
@@ -1677,6 +2673,24 @@ function printReport(report) {
   }
 
   process.stdout.write('\nSelf-test:\n');
+  const toolProfile = report.selfTest.mcp_tool_profile || report.toolProfile;
+  if (toolProfile) {
+    process.stdout.write(`- configured tool profile: ${toolProfile.configured_profile}\n`);
+    process.stdout.write(`- effective tool profile: ${toolProfile.effective_profile}\n`);
+    process.stdout.write(`- expected visible tools: ${toolProfile.expected_visible_count == null ? 'complete catalog (awaiting reloaded MCP count)' : toolProfile.expected_visible_count}\n`);
+    process.stdout.write(`- actual visible tools: ${toolProfile.actual_visible_count == null ? 'unavailable until process reload' : toolProfile.actual_visible_count}\n`);
+    process.stdout.write(`- visible tool names: ${toolProfile.visibility_live ? toolProfile.visible_tool_names.join(', ') : 'unavailable until process reload'}\n`);
+    process.stdout.write(`- profile live: ${toolProfile.visibility_live ? 'yes' : 'no'}\n`);
+    const projection = toolProfile.backend_entitlement_projection;
+    const availability = projection?.primary_tool_availability;
+    if (projection?.evidence_state === 'available' && availability?.entitlement_evidence?.state === 'available') {
+      process.stdout.write(`- backend-projected entitled tools: ${availability.counts.entitled}\n`);
+      process.stdout.write(`- backend-projected upgrade-required tools: ${availability.counts.upgrade_required}\n`);
+      process.stdout.write(`- backend projection source: ${projection.source}; authorizes calls: no\n`);
+    } else {
+      process.stdout.write(`- backend-projected entitlements: unavailable (source: ${projection?.source || 'backend_projection_not_provided'}; non-authorizing)\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`);
@@ -1836,9 +2850,15 @@ async function install(options) {
   if (options.activate && options.selfTest === false) {
     throw new Error('activate requires the server self-test');
   }
+  if (options.activate && !String(options.apiKey || '').trim()) {
+    throw new Error('activation requires MARROW_API_KEY from the process environment or trusted secret storage');
+  }
   if (options.repair && options.yes !== true && !options.dryRun && !options.doctor) {
     throw new Error('repair requires explicit write authorization (--yes)');
   }
+  options.toolProfile = resolveToolProfile(options.toolProfile === undefined
+    ? process.env.MARROW_TOOL_PROFILE
+    : options.toolProfile);
   const detection = detectEnvironment(options.cwd);
   const client = detectedClient(detection);
   options.client = client;
@@ -1860,6 +2880,7 @@ async function install(options) {
     configuration_complete: changes.every((change) => change.applied || change.already_present),
     evidence_authority: 'client_self_reported',
     coverage_verified: false,
+    passive_live: false,
     adapter_version: profile.adapter_version,
     capability_level: profile.capability_level,
     config_fingerprint: profile.config_fingerprint,
@@ -1884,20 +2905,38 @@ async function install(options) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (options.activate) throw new Error(`Marrow activation failed: ${message}`);
-    selfTest = { skipped: false, active: false, error: message };
+    selfTest = {
+      skipped: false,
+      active: false,
+      error: message,
+      mcp_tool_profile: initialToolProfileReport(options.toolProfile),
+    };
   }
   if (options.activate && !selfTest.activation_verified) {
     throw new Error('Marrow activation failed: server confirmation was not returned');
   }
+  const harnessReload = harnessReloadPlan(detection, changes);
+  if (harnessReload.required && selfTest.mcp_tool_profile) {
+    selfTest.mcp_tool_profile = {
+      ...selfTest.mcp_tool_profile,
+      visible_tool_count: null,
+      actual_visible_count: null,
+      visible_tool_names: [],
+      visibility_live: false,
+      reload_required: true,
+    };
+  }
   const changedConfig = changes.some((change) => change.applied) || configRepairs.some((repair) => repair.changed);
   const selfTestPassed = Boolean(!selfTest.skipped && selfTest.active && !selfTest.error);
   const controllerPlatform = options.controllerPlatform || process.platform;
+  const localControl = localControlEvidence({ apiKey: options.apiKey, home: options.controlHome });
   let controller = await controllerStatus({
     root: detection.root,
     agentId: options.agentId,
     platform: controllerPlatform,
   });
   const shouldEnsureController = options.controller !== false
+    && localControl.enabled
     && controllerSupportedPlatform(controllerPlatform)
     && Boolean(options.apiKey)
     && selfTestPassed
@@ -1948,11 +2987,13 @@ async function install(options) {
     adapterProvenance: ADAPTER_PROVENANCE,
     mode: plan.mode,
     writeMode,
+    toolProfile: selfTest.mcp_tool_profile || initialToolProfileReport(options.toolProfile),
     detected: {
       node: detection.node,
       python: detection.python,
       claudeCode: detection.claudeCode,
       cursor: detection.cursor,
+      grok: detection.grok,
       codex: detection.codex,
       openclaw: detection.openclaw,
       mcpConfig: detection.mcpConfig,
@@ -1969,7 +3010,7 @@ async function install(options) {
       receipt: selfTest.activation_receipt || null,
       profile,
     },
-    harnessReload: harnessReloadPlan(detection, changes),
+    harnessReload,
     firstCapture: firstCapturePath(detection, options.agentId),
     changes,
     doctor: {
@@ -1991,6 +3032,7 @@ async function install(options) {
     configRepairs,
     sdkDependency,
     controller,
+    local_control: localControl,
     selfTest,
     warnings: [
       ...(options.keyFromArg
@@ -2038,7 +3080,21 @@ module.exports = {
   stableAgentId,
   activationProfile,
   claudeNativeHookFingerprint,
+  codexNativeHookFingerprint,
+  cursorNativeHookFingerprint,
+  clineNativeHookFingerprint,
+  windsurfNativeHookFingerprint,
+  geminiNativeHookFingerprint,
+  grokNativeHookFingerprint,
+  GROK_CONTEXT_HOOK_COMMAND,
+  GROK_PRE_ACTION_HOOK_COMMAND,
+  GROK_ACTION_RESULT_HOOK_COMMAND,
+  GROK_SESSION_END_HOOK_COMMAND,
+  GROK_NATIVE_HOOK_MATCHER,
   printReport,
+  buildMcpToolProfileReport,
+  resolveToolProfile,
+  PRIMARY_TOOL_NAMES,
   ADAPTER_PROVENANCE,
   HARNESS_CAPABILITY_REGISTRY,
   defaultHarnessInstallMatrix,