@skillcap/gdh 0.26.9 → 1.0.0

package/node_modules/@gdh/adapters/dist/index.js

@@ -5,22 +5,22 @@ import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 import { readProjectConfig, readWorktreeState, resolveAuthoringStatus, resolveEffectiveTargetPath, resolvePinnedVersion, resolvePinnedVersionOrNull, resolveProjectRoot, } from "@gdh/authoring";
-import { assertClassRegistered, assertProjectLifecycleCompatibilityInvariant, definePackageBoundary, GDH_AGENT_CONTRACT_VERSION, GDH_CURSOR_RULE_VERSION, GDH_GUIDANCE_INDEX_VERSION, GDH_GUIDANCE_UNIT_VERSION, GDH_PROJECT_CONFIG_VERSION, GDH_RECIPE_SCHEMA_VERSION, GDH_RULES_SCHEMA_VERSION, GDH_SCENARIO_SCHEMA_VERSION, resolveConfiguredGodotEditorBin, resolveCurrentGdhInstall, resolveGdhProductMetadata, } from "@gdh/core";
+import { assertClassRegistered, assertProjectLifecycleCompatibilityInvariant, definePackageBoundary, GDH_AGENT_CONTRACT_VERSION, GDH_GUIDANCE_INDEX_VERSION, GDH_GUIDANCE_UNIT_VERSION, GDH_PROJECT_CONFIG_VERSION, GDH_RECIPE_SCHEMA_VERSION, GDH_RULES_SCHEMA_VERSION, GDH_SCENARIO_SCHEMA_VERSION, resolveConfiguredGodotEditorBin, resolveCurrentGdhInstall, resolveGdhProductMetadata, } from "@gdh/core";
 import { GDH_GUIDANCE_DIRECTORY_RELATIVE_PATH, GUIDANCE_INDEX_RELATIVE_PATH, createDefaultGuidanceUnits, createDefaultRulesDocument, getGuidanceStatus, readRulesDocument, renderRulesYaml, resolveGuidanceQuery, resolveRecoveryHints, } from "@gdh/docs";
 import { inspectGuidanceAudit } from "@gdh/observability";
 import { inspectRuntimeBridgeBroker, inspectRuntimeBridgeSurface, inspectRuntimeKnowledgeSurface, } from "@gdh/runtime";
 import { readInventoryCacheOrScan } from "@gdh/scan";
 import { CLAUDE_SETTINGS_RELATIVE_PATH, patchClaudeSettingsForGdhAuthoringHooks, patchClaudeSettingsForGdhSessionStart, patchClaudeSettingsForGdhStatusline, } from "./claude-settings-patch.js";
 import { computeDeferredActionsAdvisory, } from "./deferred-actions-advisory.js";
-import { CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, CODEX_AUTHORING_HOOK_COMMAND, CODEX_AUTHORING_HOOK_RELATIVE_PATH, renderGdhAuthoringHook, } from "./authoring-hook-render.js";
+import { CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, CODEX_AUTHORING_HOOK_RELATIVE_PATH, renderGdhAuthoringHook, } from "./authoring-hook-render.js";
 import { computeStateRelativePathFromHook } from "./authoring-hook-state-path.js";
+import { removeManagedCodexAuthoringHookBlock, renderManagedCodexAuthoringHookBlock, } from "./codex-authoring-hook-block.js";
 import { CLAUDE_STATUSLINE_RELATIVE_PATH, renderClaudeUpdateStatusline, } from "./claude-statusline-render.js";
 import { CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH, CLAUDE_CHECK_UPDATE_WORKER_RELATIVE_PATH, renderClaudeCheckUpdateHook, } from "./claude-update-hook-render.js";
 import { renderClaudeCheckUpdateWorker } from "./claude-update-worker-render.js";
-import { GDH_MANAGED_AGENT_SKILL_MARKER, renderClaudeMigrateSkill, renderClaudeOnboardSkill, renderClaudePrepareSkill, renderClaudeRunGameSkill, renderClaudeScanSkill, renderClaudeStatusSkill, renderClaudeUpdateSkill, renderCodexMigrateSkill, renderCodexOnboardSkill, renderCodexPrepareSkill, renderCodexRunGameSkill, renderCodexScanSkill, renderCodexStatusSkill, renderCodexUpdateSkill, renderCursorMigrateSkill, renderCursorOnboardSkill, renderCursorPrepareSkill, renderCursorRunGameSkill, renderCursorScanSkill, renderCursorStatusSkill, renderCursorUpdateSkill, } from "./skill-rendering.js";
-export { GDH_MANAGED_AGENT_SKILL_MARKER, GDH_SKILL_DEFINITIONS, GDH_SKILL_IDS, renderGdhSkill, renderManagedSkillMarker, renderClaudeMigrateSkill, renderClaudeOnboardSkill, renderClaudePrepareSkill, renderClaudeRunGameSkill, renderClaudeScanSkill, renderClaudeStatusSkill, renderClaudeUpdateSkill, renderCodexMigrateSkill, renderCodexOnboardSkill, renderCodexPrepareSkill, renderCodexRunGameSkill, renderCodexScanSkill, renderCodexStatusSkill, renderCodexUpdateSkill, renderCursorMigrateSkill, renderCursorOnboardSkill, renderCursorPrepareSkill, renderCursorRunGameSkill, renderCursorScanSkill, renderCursorStatusSkill, renderCursorUpdateSkill, } from "./skill-rendering.js";
+import { GDH_MANAGED_AGENT_SKILL_MARKER, renderClaudeMigrateSkill, renderClaudeOnboardSkill, renderClaudePrepareSkill, renderClaudeRunGameSkill, renderClaudeScanSkill, renderClaudeStatusSkill, renderClaudeUpdateSkill, renderCodexMigrateSkill, renderCodexOnboardSkill, renderCodexPrepareSkill, renderCodexRunGameSkill, renderCodexScanSkill, renderCodexStatusSkill, renderCodexUpdateSkill, } from "./skill-rendering.js";
+export { GDH_MANAGED_AGENT_SKILL_MARKER, GDH_SKILL_DEFINITIONS, GDH_SKILL_IDS, renderGdhSkill, renderManagedSkillMarker, renderClaudeMigrateSkill, renderClaudeOnboardSkill, renderClaudePrepareSkill, renderClaudeRunGameSkill, renderClaudeScanSkill, renderClaudeStatusSkill, renderClaudeUpdateSkill, renderCodexMigrateSkill, renderCodexOnboardSkill, renderCodexPrepareSkill, renderCodexRunGameSkill, renderCodexScanSkill, renderCodexStatusSkill, renderCodexUpdateSkill, } from "./skill-rendering.js";
 // Module-load drift guard. See packages/core/src/migrations/managed-surface-classes.ts.
