arkgate 4.5.6 → 4.6.0

package/bin/lib/host-support-matrix.mjs

@@ -70,9 +70,27 @@ export const HOST_SUPPORT_MATRIX = Object.freeze({
     true,
     true
   ),
-  cursor: hostProfile('Cursor', null, null, [], false, false, {
-    operationCoverage: { shell: false, 'pre-commit': false },
-  }),
+  // Cursor: official preToolUse deny / exit 2 is a hard block for matched tools when
+  // `.cursor/hooks.json` is installed + trusted. Claim hard only for Write|StrReplace;
+  // Shell/Tab/human edits still rely on CI. Repair envelope may emit; Write updated_input
+  // reinjection is not guaranteed on Cursor (agent_message + retry is the supported path).
+  cursor: hostProfile(
+    'Cursor',
+    '.cursor/hooks.json',
+    'preToolUse `Write` / `StrReplace`',
+    ['Write', 'StrReplace'],
+    true,
+    false,
+    {
+      repairEnvelopeEmitted: true,
+      operationCoverage: {
+        Write: true,
+        StrReplace: true,
+        shell: false,
+        'pre-commit': false,
+      },
+    }
+  ),
   codex: hostProfile(
     'OpenAI Codex',
     '.codex/hooks.json',
@@ -134,14 +152,15 @@ export function renderHostSupportMatrixMarkdown() {
   const rows = HOST_SUPPORT_HOSTS.map((host) => {
     const profile = HOST_SUPPORT_MATRIX[host];
     const capabilities = profile.capabilities;
-    // Fail-closed honesty: Cursor/Codex/OpenCode never claim hard write; CI is required-status.
-    // hookSurface already includes "PreToolUse …" — do not prefix PreToolUse again.
+    // Fail-closed honesty: Codex/OpenCode never claim hard write; CI is required-status.
+    // Cursor claims hard only for listed preToolUse ops when hooks are installed + trusted.
+    // hookSurface already includes "PreToolUse/preToolUse …" — do not prefix again.
     let local;
     if (capabilities['hard-write']) {
       local = `**Hard** block for listed ops (${profile.hookSurface}) when installed + trusted`;
     } else if (host === 'codex') {
       local =
-        '**Advisory / best-effort** at write (not equivalent to Claude/Grok hard block)';
+        '**Advisory / best-effort** at write (not equivalent to Claude/Grok/Cursor hard block)';
     } else if (host === 'opencode') {
       local =
         '**Advisory / best-effort** at write (MCP + optional plugin; not a hard boundary)';
@@ -169,7 +188,8 @@ ${rows}
 
 **Read the CI column:** for every host, the repository-wide hard guarantee is a **required**
 GitHub **status context** that runs the CLI — not “CI file present,” and not the CLI binary name alone.
-Cursor/Codex/OpenCode never get a fake hard write claim.
+Codex/OpenCode never get a fake hard write claim. Cursor hard write covers only listed
+\`preToolUse\` ops when \`.cursor/hooks.json\` is installed and trusted — Shell/Tab/human edits still rely on CI.
 
 This table describes the supported profile **after its files are installed and the host loads/trusts them**. A hard local boundary covers only the listed hook operations; alternate tools, direct filesystem writes, and human edits still rely on CI. MCP validation is advisory because the agent must call it. The CI check blocks a merge only when the repository makes that status required. Repair **envelopes** may be emitted without reinjection being guaranteed; silent auto-apply never happens. Run \`arkgate-check --doctor\` (or \`ark-check --doctor\`) for the evidence actually detected in the current repository.`;
 }
@@ -203,19 +223,19 @@ export function doctorWritePathHonestyMessage(activeHost, hardWriteActive) {
   // EH07: distinguish CLI command (arkgate-check / ark-check) from the GitHub required status context name.
   const mergeBoundary =
     'Required CI hard merge boundary = a required GitHub status context that runs arkgate-check --strict-merge (alias ark-check --strict-merge)';
-  if (host === 'cursor') {
-    return `Cursor: write path is advisory (MCP/rules; no hard PreToolUse). ${mergeBoundary}.`;
+  if (host === 'cursor' && !hardWriteActive) {
+    return `Cursor: pre-write block is supported for Write/StrReplace when .cursor/hooks.json is installed + trusted; without runtime-observed hook evidence, the block is unverified. ${mergeBoundary}.`;
   }
   if (host === 'codex') {
-    return `Codex: write path is advisory / best-effort at write (not Claude/Grok hard). ${mergeBoundary}.`;
+    return `Codex: edits are warning only (not blocked) at write time. ${mergeBoundary}.`;
   }
   if (host === 'opencode') {
-    return `OpenCode: write path is advisory / best-effort (MCP + optional plugin; not Claude/Grok/Antigravity hard). ${mergeBoundary}.`;
+    return `OpenCode: edits are warning only (not blocked). ${mergeBoundary}.`;
   }
   if ((host === 'claude' || host === 'grok' || host === 'antigravity') && !hardWriteActive) {
     const label =
       host === 'claude' ? 'Claude' : host === 'grok' ? 'Grok' : 'Antigravity';
-    return `${label}: hard PreToolUse is supported for listed ops when installed + trusted; without runtime-observed hook evidence, hard is unverified. ${mergeBoundary}.`;
+    return `${label}: pre-write block is supported for listed ops when installed + trusted; without runtime-observed hook evidence, the block is unverified. ${mergeBoundary}.`;
   }
   return null;
 }

package/bin/lib/html-report-depth.mjs

@@ -24,6 +24,7 @@ import { describePackageVersionDualTruth } from './field-install.mjs';
 import { buildDoctorImprovementCompass } from './improvement-compass-doctor.mjs';
 import { buildDeepModuleCoachAdvisory } from './deep-module-coach.mjs';
 import { computePhysicalCohesion } from './physical-cohesion.mjs';
+import { POST_GREEN_LEDE, operatingModeTitle } from './product-copy.mjs';
 
 function esc(value) {
   return String(value)
@@ -383,13 +384,11 @@ export function renderDesignDepthStrip(depth = {}) {
 
   const mode = String(depth.mode || '').toLowerCase();
   const title = designWeak
-    ? mode === 'enforce'
-      ? 'ENFORCE · design-weak'
-      : `${(mode || 'edges').toUpperCase()} · design-weak`
-    : 'Design smells (edges still open)';
+    ? operatingModeTitle(mode || 'enforce', true)
+    : 'Design smells (imports still open)';
   const lede = designWeak
-    ? 'Contract edges are clean, but lived design residual remains. This does not fail PASS — it blocks “healthy finished” until Shape work lands.'
-    : 'Design smells exist alongside open edge debt. Fix edges first; treat smells as Shape residual after green.';
+    ? POST_GREEN_LEDE
+    : 'Design smells exist alongside open import-rule debt. Fix imports first; treat smells as leftover design work after green.';
 
   const smellItems = smells
     .slice(0, 6)
@@ -411,7 +410,7 @@ export function renderDesignDepthStrip(depth = {}) {
     ? `<div class="pilot-card">
         <h3 style="margin-top:.85rem">Next pilot (one at a time)</h3>
         <p class="dim" style="margin:.15rem 0 .4rem;font-size:.86rem">
-          Judgment only — never mechanical-safe · never multi-pilot batch
+          Judgment only — never auto-applied · never multi-pilot batch
         </p>
         <ul class="senior-list">
           <li><b>Smell</b> · <code>${esc(pilot.smellId || pilot.id || '—')}</code></li>
@@ -489,7 +488,7 @@ export function renderDesignCleanNote(depth = {}) {
   return `<div class="section card design-strip is-clean" id="design-depth">
       <div class="design-head">
         <span class="badge design-ok" title="No deterministic design smells with clean edges">Design depth · OK</span>
-        <span class="dim" style="font-size:.86rem">No design-weak residual detected</span>
+        <span class="dim" style="font-size:.86rem">No leftover design work detected</span>
       </div>
       <p class="dim" style="margin:.45rem 0 0;font-size:.88rem">
         Edges and deterministic design sensors agree. Keep placing new code on the golden path;

package/bin/lib/html-report.mjs

@@ -11,6 +11,7 @@ import {
   resolveOperatingMode,
 } from '../ark-shared.mjs';
 import { collectAdoptionGaps, arkCheckCommand } from './agent-gates.mjs';
+import { LEFTOVER_DESIGN_BADGE } from './product-copy.mjs';
 import { CORE_LAYER_NAMES } from './core-layers.mjs';
 import {
   renderBaselineSignalLegend,
@@ -525,7 +526,7 @@ export function renderHtmlReport({
   const designSmells = Array.isArray(depth.designSmells) ? depth.designSmells : [];
   const designWeakBadge =
     designFitness?.designWeak === true
-      ? ` <span class="badge design" title="Edges can be green while lived design residual remains (Shape). Not a FAIL.">design-weak</span>`
+      ? ` <span class="badge design" title="Import rules can be green while leftover design work remains. Not a FAIL.">${LEFTOVER_DESIGN_BADGE}</span>`
       : '';
   const designStripHtml =
     renderDesignDepthStrip({

package/bin/lib/install-migrate.mjs

@@ -25,9 +25,11 @@ import {
   claudeSettings,
   codexHooks,
   codexProjectConfig,
+  cursorHooks,
   grokHooks,
   grokProjectConfig,
   mergeAntigravityArkHook,
+  mergeCursorArkHook,
   mergeOpencodeArkMcp,
   opencodeProjectConfig,
 } from './hook-templates.mjs';
@@ -78,6 +80,7 @@ import {
   RUNNER_BEFORE_ARK,
 } from './mcp-adoption.mjs';
 import { inspectCodexInstallActivation, printCodexActivationHandoff, reportPartialInstall } from './install-activation.mjs';
+import { installRequestedAgentHomes } from './agent-homes.mjs';
 import {
   hasHardWriteHook,
   validateHardWriteRequest,
@@ -194,6 +197,9 @@ export function buildManagedAssetCatalog({ root, tools, compact = false, skillsO
     );
     if (selectedTools.has('cursor')) {
       add('.cursor/mcp.json', mcpJson(root));
+      // whole-file for managed upgrade/manifest (json-merge is install-time only via
+      // mergeCursorArkHook below — same pattern as Antigravity hooks).
+      add('.cursor/hooks.json', cursorHooks(root));
       if (!compact) add('.cursor/rules/ark.mdc', cursorRule(root));
     }
     if (selectedTools.has('claude')) add('.claude/settings.json', claudeSettings(root));
@@ -516,6 +522,25 @@ export function runInstallAgentGates(args) {
       if (merged === existing) return { relativePath, status: 'skipped' };
       return writeTemplate(root, relativePath, merged, true);
     }
+    if (relativePath === '.cursor/hooks.json') {
+      const fullPath = path.join(root, relativePath);
+      let existing = '';
+      try {
+        existing = fs.readFileSync(fullPath, 'utf8');
+      } catch {
+        // Missing hooks file → write generated Cursor preToolUse gate.
+      }
+      if (!existing) {
+        return writeTemplate(root, relativePath, content, true);
+      }
+      const merged = mergeCursorArkHook(existing, content);
+      if (merged == null) {
+        return { relativePath, status: 'skipped-non-ark' };
+      }
+      if (merged === existing) return { relativePath, status: 'skipped' };
+      // Upsert Ark preToolUse without requiring --force; never wipe sibling hooks.
+      return writeTemplate(root, relativePath, merged, true);
+    }
     if (relativePath === '.agents/hooks.json') {
       const fullPath = path.join(root, relativePath);
       let existing = '';
@@ -623,6 +648,17 @@ export function runInstallAgentGates(args) {
     }
   }
 
+  installRequestedAgentHomes({
+    root,
+    skills,
+    version,
+    force: args.force,
+    claudeHome: args.claudeHome,
+    grokHome: args.grokHome,
+    agentHomes: args.agentHomes,
+    json: args.json,
+  });
+
   // Optional legacy/home fallback. Normal Codex installs use the project-scoped
   // .codex/config.toml above, avoiding cross-project primary binding conflicts.
   //

package/bin/lib/managed-upgrade.mjs

@@ -126,7 +126,12 @@ function hasArkText(root, relativePath) {
 
 const HOST_SIGNALS = {
   claude: ['.claude/settings.json', '.claude/skills/ark-upgrade/SKILL.md'],
-  cursor: ['.cursor/mcp.json', '.cursor/rules/ark.mdc', '.cursor/commands/ark-upgrade.md'],
+  cursor: [
+    '.cursor/mcp.json',
+    '.cursor/hooks.json',
+    '.cursor/rules/ark.mdc',
+    '.cursor/commands/ark-upgrade.md',
+  ],
   codex: ['.codex/hooks.json', '.codex/config.toml', '.agents/skills/ark-upgrade/SKILL.md'],
   grok: ['.grok/config.toml', '.grok/hooks/ark-write-gate.json', '.grok/skills/ark-upgrade/SKILL.md'],
   antigravity: ['.agents/hooks.json', '.agents/skills/ark-upgrade/SKILL.md'],

package/bin/lib/mcp-adoption.mjs

@@ -27,7 +27,12 @@ export const COMMAND_GATE_TEXT_FILES = [
   '.grok/hooks/ark-write-gate.json', '.grok/config.toml', '.codex/config.toml',
   '.agents/hooks.json',
 ];
-export const COMMAND_GATE_JSON_FILES = ['.mcp.json', '.cursor/mcp.json', 'opencode.json'];
+export const COMMAND_GATE_JSON_FILES = [
+  '.mcp.json',
+  '.cursor/mcp.json',
+  '.cursor/hooks.json',
+  'opencode.json',
+];
 // Primary CLI names (product) + one-major aliases. migrate-commands must strip ALL of these
 // before re-emitting a single preferred bin — otherwise a partial rename leaves
 // args: ["ark-mcp", "arkgate-mcp", ...] which breaks stdio MCP hosts.

package/bin/lib/mcp-process-package.mjs

@@ -0,0 +1,95 @@
+/**
+ * FX06 — MCP process package vs project install honesty.
+ *
+ * Pure-ish helpers so unit tests need no MCP server. Production MCP runtime
+ * calls buildProcessPackageHonesty with the process version + project root.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+/**
+ * Resolve installed arkgate version for a project root (shallow node_modules,
+ * then Node module resolution for hoisted monorepos).
+ * @param {string} root
+ * @returns {string|null}
+ */
+export function readProjectInstalledArkgateVersion(root) {
+  const resolvedRoot = path.resolve(root);
+  try {
+    const shallow = path.join(resolvedRoot, 'node_modules', 'arkgate', 'package.json');
+    if (fs.existsSync(shallow)) {
+      const v = JSON.parse(fs.readFileSync(shallow, 'utf8')).version;
+      return typeof v === 'string' && v.trim() ? v.trim() : null;
+    }
+  } catch {
+    /* fall through */
+  }
+  try {
+    const requireFromProject = createRequire(path.join(resolvedRoot, 'package.json'));
+    const pkgJson = requireFromProject.resolve('arkgate/package.json');
+    const v = JSON.parse(fs.readFileSync(pkgJson, 'utf8')).version;
+    return typeof v === 'string' && v.trim() ? v.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {{
+ *   processVersion?: string|null,
+ *   projectInstalledVersion?: string|null,
+ *   root?: string,
+ * }} input
+ * @returns {{
+ *   schemaVersion: '1.0',
+ *   notAScore: true,
+ *   processArkgateVersion: string|null,
+ *   projectInstalledVersion: string|null,
+ *   processPackageMismatch: boolean,
+ *   processStale: boolean,
+ *   nextAction: string,
+ * }}
+ */
+export function buildProcessPackageHonesty(input = {}) {
+  const processVersion =
+    typeof input.processVersion === 'string' && input.processVersion.trim()
+      ? input.processVersion.trim()
+      : null;
+  let projectInstalledVersion =
+    input.projectInstalledVersion !== undefined
+      ? input.projectInstalledVersion
+      : null;
+  if (
+    projectInstalledVersion === null &&
+    input.projectInstalledVersion === undefined &&
+    typeof input.root === 'string' &&
+    input.root
+  ) {
+    projectInstalledVersion = readProjectInstalledArkgateVersion(input.root);
+  }
+  if (typeof projectInstalledVersion === 'string') {
+    projectInstalledVersion = projectInstalledVersion.trim() || null;
+  } else if (projectInstalledVersion !== null) {
+    projectInstalledVersion = null;
+  }
+
+  const mismatch =
+    processVersion != null &&
+    projectInstalledVersion != null &&
+    processVersion !== projectInstalledVersion;
+
+  return {
+    schemaVersion: '1.0',
+    notAScore: true,
+    processArkgateVersion: processVersion,
+    projectInstalledVersion,
+    processPackageMismatch: mismatch,
+    processStale: mismatch,
+    nextAction: mismatch
+      ? 'Restart or retarget the Ark MCP server so process arkgateVersion matches the project install. Prefer project-local CLI (`npx arkgate` / `npx arkgate-check`) until identity is matched and versions align. Multi-checkout users: one expectedRoot per project; never reuse another checkout’s projectId.'
+      : projectInstalledVersion == null
+        ? 'Project has no resolvable node_modules/arkgate; install the package or use CLI from a project that pins arkgate.'
+        : 'Process package version matches project install for this MCP root.',
+  };
+}

package/bin/lib/post-green-path.mjs

@@ -6,6 +6,8 @@
  * Plan B stays never mechanical-safe.
  */
 
+import { POST_GREEN_HUMAN } from './product-copy.mjs';
+
 /** Stable product id for JSON / tests. */
 export const POST_GREEN_PATH_ID = 'clarify-for-ai';
 
@@ -16,8 +18,7 @@ export const POST_GREEN_PRIMARY_SKILL = '/ark-explore';
  * Canonical human / agent next-action string (single door).
  * Chained: explore shape-focus then autopilot only to apply B with user OK.
  */
-export const POST_GREEN_PRIMARY_ACTION =
-  'Shape residual (design-weak): edges are clean, design is not finished. Map with /ark-explore shape-focus → dual-plan B; apply B only via /ark-autopilot with your OK. Empty plan A is not done; pattern bets are never mechanical-safe.';
+export const POST_GREEN_PRIMARY_ACTION = POST_GREEN_HUMAN;
 
 /** Short label for tables / metrics. */
 export const POST_GREEN_PRIMARY_SHORT =

package/bin/lib/product-copy.mjs

@@ -0,0 +1,32 @@
+/**
+ * Human-facing product copy (4.6). JSON field names stay stable; this module
+ * owns labels people read in doctor, HTML, and compact router.
+ *
+ * Brands kept: ArkGate, ArkRules. Dialect (design-weak, hard write, …) maps to
+ * common software words. See docs/product-voice.md.
+ */
+
+/** Status-light leftover-design qualifier (was “design-weak”). */
+export const LEFTOVER_DESIGN_LABEL = 'leftover design work';
+
+/**
+ * Operating-mode title for humans (and doctor JSON `designFitness.label` prefix).
+ * @param {string|null|undefined} mode suggest|adapt|enforce
+ * @param {boolean} leftoverDesign
+ */
+export function operatingModeTitle(mode, leftoverDesign) {
+  const light = String(mode || 'enforce').toUpperCase();
+  return leftoverDesign ? `${light} · ${LEFTOVER_DESIGN_LABEL}` : light;
+}
+
+/** Short HTML/doctor badge text. */
+export const LEFTOVER_DESIGN_BADGE = LEFTOVER_DESIGN_LABEL;
+
+export const POST_GREEN_HUMAN =
+  'Imports check out, but the design is still messy. Map leftover work with /ark-explore shape-focus, then apply one small refactor via /ark-autopilot with your OK. A clean import check is not done; pattern bets are never auto-applied.';
+
+export const POST_GREEN_LEDE =
+  'Import rules are clean, but leftover design work remains. That does not fail the check — it only means “done” is still wrong until you tidy shape.';
+
+export const HARD_WRITE_HUMAN = 'pre-write block';
+export const ADVISORY_WRITE_HUMAN = 'warning only (not blocked)';

package/bin/lib/skill-write.mjs

@@ -16,7 +16,7 @@ export const HOME_SKILL_PENDING_CATALOG = '.arkgate-catalog.pending.json';
 const HOME_SKILL_LOCK = '.arkgate-install.lock';
 const HOME_SKILL_CATALOG_SCHEMA = '1.0';
 const HOME_SKILL_LOCK_STALE_MS = 5 * 60 * 1000;
-const HOME_SKILL_LOCK_ATTEMPTS = 100;
+const HOME_SKILL_LOCK_ATTEMPTS = 200;
 const HOME_SKILL_LOCK_RETRY_MS = 25;
 const UUID_PATTERN =
   /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;

package/bin/lib/start-preview.mjs

@@ -10,6 +10,7 @@ import {
   claudeSettings,
   codexHooks,
   codexProjectConfig,
+  cursorHooks,
   grokHooks,
   grokProjectConfig,
   opencodeProjectConfig,
@@ -30,7 +31,10 @@ const COMPACT_HOST_TEMPLATES = {
     ['.agents/hooks.json', antigravityHooks(root)],
     ['.mcp.json', mcpJson(root)],
   ],
-  cursor: (root) => [['.cursor/mcp.json', mcpJson(root)]],
+  cursor: (root) => [
+    ['.cursor/mcp.json', mcpJson(root)],
+    ['.cursor/hooks.json', cursorHooks(root)],
+  ],
   codex: (root) => [
     ['.codex/hooks.json', codexHooks(root)],
     ['.codex/config.toml', codexProjectConfig(root)],

package/bin/lib/upgrade-whats-new.mjs

@@ -33,6 +33,22 @@ export function buildUpgradeWhatsNewSuggestions() {
     neverGateInput: true,
     title: 'Suggested improvements — try or inspect after this package',
     items: [
+      {
+        id: 'plain-language-doctor',
+        title: 'Doctor in plain language',
+        try: 'npx arkgate-check --doctor',
+        inspect: 'Status light + leftover design work (not a score)',
+        why:
+          'Doctor and the HTML report use common words (import rules, leftover design work, pre-write block). ArkGate and ArkRules stay as product names.',
+      },
+      {
+        id: 'shared-agent-homes',
+        title: 'Shared agent skills (home)',
+        try: 'npx arkgate-check --install-agent-gates --skills-only --agent-homes --force',
+        inspect: 'doctor.agentHomeGaps (Claude/Grok ~/.*/skills when those catalogs exist)',
+        why:
+          'Project skills follow this pin. Shared homes stay on the newest ArkGate on the machine (additive; never downgrade). Orphan 2.x global skills stop coaching the wrong version.',
+      },
       {
         id: 'deep-module-coach',
         title: 'Deep-module coach (hot paths + deepening)',

package/bin/lib/write-path-capabilities.mjs

@@ -216,6 +216,9 @@ function requiredWriteOperations(relativePath) {
   if (relativePath === '.agents/hooks.json' || relativePath.startsWith('.agents/')) {
     return ['write_to_file', 'replace_file_content', 'multi_replace_file_content'];
   }
+  if (relativePath === '.cursor/hooks.json' || relativePath.startsWith('.cursor/hooks')) {
+    return ['Write', 'StrReplace'];
+  }
   return ['Write', 'Edit', 'MultiEdit'];
 }
 
@@ -284,6 +287,51 @@ function collectPreToolUseGroups(parsed) {
   return [];
 }
 
+/**
+ * Cursor hooks.json (version 1): { hooks: { preToolUse: [{ command, matcher, failClosed }] } }
+ * Flat command entries — not Claude's nested `{ hooks: [{ type, command }] }` groups.
+ */
+function cursorHookEvidence(root) {
+  const relativePath = '.cursor/hooks.json';
+  const text = readText(path.join(root, relativePath));
+  let hooks = [];
+  try {
+    const parsed = JSON.parse(text);
+    const entries = Array.isArray(parsed?.hooks?.preToolUse) ? parsed.hooks.preToolUse : [];
+    hooks = entries
+      .filter((entry) => entry && typeof entry === 'object' && (!entry.type || entry.type === 'command'))
+      .map((entry) => ({
+        hook: entry,
+        invocation: commandArkMcpInvocation(entry?.command),
+        operations: matcherOperations(relativePath, entry?.matcher),
+      }))
+      .filter((entry) => entry.invocation);
+  } catch {
+    hooks = [];
+  }
+  const hardHooks = hooks.filter((entry) => entry.invocation.binArgs.includes('--hook'));
+  const required = requiredWriteOperations(relativePath);
+  const hard = required.every((operation) =>
+    hardHooks.some((entry) => entry.operations.includes(operation))
+  );
+  const repair =
+    hard &&
+    required.every((operation) =>
+      hardHooks.some(
+        ({ hook, invocation, operations }) =>
+          operations.includes(operation) &&
+          (invocation.binArgs.includes('--hook-repair') ||
+            /^(?:1|true|yes|on)$/i.test(
+              String(hook.env?.ARK_HOOK_REPAIR ?? invocation.environment.ARK_HOOK_REPAIR ?? '')
+            ))
+      )
+    );
+  return {
+    hard: hard ? [relativePath] : [],
+    repair: repair ? [relativePath] : [],
+  };
+}
+
 function hookEvidence(root, relativePath) {
   const text = readText(path.join(root, relativePath));
   let hooks = [];
@@ -396,6 +444,7 @@ export function detectWritePathInventory(root) {
   const claudeHook = hookEvidence(root, '.claude/settings.json');
   const grokHook = hookEvidence(root, '.grok/hooks/ark-write-gate.json');
   const antigravityHook = hookEvidence(root, '.agents/hooks.json');
+  const cursorHook = cursorHookEvidence(root);
   const hosts = {
     claude: hostRecord(
       claudeHook.hard,
@@ -416,7 +465,19 @@ export function detectWritePathInventory(root) {
       antigravityHook.repair,
       merge
     ),
-    cursor: hostRecord([], mcpEvidence(root, '.cursor/mcp.json'), [], merge),
+    cursor: hostRecord(
+      cursorHook.hard,
+      [
+        ...mcpEvidence(root, '.cursor/mcp.json'),
+        // Shared project MCP is also a valid advisory surface for Cursor sessions.
+        ...mcpEvidence(root, '.mcp.json'),
+      ],
+      // EH07: hooks may emit --hook-repair envelopes, but Cursor Write updated_input
+      // reinjection is not package-guaranteed — keep inventory repair-payload false
+      // (envelope honesty lives on support.repair-envelope-emitted).
+      [],
+      merge
+    ),
     // Codex 0.123+ emits PreToolUse for the native apply_patch handler, but some
     // Code Mode hosts execute deferred nested writes without dispatching that
     // project hook. Keep the installed hook as best-effort protection; do not