arkgate 4.5.5 → 4.5.7

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,14 +223,14 @@ 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: hard preToolUse is supported for Write/StrReplace when .cursor/hooks.json is installed + trusted; without runtime-observed hook evidence, hard is unverified. ${mergeBoundary}.`;
   }
   if (host === 'codex') {
-    return `Codex: write path is advisory / best-effort at write (not Claude/Grok hard). ${mergeBoundary}.`;
+    return `Codex: write path is advisory / best-effort at write (not Claude/Grok/Cursor hard). ${mergeBoundary}.`;
   }
   if (host === 'opencode') {
-    return `OpenCode: write path is advisory / best-effort (MCP + optional plugin; not Claude/Grok/Antigravity hard). ${mergeBoundary}.`;
+    return `OpenCode: write path is advisory / best-effort (MCP + optional plugin; not Claude/Grok/Antigravity/Cursor hard). ${mergeBoundary}.`;
   }
   if ((host === 'claude' || host === 'grok' || host === 'antigravity') && !hardWriteActive) {
     const label =

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';
@@ -194,6 +196,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 +521,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 = '';

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'],
@@ -465,11 +470,19 @@ export function planManagedUpgrade(root, options = {}) {
           kind: catalogAsset.kind,
         });
     const accepted = options.acceptConflicts === true;
+    // FX04: --refresh-skills opt-in rewrites customized *skill* assets to package
+    // templates. Conflicted still needs --accept-conflicts. Never silent default.
+    const refreshSkills = options.refreshSkills === true;
+    const skillRefresh =
+      refreshSkills &&
+      catalogAsset.kind === 'skill' &&
+      classified.state === 'customized';
     const canApply =
       classified.state === 'stale' ||
+      skillRefresh ||
       (classified.state === 'missing' && (!recorded || accepted)) ||
       (classified.state === 'conflicted' && accepted);
-    const blocked = classified.requiresConsent && !accepted;
+    const blocked = classified.requiresConsent && !accepted && !skillRefresh;
     const desiredFile = afterFileContent(catalogAsset, currentFile, desiredScoped);
     const asset = {
       path: catalogAsset.relativePath,
@@ -542,6 +555,7 @@ export function planManagedUpgrade(root, options = {}) {
     profile: selection.profile,
     hosts: selection.hosts,
     acceptConflicts: options.acceptConflicts === true,
+    refreshSkills: options.refreshSkills === true,
     assets,
     summary,
     nextManifest,
@@ -552,6 +566,183 @@ export function planManagedUpgrade(root, options = {}) {
   return plan;
 }
 
+/**
+ * FX03 — skill content drift honesty (counts by state + sample paths).
+ * Skills only; never claims "skills upgraded" when only package pin moved.
+ */
+export function buildSkillDriftSummary(plan) {
+  const assets = Array.isArray(plan?.assets) ? plan.assets : [];
+  const skills = assets.filter((a) => a?.kind === 'skill');
+  const byState = {};
+  for (const skill of skills) {
+    const state = typeof skill.state === 'string' ? skill.state : 'unknown';
+    byState[state] = (byState[state] ?? 0) + 1;
+  }
+  const sample = (state, limit = 5) =>
+    skills
+      .filter((s) => s.state === state)
+      .map((s) => s.path)
+      .sort()
+      .slice(0, limit);
+  const customized = byState.customized ?? 0;
+  const stale = byState.stale ?? 0;
+  const missing = byState.missing ?? 0;
+  const current = byState.current ?? 0;
+  const wouldRefresh = skills.filter((s) => s.willApply === true).length;
+  return {
+    schemaVersion: '1.0',
+    notAScore: true,
+    skillCount: skills.length,
+    byState,
+    stale,
+    customized,
+    missing,
+    current,
+    wouldRefresh,
+    samplePaths: {
+      stale: sample('stale'),
+      customized: sample('customized'),
+      missing: sample('missing'),
+    },
+    note:
+      customized > 0 && wouldRefresh === 0
+        ? 'Skills on disk differ from package templates (customized preserved). Use --refresh-skills to opt in to rewrite customized skills; never silent overwrite.'
+        : stale > 0
+          ? 'Some skills are stale vs package templates and will refresh on apply.'
+          : skills.length === 0
+            ? 'No managed skill assets in this upgrade selection.'
+            : 'Skill content matches package templates or is scheduled for write.',
+  };
+}
+
+/**
+ * FX07 — active host vs managed --tools / manifest hosts.
+ */
+export function buildHostSelectionHonesty(plan) {
+  const hosts = Array.isArray(plan?.hosts) ? plan.hosts.map((h) => String(h).toLowerCase()) : [];
+  let active = null;
+  try {
+    active = detectActiveAgentHost();
+  } catch {
+    active = null;
+  }
+  const activeNorm =
+    typeof active === 'string' && active.trim() ? active.trim().toLowerCase() : null;
+  const known = activeNorm && KNOWN_TOOLS.includes(activeNorm);
+  const inSelection = Boolean(activeNorm && hosts.includes(activeNorm));
+  const note =
+    known && !inSelection
+      ? `Detected host "${activeNorm}" is not in managed tools [${hosts.join(', ') || 'none'}]. Re-run with --tools ${[...new Set([...hosts, activeNorm])].sort().join(',')} so that host's skills/hooks are in the plan.`
+      : known && inSelection
+        ? `Detected host "${activeNorm}" is in the managed selection.`
+        : activeNorm
+          ? `Detected host "${activeNorm}" is outside the known managed tool set.`
+          : 'No active agent host detected for this process.';
+  return {
+    schemaVersion: '1.0',
+    notAScore: true,
+    activeHost: activeNorm,
+    managedHosts: hosts,
+    activeInSelection: inSelection,
+    suggestTools:
+      known && !inSelection
+        ? [...new Set([...hosts, activeNorm])].sort().join(',')
+        : null,
+    note,
+  };
+}
+
+/**
+ * FX05 — post-upgrade verification block (advisory sensors only).
+ */
+export function buildPostUpgradeChecks(root, options = {}) {
+  const resolvedRoot = path.resolve(root);
+  const checks = [];
+  let projectVersion = null;
+  try {
+    const pkgPath = path.join(resolvedRoot, 'node_modules', 'arkgate', 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      projectVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version ?? null;
+    }
+  } catch {
+    projectVersion = null;
+  }
+  const cli = typeof options.cliVersion === 'string' ? options.cliVersion : arkPackageVersion();
+  const pinOk =
+    projectVersion != null && cli != null ? projectVersion === cli : null;
+  checks.push({
+    id: 'package-pin-cli',
+    ok: pinOk,
+    detail:
+      pinOk === true
+        ? `Installed arkgate@${projectVersion} matches CLI ${cli}.`
+        : pinOk === false
+          ? `Installed arkgate@${projectVersion} ≠ CLI ${cli}; re-run install or restart using project-local CLI.`
+          : `Could not compare pin (installed=${projectVersion ?? 'missing'}, cli=${cli ?? 'unknown'}).`,
+  });
+  checks.push({
+    id: 'architecture-verification',
+    ok:
+      options.verification?.mode === 'skipped'
+        ? null
+        : options.verification?.exitCode === 0,
+    detail:
+      options.verification?.mode === 'skipped'
+        ? 'Strict architecture verification was skipped (--no-strict).'
+        : options.verification?.exitCode === 0
+          ? 'Strict-merge architecture verification passed.'
+          : `Architecture verification exit ${options.verification?.exitCode ?? 'unknown'}.`,
+  });
+  checks.push({
+    id: 'package-version-truth',
+    ok: options.dualTruth?.dualTruth === true ? false : options.dualTruth ? true : null,
+    detail:
+      options.dualTruth?.dualTruth === true
+        ? options.dualTruth.note || 'Package pin dual-truth detected.'
+        : options.dualTruth
+          ? 'Package pin truth is consistent for this apply.'
+          : 'Package version truth not evaluated.',
+  });
+  checks.push({
+    id: 'doctor-compass-coach',
+    ok: null,
+    detail:
+      'Run `npx arkgate-check --doctor --json` and confirm doctor.improvementCompass + doctor.deepModuleCoach (notAScore).',
+  });
+  checks.push({
+    id: 'agents-md-projection',
+    ok: null,
+    detail: 'Run `npx arkgate agents-md --check` (or --write) so AGENTS.md matches the package projection.',
+  });
+  checks.push({
+    id: 'status-mode',
+    ok: null,
+    detail: 'Run `npx arkgate status --json` and read honesty mode; incomplete facts never invent green residual.',
+  });
+  return {
+    schemaVersion: '1.0',
+    notAScore: true,
+    neverGateInput: true,
+    checks,
+    mcpNote:
+      'If you used Ark MCP this session: restart/retarget MCP after package bump so process arkgateVersion matches project install; always pass project.expectedRoot + expectedProjectId (WI01). Prefer project-local CLI until identity matched and versions align.',
+  };
+}
+
+export function formatSkillDriftHuman(skillDrift) {
+  if (!skillDrift) return [];
+  const lines = [
+    `Skill drift: ${skillDrift.skillCount} skill(s) — current ${skillDrift.current}, stale ${skillDrift.stale}, customized ${skillDrift.customized}, missing ${skillDrift.missing}, would refresh ${skillDrift.wouldRefresh}.`,
+  ];
+  if (skillDrift.note) lines.push(`  ${skillDrift.note}`);
+  return lines;
+}
+
+export function formatHostSelectionHuman(hostSelection) {
+  if (!hostSelection?.note) return [];
+  return [`Host selection: ${hostSelection.note}`];
+}
+
 function publicPlan(plan, overrides = {}) {
   const assets = plan.assets.map(
     ({ containerBeforeHash: _container, [AFTER_CONTENT]: _content, ...asset }) => asset
@@ -784,6 +975,17 @@ export function renderManagedUpgrade(plan, options = {}) {
   for (const line of formatManagedUpgradeSelfServiceHonesty(honesty)) {
     console.log(line);
   }
+  const skillDrift =
+    options.skillDrift ?? plan.skillDrift ?? buildSkillDriftSummary(plan);
+  for (const line of formatSkillDriftHuman(skillDrift)) {
+    console.log(line);
+  }
+  const hostSelection =
+    options.hostSelection ?? plan.hostSelection ?? buildHostSelectionHonesty(plan);
+  for (const line of formatHostSelectionHuman(hostSelection)) {
+    console.log(line);
+  }
+  // FX08: whatsNew always on preview/apply human path (including nothing-to-apply).
   const whatsNew = plan.whatsNew ?? buildUpgradeWhatsNewSuggestions();
   for (const line of formatUpgradeWhatsNewSuggestions(whatsNew)) {
     console.log(line);

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/rules-inventory.mjs

@@ -136,8 +136,29 @@ export function buildRulesInventory(input) {
             /_(?:OID|OIDS)$/i.test(name) ||
             /^(?:INT2|INT4|INT8|FLOAT4|FLOAT8|NUMERIC|DATE|TIME|TIMESTAMP|TIMESTAMPTZ|JSON|JSONB|UUID)OID$/i.test(name) ||
             /(?:^|_)(?:SCHEMA|PROTOCOL|RESOLVER|FORMAT)_(?:URL|URI|VERSION|ID|IDENTITY)$/i.test(name);
+        /**
+         * FX09 — pure UX copy / error-message string constants crowd inventory pilots.
+         * Downrank (skip) sentence-like strings and message-named identifiers; keep
+         * numeric thresholds and domain status tokens for adopt/contract pilots.
+         */
+        const isUxMessageConstant = (name, rawValue) => {
+            if (/^(?:ERROR|SUCCESS|WARNING|INFO|HINT|HELP|EMPTY|TOAST|SNACK|ALERT|BANNER|DIALOG|MODAL|TOOLTIP|CAPTION|SUBTITLE|HEADLINE|USER|UI|DISPLAY|FEEDBACK)_(?:MSG|MESSAGE|TEXT|COPY|LABEL|TITLE|BODY|DESC|DESCRIPTION|HINT|HELP)?/i.test(name) ||
+                /_(?:MSG|MESSAGE|TEXT|COPY|TOAST|SNACK|ALERT|BANNER|CAPTION|HINT|HELP_TEXT|ERROR_TEXT|EMPTY_TEXT|PLACEHOLDER_TEXT|USER_MESSAGE|FEEDBACK)$/i.test(name)) {
+                return true;
+            }
+            const unquoted = rawValue.replace(/^['"]|['"]$/g, '');
+            // Sentence-like string values (spaces or terminal punctuation) are UX copy,
+            // not behavioral business limits — unless the name is a clear domain status seed.
+            if (/^['"]/.test(rawValue) &&
+                (/\s/.test(unquoted) || /[.!?…]$/.test(unquoted)) &&
+                !/^(?:STATUS|STATE|PHASE|ROLE|TYPE|KIND|ORDER|PAYMENT|CART|INVOICE|POLICY)_[A-Z0-9_]+$/i.test(name)) {
+                return true;
+            }
+            return false;
+        };
         while ((magic = magicRe.exec(content)) !== null) {
             const name = magic[2];
+            const rawValue = magic[3] ?? '';
             // With governed layer evidence, generic Tooling/Kernel constants are not
             // business-rule candidates. Controller-shaped boundaries stay eligible
             // because business policy can leak into them.
@@ -145,6 +166,8 @@ export function buildRulesInventory(input) {
                 continue;
             if (isInfraMagicName(name))
                 continue;
+            if (isUxMessageConstant(name, rawValue))
+                continue;
             // P2-N: skip remaining ALL_CAPS noise only on clear UI chrome (not all of app/).
             if (isUiChrome && !isDomain)
                 continue;

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)],