-assertClassRegistered("cursor_rule", "deterministic");
 assertClassRegistered("claude_onboard_command", "deterministic");
 assertClassRegistered("claude_status_command", "deterministic");
 assertClassRegistered("claude_scan_command", "deterministic");
@@ -48,14 +48,10 @@ export const adaptersPackage = definePackageBoundary({
 export const SUPPORTED_AGENTS = [
     "codex",
     "claude",
-    "cursor",
 ];
 export const CLAUDE_SHIM_RELATIVE_PATH = "CLAUDE.md";
 export const CLAUDE_ONBOARD_SKILL_RELATIVE_PATH = ".claude/skills/gdh-onboard/SKILL.md";
 export const PROJECT_MCP_RELATIVE_PATH = ".mcp.json";
-export const CURSOR_MCP_RELATIVE_PATH = ".cursor/mcp.json";
-export const CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/gdh-agent.mdc";
-export const CURSOR_ONBOARD_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-onboard.md";
 export const CODEX_ONBOARD_SKILL_RELATIVE_PATH = ".agents/skills/gdh-onboard/SKILL.md";
 export const CLAUDE_STATUS_SKILL_RELATIVE_PATH = ".claude/skills/gdh-status/SKILL.md";
 export const CLAUDE_MIGRATE_SKILL_RELATIVE_PATH = ".claude/skills/gdh-migrate/SKILL.md";
@@ -67,10 +63,6 @@ export const CODEX_MIGRATE_SKILL_RELATIVE_PATH = ".agents/skills/gdh-migrate/SKI
 export const CODEX_CHECK_SKILL_RELATIVE_PATH = ".agents/skills/gdh-check/SKILL.md";
 export const CODEX_PREPARE_SKILL_RELATIVE_PATH = ".agents/skills/gdh-prepare/SKILL.md";
 export const CODEX_RUN_GAME_SKILL_RELATIVE_PATH = ".agents/skills/gdh-run-game/SKILL.md";
-export const CURSOR_STATUS_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-status.md";
-export const CURSOR_MIGRATE_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-migrate.md";
-export const CURSOR_PREPARE_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-prepare.md";
-export const CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-run-game.md";
 // Phase 13 SELF-01: /gdh-update skill surface path constants. The rendered
 // bodies shell out to `npx -y @skillcap/gdh@latest self-update` (LITERAL
 // @latest, not the pinned version — D-10) so the NEW CLI performs the update,
@@ -79,7 +71,6 @@ export const CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-run-g
 // rendered bodies are version-agnostic by design.
 export const CLAUDE_UPDATE_SKILL_RELATIVE_PATH = ".claude/skills/gdh-update/SKILL.md";
 export const CODEX_UPDATE_SKILL_RELATIVE_PATH = ".agents/skills/gdh-update/SKILL.md";
-export const CURSOR_UPDATE_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-update.md";
 export const CLAUDE_SCAN_SKILL_RELATIVE_PATH = ".claude/skills/gdh-scan/SKILL.md";
 export const CODEX_SCAN_SKILL_RELATIVE_PATH = ".agents/skills/gdh-scan/SKILL.md";
 export const CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH = CLAUDE_ONBOARD_SKILL_RELATIVE_PATH;
@@ -111,18 +102,6 @@ const LEGACY_CODEX_SKILL_RELATIVE_PATHS = [
     [".codex/skills/gdh-verify/SKILL.md", "gdh-verify"],
     [".codex/skills/gdh-scan/SKILL.md", "gdh-scan"],
 ];
-const LEGACY_CURSOR_SKILL_RELATIVE_PATHS = [
-    [".cursor/skills/gdh-onboard/SKILL.md", "gdh-onboard"],
-    [".cursor/skills/gdh-status/SKILL.md", "gdh-status"],
-    [".cursor/skills/gdh-migrate/SKILL.md", "gdh-migrate"],
-    [".cursor/skills/gdh-update/SKILL.md", "gdh-update"],
-    [".cursor/skills/gdh-check/SKILL.md", "gdh-check"],
-    [".cursor/skills/gdh-prepare/SKILL.md", "gdh-prepare"],
-    [".cursor/skills/gdh-run-game/SKILL.md", "gdh-run-game"],
-    [".cursor/skills/gdh-verify/SKILL.md", "gdh-verify"],
-    [".cursor/skills/gdh-scan/SKILL.md", "gdh-scan"],
-];
-export const CURSOR_SCAN_COMMAND_RELATIVE_PATH = ".cursor/commands/gdh-scan.md";
 const CODEX_SKILL_RELATIVE_PATHS = [
     path.dirname(CODEX_ONBOARD_SKILL_RELATIVE_PATH),
     path.dirname(CODEX_STATUS_SKILL_RELATIVE_PATH),
@@ -132,14 +111,14 @@ const CODEX_SKILL_RELATIVE_PATHS = [
     path.dirname(CODEX_RUN_GAME_SKILL_RELATIVE_PATH),
     path.dirname(CODEX_SCAN_SKILL_RELATIVE_PATH),
 ];
-const CURSOR_COMMAND_RELATIVE_PATHS = [
-    CURSOR_ONBOARD_COMMAND_RELATIVE_PATH,
-    CURSOR_STATUS_COMMAND_RELATIVE_PATH,
-    CURSOR_MIGRATE_COMMAND_RELATIVE_PATH,
-    CURSOR_UPDATE_COMMAND_RELATIVE_PATH,
-    CURSOR_PREPARE_COMMAND_RELATIVE_PATH,
-    CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH,
-    CURSOR_SCAN_COMMAND_RELATIVE_PATH,
+const CLAUDE_SKILL_RELATIVE_PATHS = [
+    path.dirname(CLAUDE_ONBOARD_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_STATUS_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_MIGRATE_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_UPDATE_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_PREPARE_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_RUN_GAME_SKILL_RELATIVE_PATH),
+    path.dirname(CLAUDE_SCAN_SKILL_RELATIVE_PATH),
 ];
 export const LOCAL_PATH_HINTS_RELATIVE_PATH = ".gdh-state/local-paths.json";
 export const CODEX_PROJECT_CONFIG_RELATIVE_PATH = ".codex/config.toml";
@@ -159,17 +138,16 @@ export async function getSupportedAgentAdaptersStatus(targetPath, options = {})
         integrationRootPath: context.integrationRootPath,
         pinnedVersion,
     });
-    const [codex, claude, cursor] = await Promise.all([
+    const [codex, claude] = await Promise.all([
         inspectCodexAdapter(context.targetPath, guidance, projectMcp, pinnedVersion, {
             includeUserLocal,
         }),
         inspectClaudeAdapter(context.targetPath, guidance, projectMcp, pinnedVersion),
-        inspectCursorAdapter(context.targetPath, guidance, projectMcp, pinnedVersion),
     ]);
     return {
         targetPath: context.targetPath,
         guidance,
-        adapters: [codex, claude, cursor],
+        adapters: [codex, claude],
     };
 }
 export async function installSupportedAgentAdapters(targetPath, options = {}) {
@@ -297,7 +275,6 @@ export async function inspectProjectLifecycleCompatibility(targetPath) {
         await inspectGuidanceIndexLifecycleSurface(guidanceStatus.guidanceRootPath, resolvedTargetPath),
         await inspectGuidanceUnitLifecycleSurface(guidanceStatus.guidanceRootPath, projectConfig, resolvedTargetPath),
         inspectMcpManifestLifecycleSurface(resolvedTargetPath, projectConfig.mcp.enabled, adapterStatus),
-        inspectCursorRuleLifecycleSurface(resolvedTargetPath, adapterStatus),
         inspectRuntimeBridgeLifecycleSurface(resolvedTargetPath, bridgeStatus),
     ]);
 }
@@ -408,26 +385,6 @@ function normalizePortableRelativePath(relativePath) {
     const normalized = relativePath.split(path.sep).join("/");
     return normalized === "" ? "." : normalized.replace(/\/+$/, "");
 }
-export function renderCursorRule(input) {
-    const targetPrefix = input?.targetRelativePath
-        ? normalizePortableRelativePath(input.targetRelativePath)
-        : ".";
-    const prefixed = (relativePath) => targetPrefix === "." ? relativePath : `${targetPrefix}/${relativePath}`;
-    return [
-        "---",
-        "description: GDH visibility reinforcement",
-        "alwaysApply: true",
-        "---",
-        `<!-- GDH CURSOR RULE VERSION: ${GDH_CURSOR_RULE_VERSION} -->`,
-        "# GDH Cursor Rule",
-        "",
-        "This GDH-managed Godot target uses GDH.",
-        "Apply this rule only for files inside this Godot target or when the user explicitly asks for GDH work on this target.",
-        `Follow the canonical target-local entrypoint in [AGENTS.md](../../${prefixed("AGENTS.md")}), then load the canonical guidance index at [.gdh/guidance/README.md](../../${prefixed(".gdh/guidance/README.md")}) before substantive Godot work.`,
-        "Do not duplicate or override the canonical GDH guidance chain here.",
-        "",
-    ].join("\n");
-}
 export function renderClaudeOnboardCommand(pinnedVersion) {
     return renderClaudeOnboardSkill(pinnedVersion);
 }
@@ -456,15 +413,11 @@ async function inspectProjectMcpSupport(targetPath, options) {
         pinnedVersion: options.pinnedVersion ?? "latest",
     });
     const nestedTarget = path.resolve(targetPath) !== path.resolve(options.integrationRootPath);
-    const [projectFile, cursorFile, targetProjectFile, targetCursorFile, codexProjectContent, localPathHints,] = await Promise.all([
+    const [projectFile, targetProjectFile, codexProjectContent, localPathHints,] = await Promise.all([
         inspectJsonFile(path.join(options.integrationRootPath, PROJECT_MCP_RELATIVE_PATH)),
-        inspectJsonFile(path.join(options.integrationRootPath, CURSOR_MCP_RELATIVE_PATH)),
         nestedTarget
             ? inspectJsonFile(path.join(targetPath, PROJECT_MCP_RELATIVE_PATH))
             : inspectJsonFile(path.join(options.integrationRootPath, PROJECT_MCP_RELATIVE_PATH)),
-        nestedTarget
-            ? inspectJsonFile(path.join(targetPath, CURSOR_MCP_RELATIVE_PATH))
-            : inspectJsonFile(path.join(options.integrationRootPath, CURSOR_MCP_RELATIVE_PATH)),
         fs
             .readFile(path.join(options.integrationRootPath, CODEX_PROJECT_CONFIG_RELATIVE_PATH), "utf8")
             .catch(() => null),
@@ -477,9 +430,7 @@ async function inspectProjectMcpSupport(targetPath, options) {
         integrationRootPath: options.integrationRootPath,
         localPathHints,
         projectFile: inspectManagedMcpFile(projectFile, enabled, PROJECT_MCP_RELATIVE_PATH, "Claude project MCP config", managedMcpEntry),
-        cursorFile: inspectManagedMcpFile(cursorFile, enabled, CURSOR_MCP_RELATIVE_PATH, "Cursor project MCP config", managedMcpEntry),
         targetProjectFile: inspectManagedMcpFile(targetProjectFile, enabled, PROJECT_MCP_RELATIVE_PATH, "target-local Claude project MCP config", managedMcpEntry),
-        targetCursorFile: inspectManagedMcpFile(targetCursorFile, enabled, CURSOR_MCP_RELATIVE_PATH, "target-local Cursor project MCP config", managedMcpEntry),
         codexProjectFile: inspectManagedCodexProjectFile(codexProjectContent, enabled, options.pinnedVersion),
         codexRegistration: options.includeUserLocal
             ? await inspectCodexRegistration(targetPath, enabled, codexServerName, codexConfigPath, options.integrationRootPath, options.pinnedVersion)
@@ -776,38 +727,6 @@ function inspectClaudeSkillSurface(targetPath, relativePath, content, expectedCo
         }),
     ];
 }
-function inspectCursorCommandSurface(targetPath, relativePath, content, expectedContent, commandName) {
-    if (expectedContent === null) {
-        return [
-            createSurfaceStatus({
-                kind: "command_file",
-                scope: "repo",
-                targetPath,
-                relativePath,
-                present: content !== null,
-                state: "missing",
-                summary: `Cursor ${commandName} command cannot be validated yet: no \`gdh_version\` is pinned (run \`gdh setup\` or \`gdh migrate --apply\`).`,
-                version: null,
-            }),
-        ];
-    }
-    return [
-        createSurfaceStatus({
-            kind: "command_file",
-            scope: "repo",
-            targetPath,
-            relativePath,
-            present: content !== null,
-            state: content === null ? "missing" : content === expectedContent ? "ready" : "misconfigured",
-            summary: content === null
-                ? `Cursor \`/${commandName}\` command is missing and should install under .cursor/commands/.`
-                : content === expectedContent
-                    ? `Cursor can discover the managed \`/${commandName}\` command.`
-                    : `Cursor \`/${commandName}\` command exists but no longer matches the expected managed GDH command.`,
-            version: null,
-        }),
-    ];
-}
 async function inspectCodexAdapter(targetPath, guidance, projectMcp, pinnedVersion, options) {
     const codexSkillPath = path.join(targetPath, CODEX_ONBOARD_SKILL_RELATIVE_PATH);
     const codexSkillContent = await fs.readFile(codexSkillPath, "utf8").catch(() => null);
@@ -1049,6 +968,15 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp, pinnedVers
         inspectManagedHookSurface("claude", targetPath, CLAUDE_STATUSLINE_RELATIVE_PATH, claudeStatuslineContent, expectedClaudeStatusline, "gdh-statusline"),
         inspectManagedHookSurface("claude", targetPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, claudeAuthoringHookContent, expectedClaudeAuthoringHook, "authoring guard"),
     ];
+    if (path.resolve(projectMcp.integrationRootPath) !== path.resolve(targetPath)) {
+        surfaces.push(...(await inspectRootSymlinkSurfaces({
+            agent: "claude",
+            integrationRootPath: projectMcp.integrationRootPath,
+            targetPath,
+            relativePaths: CLAUDE_SKILL_RELATIVE_PATHS,
+            noun: "Claude skill",
+        })));
+    }
     if (projectMcp.enabled) {
         surfaces.push(createSurfaceStatus({
             kind: "mcp_file",
@@ -1077,111 +1005,34 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp, pinnedVers
     }
     return createAgentStatus("claude", guidance, surfaces);
 }
-async function inspectCursorAdapter(targetPath, guidance, projectMcp, pinnedVersion) {
-    const absolutePath = path.join(targetPath, CURSOR_RULE_RELATIVE_PATH);
-    const onboardCommandPath = path.join(targetPath, CURSOR_ONBOARD_COMMAND_RELATIVE_PATH);
-    const content = await fs.readFile(absolutePath, "utf8").catch(() => null);
-    const onboardCommandContent = await fs.readFile(onboardCommandPath, "utf8").catch(() => null);
-    const cursorStatusContent = await fs
-        .readFile(path.join(targetPath, CURSOR_STATUS_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    const cursorMigrateContent = await fs
-        .readFile(path.join(targetPath, CURSOR_MIGRATE_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    // Phase 13 Plan 13-03 deliverable — /gdh-update skill for Cursor. Inspection
-    // wiring required so planSkillInstallAction sees the surface state; otherwise
-    // the planner returns `unchanged` for a missing file and install becomes a
-    // no-op (Plan 13-05 integration-test Rule 2 fix).
-    const cursorUpdateContent = await fs
-        .readFile(path.join(targetPath, CURSOR_UPDATE_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    const cursorPrepareContent = await fs
-        .readFile(path.join(targetPath, CURSOR_PREPARE_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    const cursorRunGameContent = await fs
-        .readFile(path.resolve(targetPath, CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    const cursorScanContent = await fs
-        .readFile(path.join(targetPath, CURSOR_SCAN_COMMAND_RELATIVE_PATH), "utf8")
-        .catch(() => null);
-    const expectedContent = renderCursorRule();
-    const version = readCursorRuleVersion(content);
-    const expectedCursorOnboardSkill = pinnedVersion === null ? null : renderCursorOnboardSkill(pinnedVersion);
-    const expectedCursorStatusSkill = pinnedVersion === null ? null : renderCursorStatusSkill(pinnedVersion);
-    const expectedCursorMigrateSkill = pinnedVersion === null ? null : renderCursorMigrateSkill(pinnedVersion);
-    const expectedCursorUpdateSkill = pinnedVersion === null ? null : renderCursorUpdateSkill(pinnedVersion);
-    const expectedCursorPrepareSkill = pinnedVersion === null ? null : renderCursorPrepareSkill(pinnedVersion);
-    const expectedCursorRunGameSkill = pinnedVersion === null ? null : renderCursorRunGameSkill(pinnedVersion);
-    const expectedCursorScanSkill = pinnedVersion === null ? null : renderCursorScanSkill(pinnedVersion);
-    const surfaces = [
-        createSurfaceStatus({
-            kind: "rule_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_RULE_RELATIVE_PATH,
-            present: content !== null,
-            state: content === null ? "missing" : content === expectedContent ? "ready" : "misconfigured",
-            summary: content === null
-                ? "Cursor reinforcement is missing and should point back to AGENTS.md."
-                : content === expectedContent
-                    ? "Cursor has a thin always-on rule that points back to the canonical GDH guidance chain."
-                    : "Cursor reinforcement exists but no longer matches the expected managed GDH rule.",
-            version,
-        }),
-        createSurfaceStatus({
-            kind: "command_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_ONBOARD_COMMAND_RELATIVE_PATH,
-            present: onboardCommandContent !== null,
-            state: onboardCommandContent === null
-                ? "missing"
-                : expectedCursorOnboardSkill === null
-                    ? "missing"
-                    : onboardCommandContent === expectedCursorOnboardSkill
-                        ? "ready"
-                        : "misconfigured",
-            summary: onboardCommandContent === null
-                ? "Cursor onboarding handoff is missing and should install `/gdh-onboard` under .cursor/commands/."
-                : expectedCursorOnboardSkill === null
-                    ? "Cursor onboarding handoff cannot be validated yet: no `gdh_version` is pinned (run `gdh setup` or `gdh migrate --apply`)."
-                    : onboardCommandContent === expectedCursorOnboardSkill
-                        ? "Cursor can discover the managed `/gdh-onboard` handoff command."
-                        : "Cursor onboarding handoff exists but no longer matches the expected managed GDH command.",
-            version: null,
-        }),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_STATUS_COMMAND_RELATIVE_PATH, cursorStatusContent, expectedCursorStatusSkill, "gdh-status"),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_MIGRATE_COMMAND_RELATIVE_PATH, cursorMigrateContent, expectedCursorMigrateSkill, "gdh-migrate"),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_UPDATE_COMMAND_RELATIVE_PATH, cursorUpdateContent, expectedCursorUpdateSkill, "gdh-update"),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_PREPARE_COMMAND_RELATIVE_PATH, cursorPrepareContent, expectedCursorPrepareSkill, "gdh-prepare"),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH, cursorRunGameContent, expectedCursorRunGameSkill, "gdh-run-game"),
-        ...inspectCursorCommandSurface(targetPath, CURSOR_SCAN_COMMAND_RELATIVE_PATH, cursorScanContent, expectedCursorScanSkill, "gdh-scan"),
-    ];
-    if (projectMcp.enabled) {
-        surfaces.push(createSurfaceStatus({
-            kind: "mcp_file",
+async function inspectRootSymlinkSurfaces(input) {
+    return Promise.all(input.relativePaths.map(async (relativePath) => {
+        const absolutePath = path.join(input.integrationRootPath, relativePath);
+        const rootLinkDirectory = path.dirname(absolutePath);
+        const targetFilePath = path.join(input.targetPath, relativePath);
+        const expectedTarget = normalizePortableRelativePath(path.relative(rootLinkDirectory, targetFilePath));
+        const stat = await fs.lstat(absolutePath).catch(() => null);
+        const detectedTarget = stat?.isSymbolicLink()
+            ? await fs.readlink(absolutePath).catch(() => null)
+            : null;
+        const ready = stat?.isSymbolicLink() === true && detectedTarget === expectedTarget;
+        return createSurfaceStatus({
+            kind: "symlink",
             scope: "repo",
-            targetPath: projectMcp.integrationRootPath,
-            relativePath: CURSOR_MCP_RELATIVE_PATH,
-            present: projectMcp.cursorFile.present,
-            state: projectMcp.cursorFile.state,
-            summary: projectMcp.cursorFile.summary,
+            targetPath: input.integrationRootPath,
+            relativePath,
+            present: stat !== null,
+            state: stat === null ? "missing" : ready ? "ready" : "misconfigured",
+            summary: stat === null
+                ? `Root-launched ${input.noun} ${relativePath} is missing and should point to the target-local managed surface.`
+                : ready
+                    ? `Root-launched ${input.noun} ${relativePath} points to the target-local managed surface.`
+                    : `Root-launched ${input.noun} ${relativePath} does not point to the target-local managed surface.`,
             version: null,
-        }));
-        if (path.resolve(projectMcp.integrationRootPath) !== path.resolve(targetPath)) {
-            surfaces.push(createSurfaceStatus({
-                kind: "mcp_file",
-                scope: "repo",
-                targetPath,
-                relativePath: CURSOR_MCP_RELATIVE_PATH,
-                present: projectMcp.targetCursorFile.present,
-                state: projectMcp.targetCursorFile.state,
-                summary: projectMcp.targetCursorFile.summary,
-                version: null,
-            }));
-        }
-    }
-    return createAgentStatus("cursor", guidance, surfaces);
+            expectedTarget,
+            detectedTarget,
+        });
+    }));
 }
 function createAgentStatus(agent, guidance, surfaces) {
     const state = !hasReadyVisibilityChain(guidance)
@@ -1294,17 +1145,12 @@ async function planInstallActions(targetPath, adapters, requestedAgents, options
         }
         if (adapter.agent === "claude") {
             actions.push(...planClaudeInstallActions(targetPath, adapter, options.pinnedVersion, options.integrationRootPath));
-            continue;
-        }
-        if (adapter.agent === "cursor") {
-            actions.push(...planCursorInstallActions(targetPath, adapter, options.pinnedVersion, options.integrationRootPath));
         }
     }
     actions.push(...planRetiredManagedSurfaceCleanupActions(targetPath));
     if (path.resolve(options.integrationRootPath) !== path.resolve(targetPath)) {
         actions.push(...planRetiredManagedSurfaceCleanupActions(options.integrationRootPath));
         actions.push(...planLegacyCodexSkillCleanupActions(options.integrationRootPath, options.pinnedVersion));
-        actions.push(...planLegacyCursorSkillCleanupActions(options.integrationRootPath));
     }
     return dedupeInstallActions(actions);
 }
@@ -1330,21 +1176,6 @@ function planSharedRepoInstallActions(targetPath, projectMcp, agent, effectiveDe
             content: renderManagedMcpConfig(path.join(integrationRootPath, PROJECT_MCP_RELATIVE_PATH), managedMcpEntry),
         }));
     }
-    if (projectMcp.cursorFile.state !== "ready") {
-        actions.push(createInstallAction({
-            agent,
-            kind: "write_file",
-            scope: "repo",
-            targetPath: integrationRootPath,
-            relativePath: CURSOR_MCP_RELATIVE_PATH,
-            state: "planned",
-            mode: projectMcp.cursorFile.present ? "replace" : "create",
-            summary: projectMcp.cursorFile.present
-                ? "Replace the managed `gdh` MCP entry in .cursor/mcp.json while preserving any non-GDH servers."
-                : "Create .cursor/mcp.json with the managed `gdh` MCP entry.",
-            content: renderManagedMcpConfig(path.join(integrationRootPath, CURSOR_MCP_RELATIVE_PATH), managedMcpEntry),
-        }));
-    }
     if (nestedTarget && projectMcp.targetProjectFile.state !== "ready") {
         actions.push(createInstallAction({
             agent,
@@ -1360,21 +1191,6 @@ function planSharedRepoInstallActions(targetPath, projectMcp, agent, effectiveDe
             content: renderManagedMcpConfig(path.join(targetPath, PROJECT_MCP_RELATIVE_PATH), managedMcpEntry),
         }));
     }
-    if (nestedTarget && projectMcp.targetCursorFile.state !== "ready") {
-        actions.push(createInstallAction({
-            agent,
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_MCP_RELATIVE_PATH,
-            state: "planned",
-            mode: projectMcp.targetCursorFile.present ? "replace" : "create",
-            summary: projectMcp.targetCursorFile.present
-                ? "Replace the managed `gdh` MCP entry in target-local .cursor/mcp.json while preserving any non-GDH servers."
-                : "Create target-local .cursor/mcp.json so Cursor can discover GDH when opened at the Godot target.",
-            content: renderManagedMcpConfig(path.join(targetPath, CURSOR_MCP_RELATIVE_PATH), managedMcpEntry),
-        }));
-    }
     if (projectMcp.localPathHints.gdhDevRepoPath !== effectiveDevRepoPath) {
         actions.push(createInstallAction({
             agent,
@@ -1511,8 +1327,6 @@ function agentLabel(agent) {
             return "Claude";
         case "codex":
             return "Codex";
-        case "cursor":
-            return "Cursor";
     }
 }
 function planCodexRepoInstallActions(targetPath, adapter, pinnedVersion, projectMcp, integrationRootPath) {
@@ -1569,20 +1383,14 @@ function planCodexRepoInstallActions(targetPath, adapter, pinnedVersion, project
 // accepts both so old managed files can migrate without deleting user-authored
 // files based only on path.
 const LEGACY_CODEX_MANAGED_SKILL_MARKER = "<codex_skill_adapter>";
-const LEGACY_CURSOR_MANAGED_SKILL_MARKER = "<cursor_skill_adapter>";
 function isManagedAgentSkillContent(content) {
     return (content.includes(GDH_MANAGED_AGENT_SKILL_MARKER) ||
-        content.includes(LEGACY_CODEX_MANAGED_SKILL_MARKER) ||
-        content.includes(LEGACY_CURSOR_MANAGED_SKILL_MARKER));
+        content.includes(LEGACY_CODEX_MANAGED_SKILL_MARKER));
 }
 function isManagedLegacyCodexSkillContent(content) {
     return (content.includes(GDH_MANAGED_AGENT_SKILL_MARKER) ||
         content.includes(LEGACY_CODEX_MANAGED_SKILL_MARKER));
 }
-function isManagedLegacyCursorSkillContent(content) {
-    return (content.includes(GDH_MANAGED_AGENT_SKILL_MARKER) ||
-        content.includes(LEGACY_CURSOR_MANAGED_SKILL_MARKER));
-}
 function isManagedLegacyClaudeCommandContent(content, skillName) {
     const slashName = skillName.replace("gdh-", "gdh:");
     return (content.includes(`name: ${slashName}`) &&
@@ -1609,13 +1417,6 @@ const RETIRED_MANAGED_SURFACE_RELATIVE_PATHS = [
         isManaged: isManagedAgentSkillContent,
         replacementSummary: "Agents should rely on GDH post-edit hooks, MCP/CLI status, and explicit `gdh authoring check --mode final` evidence instead.",
     },
-    {
-        agent: "cursor",
-        relativePath: ".cursor/skills/gdh-check/SKILL.md",
-        skillName: "gdh-check",
-        isManaged: isManagedAgentSkillContent,
-        replacementSummary: "Agents should rely on MCP/CLI status and explicit `gdh authoring check --mode final` evidence instead.",
-    },
     {
         agent: "claude",
         relativePath: ".claude/skills/gdh-check/SKILL.md",
@@ -1630,13 +1431,6 @@ const RETIRED_MANAGED_SURFACE_RELATIVE_PATHS = [
         isManaged: isManagedAgentSkillContent,
         replacementSummary: "Agents should use `gdh authoring check --mode final` for code-validity evidence.",
     },
-    {
-        agent: "cursor",
-        relativePath: ".cursor/skills/gdh-verify/SKILL.md",
-        skillName: "gdh-verify",
-        isManaged: isManagedAgentSkillContent,
-        replacementSummary: "Agents should use `gdh authoring check --mode final` for code-validity evidence.",
-    },
     {
         agent: "claude",
         relativePath: ".claude/commands/gdh/verify.md",
@@ -1645,6 +1439,59 @@ const RETIRED_MANAGED_SURFACE_RELATIVE_PATHS = [
             (content.includes("@skillcap/gdh@") || content.includes("gdh verify recommend")),
         replacementSummary: "Agents should use `gdh authoring check --mode final` for code-validity evidence.",
     },
+    // Retired cursor agent (commit 7f65b098, "feat(adapters)!: drop cursor
+    // agent from source"). Cursor was a hard delete — no deprecation shim — so
+    // legacy targets that ran a pre-removal GDH still carry GDH-rendered files
+    // under .cursor/. The inventory sweep handles targets with a prior
+    // render-inventory.json; these entries cover the legacy-target case where
+    // no inventory exists yet (pre-Phase 70 onboarding). Content-checked so
+    // user-authored .cursor/ files are never touched. The `agent` field is
+    // attribution-only — cursor is no longer in GdhSupportedAgent — and is set
+    // to "claude" because cursor commands/skills were Claude-style markdown
+    // surfaces. .cursor/mcp.json is intentionally NOT enumerated here: it is a
+    // JSON file that may carry non-GDH MCP servers; deleting it whole would
+    // nuke user content. (The stale `gdh` entry inside it is harmless — the
+    // command it points at is dead — and a JSON-aware partial delete is a
+    // separate concern.)
+    ...([
+        "gdh-onboard",
+        "gdh-status",
+        "gdh-migrate",
+        "gdh-update",
+        "gdh-prepare",
+        "gdh-run-game",
+        "gdh-scan",
+    ].map((skillName) => ({
+        agent: "claude",
+        relativePath: `.cursor/commands/${skillName}.md`,
+        skillName,
+        isManaged: isManagedAgentSkillContent,
+        replacementSummary: "Cursor is no longer a supported GDH adapter target; this file was rendered by a pre-removal GDH version.",
+    }))),
+    ...([
+        "gdh-onboard",
+        "gdh-status",
+        "gdh-migrate",
+        "gdh-update",
+        "gdh-check",
+        "gdh-prepare",
+        "gdh-run-game",
+        "gdh-verify",
+        "gdh-scan",
+    ].map((skillName) => ({
+        agent: "claude",
+        relativePath: `.cursor/skills/${skillName}/SKILL.md`,
+        skillName,
+        isManaged: isManagedAgentSkillContent,
+        replacementSummary: "Cursor is no longer a supported GDH adapter target; this file was rendered by a pre-removal GDH version.",
+    }))),
+    {
+        agent: "claude",
+        relativePath: ".cursor/rules/gdh-agent.mdc",
+        skillName: "gdh-agent-rule",
+        isManaged: (content) => content.includes("GDH CURSOR RULE VERSION:"),
+        replacementSummary: "Cursor is no longer a supported GDH adapter target; this rule file was rendered by a pre-removal GDH version.",
+    },
 ];
 function planRetiredManagedSurfaceCleanupActions(targetPath) {
     const actions = [];
@@ -1667,7 +1514,6 @@ function planRetiredManagedSurfaceCleanupActions(targetPath) {
             summary: `Remove retired managed \`${entry.skillName}\` surface. ${entry.replacementSummary}`,
         }));
     }
-    actions.push(...planLegacyCursorSkillCleanupActions(targetPath));
     return actions;
 }
 function planLegacyCodexSkillCleanupActions(targetPath, _pinnedVersion) {
@@ -1699,29 +1545,6 @@ function planLegacyCodexSkillCleanupActions(targetPath, _pinnedVersion) {
     }
     return actions;
 }
-function planLegacyCursorSkillCleanupActions(targetPath) {
-    const actions = [];
-    for (const [relativePath, skillName] of LEGACY_CURSOR_SKILL_RELATIVE_PATHS) {
-        const absolutePath = path.join(targetPath, relativePath);
-        const content = fsSync.existsSync(absolutePath)
-            ? fsSync.readFileSync(absolutePath, "utf8")
-            : null;
-        if (content === null || !isManagedLegacyCursorSkillContent(content)) {
-            continue;
-        }
-        actions.push(createInstallAction({
-            agent: "cursor",
-            kind: "remove_file",
-            scope: "repo",
-            targetPath,
-            relativePath,
-            state: "planned",
-            mode: "delete",
-            summary: `Remove legacy managed Cursor \`/${skillName}\` skill from .cursor/skills after installing the documented .cursor/commands location.`,
-        }));
-    }
-    return actions;
-}
 function planLegacyClaudeCommandCleanupActions(targetPath) {
     const actions = [];
     for (const [relativePath, skillName] of LEGACY_CLAUDE_SKILL_COMMAND_RELATIVE_PATHS) {
@@ -1870,7 +1693,13 @@ function planClaudeInstallActions(targetPath, adapter, pinnedVersion, integratio
             readySummary: "Root-launched Claude authoring hook already matches the managed target-scoped hook.",
             createSummary: "Create the root-launched Claude authoring hook with target-scoped filtering.",
             replaceSummary: "Replace the root-launched Claude authoring hook with the target-scoped managed hook.",
-        }), planRootClaudeAuthoringSettingsAction(integrationRootPath));
+        }), planRootClaudeAuthoringSettingsAction(integrationRootPath), ...planRootSymlinkActions({
+            agent: "claude",
+            integrationRootPath,
+            targetPath,
+            relativePaths: CLAUDE_SKILL_RELATIVE_PATHS,
+            noun: "Claude skill",
+        }));
     }
     // .claude/settings.json composite patch action.
     //   - Plan 02 (Strategy A, planner-lock #1): patch-merge the SessionStart
@@ -1883,7 +1712,7 @@ function planClaudeInstallActions(targetPath, adapter, pinnedVersion, integratio
     //
     // Synchronous read via fsSync is intentional: planClaudeInstallActions is
     // called without `await`, and making it async would ripple to every sibling
-    // planner (Codex, Cursor). The composed patches are idempotent and
+    // planner (Codex). The composed patches are idempotent and
     // commutative (proven in Task 1 Test J) so application order is irrelevant.
     let existingSettingsContent = "";
     try {
@@ -2006,60 +1835,6 @@ function planRootClaudeAuthoringSettingsAction(integrationRootPath) {
         content: patchedSettings,
     });
 }
-function planCursorInstallActions(targetPath, adapter, pinnedVersion, integrationRootPath) {
-    const actions = [];
-    const cursorRuleSurface = adapter.surfaces.find((surface) => surface.relativePath === CURSOR_RULE_RELATIVE_PATH);
-    const targetRelativePath = path.relative(integrationRootPath, targetPath) || ".";
-    if (!cursorRuleSurface || cursorRuleSurface.state === "ready") {
-        actions.push(createInstallAction({
-            agent: "cursor",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_RULE_RELATIVE_PATH,
-            state: "unchanged",
-            mode: "unchanged",
-            summary: "The managed Cursor reinforcement rule already matches the expected GDH content.",
-            version: GDH_CURSOR_RULE_VERSION,
-            content: renderCursorRule(),
-        }));
-    }
-    else {
-        actions.push(createInstallAction({
-            agent: "cursor",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_RULE_RELATIVE_PATH,
-            state: "planned",
-            mode: cursorRuleSurface.present ? "replace" : "create",
-            summary: cursorRuleSurface.present
-                ? "Replace the existing Cursor reinforcement rule with the managed GDH rule."
-                : "Create the managed Cursor reinforcement rule that points back to AGENTS.md.",
-            version: GDH_CURSOR_RULE_VERSION,
-            content: renderCursorRule(),
-        }));
-    }
-    actions.push(planCommandInstallAction("cursor", targetPath, adapter, CURSOR_ONBOARD_COMMAND_RELATIVE_PATH, renderCursorOnboardSkill, "gdh-onboard", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_STATUS_COMMAND_RELATIVE_PATH, renderCursorStatusSkill, "gdh-status", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_MIGRATE_COMMAND_RELATIVE_PATH, renderCursorMigrateSkill, "gdh-migrate", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_UPDATE_COMMAND_RELATIVE_PATH, renderCursorUpdateSkill, "gdh-update", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_PREPARE_COMMAND_RELATIVE_PATH, renderCursorPrepareSkill, "gdh-prepare", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_RUN_GAME_COMMAND_RELATIVE_PATH, renderCursorRunGameSkill, "gdh-run-game", pinnedVersion), planCommandInstallAction("cursor", targetPath, adapter, CURSOR_SCAN_COMMAND_RELATIVE_PATH, renderCursorScanSkill, "gdh-scan", pinnedVersion));
-    if (path.resolve(integrationRootPath) !== path.resolve(targetPath)) {
-        actions.push(planDirectWriteFileAction({
-            agent: "cursor",
-            targetPath: integrationRootPath,
-            relativePath: CURSOR_RULE_RELATIVE_PATH,
-            content: renderCursorRule({ targetRelativePath }),
-            readySummary: "Root-launched Cursor rule already routes to the managed Godot target.",
-            createSummary: "Create root-launched Cursor rule that routes to the managed Godot target.",
-            replaceSummary: "Replace root-launched Cursor rule with target-aware links to the managed Godot target.",
-        }), ...planRootSymlinkActions({
-            agent: "cursor",
-            integrationRootPath,
-            targetPath,
-            relativePaths: CURSOR_COMMAND_RELATIVE_PATHS,
-            noun: "Cursor command",
-        }));
-    }
-    return actions;
-}
 function dedupeInstallActions(actions) {
     const seen = new Set();
     const deduped = [];
@@ -2111,8 +1886,11 @@ async function applyWriteFileAction(action) {
     if (action.absolutePath === null) {
         throw new Error("Write-file install action is missing an absolute path.");
     }
+    if (action.content === null) {
+        throw new Error("Write-file install action is missing rendered content.");
+    }
     await fs.mkdir(path.dirname(action.absolutePath), { recursive: true });
-    await fs.writeFile(action.absolutePath, action.content ?? renderCursorRule(), "utf8");
+    await fs.writeFile(action.absolutePath, action.content, "utf8");
 }
 async function applyRemoveFileAction(action) {
     if (action.absolutePath === null) {
@@ -2143,16 +1921,6 @@ async function applyLocalHintsAction(action) {
         gdhDevRepoPath: typeof parsed.gdhDevRepoPath === "string" ? parsed.gdhDevRepoPath : null,
     });
 }
-function readCursorRuleVersion(content) {
-    if (content === null) {
-        return null;
-    }
-    const match = content.match(/<!-- GDH CURSOR RULE VERSION: (\d+) -->/);
-    if (!match?.[1]) {
-        return null;
-    }
-    return Number.parseInt(match[1], 10);
-}
 function resolveProjectMcpEnabled(projectConfig) {
     if (projectConfig === null) {
         return false;
@@ -2252,12 +2020,6 @@ function patchManagedCodexProjectSection(content, section) {
     const afterJoin = afterNonEmpty.length > 0 ? `\n\n${afterNonEmpty}` : "\n";
     return `${beforeJoin}${section}${afterJoin}`;
 }
-function removeManagedCodexAuthoringHookBlock(content) {
-    return content
-        .replace(/(?:^|\n)# BEGIN GDH managed authoring hooks\n[\s\S]*?# END GDH managed authoring hooks\n?/, "\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trimEnd();
-}
 function appendManagedCodexAuthoringHookBlock(content) {
     const normalized = content.trimEnd();
     const separator = normalized.length > 0 ? "\n\n" : "";
@@ -2287,30 +2049,6 @@ function ensureCodexHooksFeature(content) {
     }
     return [...lines.slice(0, featuresStart), ...featureLines, ...lines.slice(featuresEnd)].join("\n");
 }
-function renderManagedCodexAuthoringHookBlock() {
-    // Phase 82 / LSP-03. Render PostToolUse and Stop registrations inside one
-    // BEGIN/END envelope, in that order. The empty line between the two blocks is
-    // for human readability. removeManagedCodexAuthoringHookBlock strips the
-    // entire envelope as a single unit, so re-render replaces both blocks
-    // atomically (byte-identical idempotency).
-    return [
-        "# BEGIN GDH managed authoring hooks",
-        "[[hooks.PostToolUse]]",
-        'matcher = "^(apply_patch|Edit|Write)$"',
-        "[[hooks.PostToolUse.hooks]]",
-        'type = "command"',
-        `command = ${JSON.stringify(CODEX_AUTHORING_HOOK_COMMAND)}`,
-        "timeout = 30",
-        "",
-        "[[hooks.Stop]]",
-        "[[hooks.Stop.hooks]]",
-        'type = "command"',
-        `command = ${JSON.stringify(CODEX_AUTHORING_HOOK_COMMAND)}`,
-        "timeout = 60",
-        "# END GDH managed authoring hooks",
-        "",
-    ].join("\n");
-}
 function extractManagedCodexSection(content) {
     const lines = content.split("\n");
     const start = lines.findIndex((line) => /^\[mcp_servers\.gdh\]\s*$/.test(line));
@@ -2942,9 +2680,8 @@ function inspectMcpManifestLifecycleSurface(targetPath, mcpEnabled, adapterStatu
         });
     }
     const claudeMcp = findAdapterSurface(adapterStatus, "claude", "mcp_file");
-    const cursorMcp = findAdapterSurface(adapterStatus, "cursor", "mcp_file");
     const codexMcp = findAdapterSurface(adapterStatus, "codex", "mcp_file");
-    const probes = [claudeMcp, cursorMcp, codexMcp]
+    const probes = [claudeMcp, codexMcp]
         .filter((surface) => surface !== null)
         .map((surface) => createVersionProbe({
         targetPath,
@@ -2953,13 +2690,13 @@ function inspectMcpManifestLifecycleSurface(targetPath, mcpEnabled, adapterStatu
         expectedVersion: null,
         detectedVersion: surface.present ? surface.version : null,
     }));
-    const states = [claudeMcp?.state, cursorMcp?.state, codexMcp?.state].filter((state) => state !== undefined);
+    const states = [claudeMcp?.state, codexMcp?.state].filter((state) => state !== undefined);
     if (states.length > 0 && states.every((state) => state === "ready")) {
         return createLifecycleSurfaceStatus({
             surface: "mcp_manifest",
             management: "managed",
             state: "compatible",
-            summary: "Project MCP config files are aligned for Codex, Claude, and Cursor.",
+            summary: "Project MCP config files are aligned for Codex and Claude.",
             reasons: [],
             probes,
             action: null,
@@ -2984,45 +2721,6 @@ function inspectMcpManifestLifecycleSurface(targetPath, mcpEnabled, adapterStatu
         },
     });
 }
-function inspectCursorRuleLifecycleSurface(targetPath, adapterStatus) {
-    const surface = findAdapterSurface(adapterStatus, "cursor", "rule_file");
-    const probes = surface === null
-        ? []
-        : [
-            createVersionProbe({
-                targetPath,
-                relativePath: surface.relativePath ?? CURSOR_RULE_RELATIVE_PATH,
-                present: surface.present,
-                expectedVersion: GDH_CURSOR_RULE_VERSION,
-                detectedVersion: surface.present ? surface.version : null,
-            }),
-        ];
-    if (surface?.state === "ready") {
-        return createLifecycleSurfaceStatus({
-            surface: "cursor_rule",
-            management: "managed",
-            state: "compatible",
-            summary: "Cursor rule file matches the current GDH-managed surface.",
-            reasons: [],
-            probes,
-            action: null,
-        });
-    }
-    return createLifecycleSurfaceStatus({
-        surface: "cursor_rule",
-        management: "managed",
-        state: surface?.present ? "migration_available" : "migration_needed",
-        summary: "Cursor rule file needs to be created or refreshed through the adapter install flow.",
-        reasons: surface?.present ? ["cursor_rule_misconfigured"] : ["cursor_rule_missing"],
-        probes,
-        action: {
-            kind: "run_repair",
-            summary: "Run GDH migrate or adapters install to refresh the managed Cursor rule file.",
-            command: ["gdh", "adapters", "install", targetPath],
-            autoApplicable: true,
-        },
-    });
-}
 function inspectRuntimeBridgeLifecycleSurface(targetPath, bridgeStatus) {
     const probes = bridgeStatus.managedArtifacts.map((artifact) => createVersionProbe({
         targetPath,
@@ -3563,14 +3261,4 @@ export { DEFAULT_GRACEFUL_STOP_TIMEOUT_MS, STOP_AND_RESTART_ENV_SUBSET_KEYS, bui
 // package should continue to use inspectProjectLifecycleCompatibility, which
 // wraps this function with filesystem probing and surface discovery.
 export { summarizeProjectLifecycleCompatibility };
-/**
- * Phase 82 / LSP-03. Test-only export of internals to support
- * codex-config-render.test.ts (Plan 82-02 Wave 0 RED test scaffold). Do NOT
- * consume this from production code paths; the public renderers/strippers go
- * through appendManagedCodexAuthoringHookBlock and the regular config patcher.
- */
-export const __testing__ = {
-    renderManagedCodexAuthoringHookBlock,
-    removeManagedCodexAuthoringHookBlock,
-};
 //# sourceMappingURL=index.js.map