@skillcap/gdh 0.2.1 → 0.3.1

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

@@ -33,6 +33,21 @@ export const CURSOR_MCP_RELATIVE_PATH = ".cursor/mcp.json";
 export const CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/gdh-agent.mdc";
 export const CURSOR_ONBOARD_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-onboard/SKILL.md";
 export const CODEX_ONBOARD_SKILL_RELATIVE_PATH = ".codex/skills/gdh-onboard/SKILL.md";
+export const CLAUDE_STATUS_COMMAND_RELATIVE_PATH = ".claude/commands/gdh/status.md";
+export const CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH = ".claude/commands/gdh/migrate.md";
+export const CLAUDE_CHECK_COMMAND_RELATIVE_PATH = ".claude/commands/gdh/check.md";
+export const CLAUDE_PREPARE_COMMAND_RELATIVE_PATH = ".claude/commands/gdh/prepare.md";
+export const CLAUDE_VERIFY_COMMAND_RELATIVE_PATH = ".claude/commands/gdh/verify.md";
+export const CODEX_STATUS_SKILL_RELATIVE_PATH = ".codex/skills/gdh-status/SKILL.md";
+export const CODEX_MIGRATE_SKILL_RELATIVE_PATH = ".codex/skills/gdh-migrate/SKILL.md";
+export const CODEX_CHECK_SKILL_RELATIVE_PATH = ".codex/skills/gdh-check/SKILL.md";
+export const CODEX_PREPARE_SKILL_RELATIVE_PATH = ".codex/skills/gdh-prepare/SKILL.md";
+export const CODEX_VERIFY_SKILL_RELATIVE_PATH = ".codex/skills/gdh-verify/SKILL.md";
+export const CURSOR_STATUS_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-status/SKILL.md";
+export const CURSOR_MIGRATE_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-migrate/SKILL.md";
+export const CURSOR_CHECK_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-check/SKILL.md";
+export const CURSOR_PREPARE_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-prepare/SKILL.md";
+export const CURSOR_VERIFY_SKILL_RELATIVE_PATH = ".cursor/skills/gdh-verify/SKILL.md";
 export const LOCAL_PATH_HINTS_RELATIVE_PATH = ".gdh-state/local-paths.json";
 export const MCP_LAUNCHER_RELATIVE_PATH = ".gdh/bin/gdh-mcp.mjs";
 export const GDH_MCP_SERVER_NAME = "gdh";
@@ -118,7 +133,9 @@ export async function installSupportedAgentAdapters(targetPath, options = {}) {
     };
 }
 export async function inspectProjectLifecycleCompatibility(targetPath) {
-    const resolvedTargetPath = path.resolve(targetPath);
+    const rawTargetPath = path.resolve(targetPath);
+    const projectRoot = await resolveProjectRoot(rawTargetPath);
+    const resolvedTargetPath = projectRoot ?? rawTargetPath;
     const projectConfig = await readProjectConfig(resolvedTargetPath);
     if (projectConfig === null) {
         const blockedSurface = createLifecycleSurfaceStatus({
@@ -397,6 +414,569 @@ export function renderCursorOnboardSkill() {
         "",
     ].join("\n");
 }
+// --- gdh-status skill renders ---
+export function renderClaudeStatusCommand() {
+    return [
+        "---",
+        "name: gdh:status",
+        "description: Check GDH project readiness, surface migration needs, and suggest next step",
+        "allowed-tools:",
+        "  - Read",
+        "  - Grep",
+        "  - Glob",
+        "  - Bash",
+        "---",
+        "<objective>",
+        "Check GDH project readiness, surface migration needs, and suggest the most productive next step.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "1. Run `gdh status` and explain each readiness field.",
+        "2. Check if migration is needed with `gdh migrate`.",
+        "3. Surface any degraded or unavailable capabilities.",
+        "4. Suggest the most productive next step based on current state.",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not start editing code.",
+        "- Prefer structured GDH surfaces over repo guesswork.",
+        "- Keep output short and operational.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCodexStatusSkill() {
+    return [
+        "---",
+        'name: "gdh-status"',
+        'description: "Check GDH project readiness, surface migration needs, and suggest next step"',
+        "metadata:",
+        '  short-description: "Check GDH project readiness, surface migration needs, and suggest next step"',
+        "---",
+        "",
+        "<codex_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-status` or mentions `$gdh-status`.",
+        "- Treat any extra user text as additional status context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- If structured user-input tooling is unavailable, ask concise plain-text questions instead.",
+        "</codex_skill_adapter>",
+        "",
+        "<objective>",
+        "Check GDH project readiness, surface migration needs, and suggest the most productive next step.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh status` and explain each readiness field",
+        "- check if migration is needed with `gdh migrate`",
+        "- surface any degraded or unavailable capabilities",
+        "- suggest the most productive next step based on current state",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not start editing code.",
+        "- Prefer structured GDH surfaces over repo guesswork.",
+        "- Keep output short and operational.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCursorStatusSkill() {
+    return [
+        "---",
+        "name: gdh-status",
+        'description: "Check GDH project readiness, surface migration needs, and suggest next step"',
+        "---",
+        "",
+        "<cursor_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-status` or mentions `gdh-status`.",
+        "- Treat any extra user text as additional status context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- Keep questions conversational and concise.",
+        "</cursor_skill_adapter>",
+        "",
+        "<objective>",
+        "Check GDH project readiness, surface migration needs, and suggest the most productive next step.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh status` and explain each readiness field",
+        "- check if migration is needed with `gdh migrate`",
+        "- surface any degraded or unavailable capabilities",
+        "- suggest the most productive next step based on current state",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not start editing code.",
+        "- Prefer structured GDH surfaces over repo guesswork.",
+        "- Keep output short and operational.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+// --- gdh-migrate skill renders ---
+export function renderClaudeMigrateCommand() {
+    return [
+        "---",
+        "name: gdh:migrate",
+        "description: Preview and apply GDH project migrations",
+        "allowed-tools:",
+        "  - Read",
+        "  - Grep",
+        "  - Glob",
+        "  - Bash",
+        "  - AskUserQuestion",
+        "---",
+        "<objective>",
+        "Preview and apply GDH project migrations safely with explicit user approval.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "1. Run `gdh migrate` to preview pending migrations.",
+        "2. Explain what each migration step will change and why.",
+        "3. Offer to run `gdh migrate --apply` if the user approves.",
+        "4. After apply, run `gdh status` to verify the migration succeeded.",
+        "</process>",
+        "",
+        "<rules>",
+        "- Never apply migrations without explicit user approval.",
+        "- Show the dry-run output first.",
+        "- Keep explanations concise.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCodexMigrateSkill() {
+    return [
+        "---",
+        'name: "gdh-migrate"',
+        'description: "Preview and apply GDH project migrations"',
+        "metadata:",
+        '  short-description: "Preview and apply GDH project migrations"',
+        "---",
+        "",
+        "<codex_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-migrate` or mentions `$gdh-migrate`.",
+        "- Treat any extra user text as additional migration context.",
+        "",
+        "## User questions",
+        "- Always ask before applying migrations.",
+        "- If structured user-input tooling is unavailable, ask concise plain-text questions instead.",
+        "</codex_skill_adapter>",
+        "",
+        "<objective>",
+        "Preview and apply GDH project migrations safely with explicit user approval.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh migrate` to preview pending migrations",
+        "- explain what each migration step will change and why",
+        "- offer to run `gdh migrate --apply` if the user approves",
+        "- after apply, run `gdh status` to verify the migration succeeded",
+        "</process>",
+        "",
+        "<rules>",
+        "- Never apply migrations without explicit user approval.",
+        "- Show the dry-run output first.",
+        "- Keep explanations concise.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCursorMigrateSkill() {
+    return [
+        "---",
+        "name: gdh-migrate",
+        'description: "Preview and apply GDH project migrations"',
+        "---",
+        "",
+        "<cursor_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-migrate` or mentions `gdh-migrate`.",
+        "- Treat any extra user text as additional migration context.",
+        "",
+        "## User questions",
+        "- Always ask before applying migrations.",
+        "- Keep questions conversational and concise.",
+        "</cursor_skill_adapter>",
+        "",
+        "<objective>",
+        "Preview and apply GDH project migrations safely with explicit user approval.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh migrate` to preview pending migrations",
+        "- explain what each migration step will change and why",
+        "- offer to run `gdh migrate --apply` if the user approves",
+        "- after apply, run `gdh status` to verify the migration succeeded",
+        "</process>",
+        "",
+        "<rules>",
+        "- Never apply migrations without explicit user approval.",
+        "- Show the dry-run output first.",
+        "- Keep explanations concise.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+// --- gdh-check skill renders ---
+export function renderClaudeCheckCommand() {
+    return [
+        "---",
+        "name: gdh:check",
+        "description: Run GDH authoring checks and explain diagnostics",
+        "allowed-tools:",
+        "  - Read",
+        "  - Grep",
+        "  - Glob",
+        "  - Bash",
+        "---",
+        "<objective>",
+        "Run GDH authoring checks and explain diagnostics in human-readable terms.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "1. Run `gdh authoring check`.",
+        "2. Explain each diagnostic finding with severity and provenance.",
+        "3. Surface any import-state caveats or editor-side warnings.",
+        "4. If issues found, suggest concrete remediation steps.",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not fix issues automatically unless asked.",
+        "- Explain diagnostics in human-readable terms.",
+        "- Report both hard failures and informational caveats.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCodexCheckSkill() {
+    return [
+        "---",
+        'name: "gdh-check"',
+        'description: "Run GDH authoring checks and explain diagnostics"',
+        "metadata:",
+        '  short-description: "Run GDH authoring checks and explain diagnostics"',
+        "---",
+        "",
+        "<codex_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-check` or mentions `$gdh-check`.",
+        "- Treat any extra user text as additional check context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- If structured user-input tooling is unavailable, ask concise plain-text questions instead.",
+        "</codex_skill_adapter>",
+        "",
+        "<objective>",
+        "Run GDH authoring checks and explain diagnostics in human-readable terms.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh authoring check`",
+        "- explain each diagnostic finding with severity and provenance",
+        "- surface any import-state caveats or editor-side warnings",
+        "- if issues found, suggest concrete remediation steps",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not fix issues automatically unless asked.",
+        "- Explain diagnostics in human-readable terms.",
+        "- Report both hard failures and informational caveats.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCursorCheckSkill() {
+    return [
+        "---",
+        "name: gdh-check",
+        'description: "Run GDH authoring checks and explain diagnostics"',
+        "---",
+        "",
+        "<cursor_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-check` or mentions `gdh-check`.",
+        "- Treat any extra user text as additional check context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- Keep questions conversational and concise.",
+        "</cursor_skill_adapter>",
+        "",
+        "<objective>",
+        "Run GDH authoring checks and explain diagnostics in human-readable terms.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh authoring check`",
+        "- explain each diagnostic finding with severity and provenance",
+        "- surface any import-state caveats or editor-side warnings",
+        "- if issues found, suggest concrete remediation steps",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not fix issues automatically unless asked.",
+        "- Explain diagnostics in human-readable terms.",
+        "- Report both hard failures and informational caveats.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+// --- gdh-prepare skill renders ---
+export function renderClaudePrepareCommand() {
+    return [
+        "---",
+        "name: gdh:prepare",
+        "description: Prepare a Godot target for authoring or runtime work",
+        "allowed-tools:",
+        "  - Read",
+        "  - Grep",
+        "  - Glob",
+        "  - Bash",
+        "  - AskUserQuestion",
+        "---",
+        "<objective>",
+        "Prepare a Godot target for authoring or runtime work using GDH target preparation.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "1. Run `gdh target prepare --dry-run` first to preview planned actions.",
+        "2. Explain what hydration and import refresh will do.",
+        "3. If the user approves, run `gdh target prepare`.",
+        "4. If a `--source-target` is relevant, explain when and why to use it.",
+        "5. Verify preparation succeeded with `gdh status`.",
+        "</process>",
+        "",
+        "<rules>",
+        "- Always show dry-run first.",
+        "- Explain worktree hydration context.",
+        "- Do not skip import refresh without explicit reason.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCodexPrepareSkill() {
+    return [
+        "---",
+        'name: "gdh-prepare"',
+        'description: "Prepare a Godot target for authoring or runtime work"',
+        "metadata:",
+        '  short-description: "Prepare a Godot target for authoring or runtime work"',
+        "---",
+        "",
+        "<codex_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-prepare` or mentions `$gdh-prepare`.",
+        "- Treat any extra user text as additional preparation context.",
+        "",
+        "## User questions",
+        "- Ask before running preparation if the user has not explicitly approved.",
+        "- If structured user-input tooling is unavailable, ask concise plain-text questions instead.",
+        "</codex_skill_adapter>",
+        "",
+        "<objective>",
+        "Prepare a Godot target for authoring or runtime work using GDH target preparation.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh target prepare --dry-run` first to preview planned actions",
+        "- explain what hydration and import refresh will do",
+        "- if the user approves, run `gdh target prepare`",
+        "- if a `--source-target` is relevant, explain when and why to use it",
+        "- verify preparation succeeded with `gdh status`",
+        "</process>",
+        "",
+        "<rules>",
+        "- Always show dry-run first.",
+        "- Explain worktree hydration context.",
+        "- Do not skip import refresh without explicit reason.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCursorPrepareSkill() {
+    return [
+        "---",
+        "name: gdh-prepare",
+        'description: "Prepare a Godot target for authoring or runtime work"',
+        "---",
+        "",
+        "<cursor_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-prepare` or mentions `gdh-prepare`.",
+        "- Treat any extra user text as additional preparation context.",
+        "",
+        "## User questions",
+        "- Ask before running preparation if the user has not explicitly approved.",
+        "- Keep questions conversational and concise.",
+        "</cursor_skill_adapter>",
+        "",
+        "<objective>",
+        "Prepare a Godot target for authoring or runtime work using GDH target preparation.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- run `gdh target prepare --dry-run` first to preview planned actions",
+        "- explain what hydration and import refresh will do",
+        "- if the user approves, run `gdh target prepare`",
+        "- if a `--source-target` is relevant, explain when and why to use it",
+        "- verify preparation succeeded with `gdh status`",
+        "</process>",
+        "",
+        "<rules>",
+        "- Always show dry-run first.",
+        "- Explain worktree hydration context.",
+        "- Do not skip import refresh without explicit reason.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+// --- gdh-verify skill renders ---
+export function renderClaudeVerifyCommand() {
+    return [
+        "---",
+        "name: gdh:verify",
+        "description: Evaluate verification readiness and done-policy for changed files",
+        "allowed-tools:",
+        "  - Read",
+        "  - Grep",
+        "  - Glob",
+        "  - Bash",
+        "---",
+        "<objective>",
+        "Evaluate verification readiness and done-policy for changed files using GDH verification surfaces.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "1. Identify changed files from git diff or user input.",
+        "2. Run `gdh verify recommend` with those files to get recommended validation kinds.",
+        "3. Run `gdh verify done` with performed validations to check done eligibility.",
+        "4. Summarize gaps between recommended and performed validation.",
+        "5. Suggest specific next verification steps.",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not mark work as done if done-policy is not satisfied.",
+        "- Surface all recommended validation kinds.",
+        "- Keep the summary actionable.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCodexVerifySkill() {
+    return [
+        "---",
+        'name: "gdh-verify"',
+        'description: "Evaluate verification readiness and done-policy for changed files"',
+        "metadata:",
+        '  short-description: "Evaluate verification readiness and done-policy for changed files"',
+        "---",
+        "",
+        "<codex_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-verify` or mentions `$gdh-verify`.",
+        "- Treat any extra user text as additional verification context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- If structured user-input tooling is unavailable, ask concise plain-text questions instead.",
+        "</codex_skill_adapter>",
+        "",
+        "<objective>",
+        "Evaluate verification readiness and done-policy for changed files using GDH verification surfaces.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- identify changed files from git diff or user input",
+        "- run `gdh verify recommend` with those files to get recommended validation kinds",
+        "- run `gdh verify done` with performed validations to check done eligibility",
+        "- summarize gaps between recommended and performed validation",
+        "- suggest specific next verification steps",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not mark work as done if done-policy is not satisfied.",
+        "- Surface all recommended validation kinds.",
+        "- Keep the summary actionable.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
+export function renderCursorVerifySkill() {
+    return [
+        "---",
+        "name: gdh-verify",
+        'description: "Evaluate verification readiness and done-policy for changed files"',
+        "---",
+        "",
+        "<cursor_skill_adapter>",
+        "## Invocation",
+        "- This skill is invoked when the user says `/gdh-verify` or mentions `gdh-verify`.",
+        "- Treat any extra user text as additional verification context.",
+        "",
+        "## User questions",
+        "- Ask only narrow follow-up questions when GDH cannot infer the missing fact safely.",
+        "- Keep questions conversational and concise.",
+        "</cursor_skill_adapter>",
+        "",
+        "<objective>",
+        "Evaluate verification readiness and done-policy for changed files using GDH verification surfaces.",
+        "</objective>",
+        "",
+        "<process>",
+        "Follow this order:",
+        "",
+        "- identify changed files from git diff or user input",
+        "- run `gdh verify recommend` with those files to get recommended validation kinds",
+        "- run `gdh verify done` with performed validations to check done eligibility",
+        "- summarize gaps between recommended and performed validation",
+        "- suggest specific next verification steps",
+        "</process>",
+        "",
+        "<rules>",
+        "- Do not mark work as done if done-policy is not satisfied.",
+        "- Surface all recommended validation kinds.",
+        "- Keep the summary actionable.",
+        "</rules>",
+        "",
+    ].join("\n");
+}
 async function inspectProjectMcpSupport(targetPath, options) {
     const projectConfig = await readProjectConfig(targetPath);
     const enabled = resolveProjectMcpEnabled(projectConfig);
@@ -601,9 +1181,80 @@ async function inspectCodexRegistration(targetPath, enabled, codexServerName, co
         summary: `Codex has the expected user-local MCP registration \`${codexServerName}\`.`,
     };
 }
+function inspectCodexSkillSurface(targetPath, relativePath, content, expectedContent, skillName) {
+    return [
+        createSurfaceStatus({
+            kind: "skill_file",
+            scope: "repo",
+            targetPath,
+            relativePath,
+            present: content !== null,
+            state: content === null
+                ? "missing"
+                : content === expectedContent
+                    ? "ready"
+                    : "misconfigured",
+            summary: content === null
+                ? `Codex \`/${skillName}\` skill is missing and should install under .codex/skills/.`
+                : content === expectedContent
+                    ? `Codex can discover the managed \`/${skillName}\` skill.`
+                    : `Codex \`/${skillName}\` skill exists but no longer matches the expected managed GDH skill.`,
+            version: null,
+        }),
+    ];
+}
+function inspectClaudeCommandSurface(targetPath, relativePath, content, expectedContent, commandName) {
+    return [
+        createSurfaceStatus({
+            kind: "command_file",
+            scope: "repo",
+            targetPath,
+            relativePath,
+            present: content !== null,
+            state: content === null
+                ? "missing"
+                : content === expectedContent
+                    ? "ready"
+                    : "misconfigured",
+            summary: content === null
+                ? `Claude \`/${commandName}\` command is missing and should install under .claude/commands/gdh/.`
+                : content === expectedContent
+                    ? `Claude can discover the managed \`/${commandName}\` command.`
+                    : `Claude \`/${commandName}\` command exists but no longer matches the expected managed GDH command.`,
+            version: null,
+        }),
+    ];
+}
+function inspectCursorSkillSurface(targetPath, relativePath, content, expectedContent, skillName) {
+    return [
+        createSurfaceStatus({
+            kind: "skill_file",
+            scope: "repo",
+            targetPath,
+            relativePath,
+            present: content !== null,
+            state: content === null
+                ? "missing"
+                : content === expectedContent
+                    ? "ready"
+                    : "misconfigured",
+            summary: content === null
+                ? `Cursor \`/${skillName}\` skill is missing and should install under .cursor/skills/.`
+                : content === expectedContent
+                    ? `Cursor can discover the managed \`/${skillName}\` skill.`
+                    : `Cursor \`/${skillName}\` skill exists but no longer matches the expected managed GDH skill.`,
+            version: null,
+        }),
+    ];
+}
 async function inspectCodexAdapter(targetPath, guidance, projectMcp, options) {
     const codexSkillPath = path.join(targetPath, CODEX_ONBOARD_SKILL_RELATIVE_PATH);
     const codexSkillContent = await fs.readFile(codexSkillPath, "utf8").catch(() => null);
+    const codexStatusContent = await fs.readFile(path.join(targetPath, CODEX_STATUS_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const codexMigrateContent = await fs.readFile(path.join(targetPath, CODEX_MIGRATE_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const codexCheckContent = await fs.readFile(path.join(targetPath, CODEX_CHECK_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const codexPrepareContent = await fs.readFile(path.join(targetPath, CODEX_PREPARE_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const codexVerifyContent = await fs.readFile(path.join(targetPath, CODEX_VERIFY_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
     const surfaces = [
         createSurfaceStatus({
             kind: "canonical_entrypoint",
@@ -641,6 +1292,11 @@ async function inspectCodexAdapter(targetPath, guidance, projectMcp, options) {
                     : "Codex onboarding handoff exists but no longer matches the expected managed GDH skill.",
             version: null,
         }),
+        ...inspectCodexSkillSurface(targetPath, CODEX_STATUS_SKILL_RELATIVE_PATH, codexStatusContent, renderCodexStatusSkill(), "gdh-status"),
+        ...inspectCodexSkillSurface(targetPath, CODEX_MIGRATE_SKILL_RELATIVE_PATH, codexMigrateContent, renderCodexMigrateSkill(), "gdh-migrate"),
+        ...inspectCodexSkillSurface(targetPath, CODEX_CHECK_SKILL_RELATIVE_PATH, codexCheckContent, renderCodexCheckSkill(), "gdh-check"),
+        ...inspectCodexSkillSurface(targetPath, CODEX_PREPARE_SKILL_RELATIVE_PATH, codexPrepareContent, renderCodexPrepareSkill(), "gdh-prepare"),
+        ...inspectCodexSkillSurface(targetPath, CODEX_VERIFY_SKILL_RELATIVE_PATH, codexVerifyContent, renderCodexVerifySkill(), "gdh-verify"),
     ];
     if (projectMcp.enabled) {
         surfaces.push(createSurfaceStatus({
@@ -674,6 +1330,11 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp) {
     const onboardCommandPath = path.join(targetPath, CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH);
     const lstat = await fs.lstat(absolutePath).catch(() => null);
     const onboardCommandContent = await fs.readFile(onboardCommandPath, "utf8").catch(() => null);
+    const claudeStatusContent = await fs.readFile(path.join(targetPath, CLAUDE_STATUS_COMMAND_RELATIVE_PATH), "utf8").catch(() => null);
+    const claudeMigrateContent = await fs.readFile(path.join(targetPath, CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH), "utf8").catch(() => null);
+    const claudeCheckContent = await fs.readFile(path.join(targetPath, CLAUDE_CHECK_COMMAND_RELATIVE_PATH), "utf8").catch(() => null);
+    const claudePrepareContent = await fs.readFile(path.join(targetPath, CLAUDE_PREPARE_COMMAND_RELATIVE_PATH), "utf8").catch(() => null);
+    const claudeVerifyContent = await fs.readFile(path.join(targetPath, CLAUDE_VERIFY_COMMAND_RELATIVE_PATH), "utf8").catch(() => null);
     let detectedTarget = null;
     if (lstat?.isSymbolicLink()) {
         detectedTarget = await fs.readlink(absolutePath).catch(() => null);
@@ -717,6 +1378,11 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp) {
                     : "Claude onboarding handoff exists but no longer matches the expected managed GDH command.",
             version: null,
         }),
+        ...inspectClaudeCommandSurface(targetPath, CLAUDE_STATUS_COMMAND_RELATIVE_PATH, claudeStatusContent, renderClaudeStatusCommand(), "gdh-status"),
+        ...inspectClaudeCommandSurface(targetPath, CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH, claudeMigrateContent, renderClaudeMigrateCommand(), "gdh-migrate"),
+        ...inspectClaudeCommandSurface(targetPath, CLAUDE_CHECK_COMMAND_RELATIVE_PATH, claudeCheckContent, renderClaudeCheckCommand(), "gdh-check"),
+        ...inspectClaudeCommandSurface(targetPath, CLAUDE_PREPARE_COMMAND_RELATIVE_PATH, claudePrepareContent, renderClaudePrepareCommand(), "gdh-prepare"),
+        ...inspectClaudeCommandSurface(targetPath, CLAUDE_VERIFY_COMMAND_RELATIVE_PATH, claudeVerifyContent, renderClaudeVerifyCommand(), "gdh-verify"),
     ];
     if (projectMcp.enabled) {
         surfaces.push(createSurfaceStatus({
@@ -748,6 +1414,11 @@ async function inspectCursorAdapter(targetPath, guidance, projectMcp) {
     const onboardSkillPath = path.join(targetPath, CURSOR_ONBOARD_SKILL_RELATIVE_PATH);
     const content = await fs.readFile(absolutePath, "utf8").catch(() => null);
     const onboardSkillContent = await fs.readFile(onboardSkillPath, "utf8").catch(() => null);
+    const cursorStatusContent = await fs.readFile(path.join(targetPath, CURSOR_STATUS_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const cursorMigrateContent = await fs.readFile(path.join(targetPath, CURSOR_MIGRATE_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const cursorCheckContent = await fs.readFile(path.join(targetPath, CURSOR_CHECK_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const cursorPrepareContent = await fs.readFile(path.join(targetPath, CURSOR_PREPARE_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
+    const cursorVerifyContent = await fs.readFile(path.join(targetPath, CURSOR_VERIFY_SKILL_RELATIVE_PATH), "utf8").catch(() => null);
     const expectedContent = renderCursorRule();
     const version = readCursorRuleVersion(content);
     const surfaces = [
@@ -787,6 +1458,11 @@ async function inspectCursorAdapter(targetPath, guidance, projectMcp) {
                     : "Cursor onboarding handoff exists but no longer matches the expected managed GDH skill.",
             version: null,
         }),
+        ...inspectCursorSkillSurface(targetPath, CURSOR_STATUS_SKILL_RELATIVE_PATH, cursorStatusContent, renderCursorStatusSkill(), "gdh-status"),
+        ...inspectCursorSkillSurface(targetPath, CURSOR_MIGRATE_SKILL_RELATIVE_PATH, cursorMigrateContent, renderCursorMigrateSkill(), "gdh-migrate"),
+        ...inspectCursorSkillSurface(targetPath, CURSOR_CHECK_SKILL_RELATIVE_PATH, cursorCheckContent, renderCursorCheckSkill(), "gdh-check"),
+        ...inspectCursorSkillSurface(targetPath, CURSOR_PREPARE_SKILL_RELATIVE_PATH, cursorPrepareContent, renderCursorPrepareSkill(), "gdh-prepare"),
+        ...inspectCursorSkillSurface(targetPath, CURSOR_VERIFY_SKILL_RELATIVE_PATH, cursorVerifyContent, renderCursorVerifySkill(), "gdh-verify"),
     ];
     if (projectMcp.enabled) {
         surfaces.push(createSurfaceStatus({
@@ -991,38 +1667,54 @@ function planSharedRepoInstallActions(targetPath, projectMcp, agent, effectiveDe
     }
     return actions;
 }
-function planCodexRepoInstallActions(targetPath, adapter) {
-    const actions = [];
-    const codexSkillSurface = adapter.surfaces.find((surface) => surface.relativePath === CODEX_ONBOARD_SKILL_RELATIVE_PATH);
-    if (!codexSkillSurface || codexSkillSurface.state === "ready") {
-        actions.push(createInstallAction({
-            agent: "codex",
+function planSkillInstallAction(agent, targetPath, adapter, relativePath, renderFn, skillName) {
+    const surface = adapter.surfaces.find((s) => s.relativePath === relativePath);
+    if (!surface || surface.state === "ready") {
+        return createInstallAction({
+            agent,
             kind: "write_file",
             scope: "repo",
             targetPath,
-            relativePath: CODEX_ONBOARD_SKILL_RELATIVE_PATH,
+            relativePath,
             state: "unchanged",
             mode: "unchanged",
-            summary: "The managed Codex `/gdh-onboard` skill already matches the expected GDH content.",
-            content: renderCodexOnboardSkill(),
-        }));
+            summary: `The managed ${agentLabel(agent)} \`/${skillName}\` ${agent === "claude" ? "command" : "skill"} already matches the expected GDH content.`,
+            content: renderFn(),
+        });
     }
-    else {
-        actions.push(createInstallAction({
-            agent: "codex",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CODEX_ONBOARD_SKILL_RELATIVE_PATH,
-            state: "planned",
-            mode: codexSkillSurface.present ? "replace" : "create",
-            summary: codexSkillSurface.present
-                ? "Replace the existing Codex `/gdh-onboard` skill with the managed GDH skill."
-                : "Create the managed Codex `/gdh-onboard` skill.",
-            content: renderCodexOnboardSkill(),
-        }));
+    return createInstallAction({
+        agent,
+        kind: "write_file",
+        scope: "repo",
+        targetPath,
+        relativePath,
+        state: "planned",
+        mode: surface.present ? "replace" : "create",
+        summary: surface.present
+            ? `Replace the existing ${agentLabel(agent)} \`/${skillName}\` ${agent === "claude" ? "command" : "skill"} with the managed GDH ${agent === "claude" ? "command" : "skill"}.`
+            : `Create the managed ${agentLabel(agent)} \`/${skillName}\` ${agent === "claude" ? "command" : "skill"}.`,
+        content: renderFn(),
+    });
+}
+function agentLabel(agent) {
+    switch (agent) {
+        case "claude":
+            return "Claude";
+        case "codex":
+            return "Codex";
+        case "cursor":
+            return "Cursor";
     }
-    return actions;
+}
+function planCodexRepoInstallActions(targetPath, adapter) {
+    return [
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_ONBOARD_SKILL_RELATIVE_PATH, renderCodexOnboardSkill, "gdh-onboard"),
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_STATUS_SKILL_RELATIVE_PATH, renderCodexStatusSkill, "gdh-status"),
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_MIGRATE_SKILL_RELATIVE_PATH, renderCodexMigrateSkill, "gdh-migrate"),
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_CHECK_SKILL_RELATIVE_PATH, renderCodexCheckSkill, "gdh-check"),
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_PREPARE_SKILL_RELATIVE_PATH, renderCodexPrepareSkill, "gdh-prepare"),
+        planSkillInstallAction("codex", targetPath, adapter, CODEX_VERIFY_SKILL_RELATIVE_PATH, renderCodexVerifySkill, "gdh-verify"),
+    ];
 }
 function planCodexUserInstallActions(targetPath, projectMcp, integrationRootPath) {
     if (!projectMcp.enabled || projectMcp.codexServerName === null) {
@@ -1103,35 +1795,7 @@ function planClaudeInstallActions(targetPath, adapter) {
             expectedTarget: "AGENTS.md",
         }));
     }
-    const claudeCommandSurface = adapter.surfaces.find((surface) => surface.relativePath === CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH);
-    if (!claudeCommandSurface || claudeCommandSurface.state === "ready") {
-        actions.push(createInstallAction({
-            agent: "claude",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH,
-            state: "unchanged",
-            mode: "unchanged",
-            summary: "The managed Claude `/gdh-onboard` command already matches the expected GDH content.",
-            content: renderClaudeOnboardCommand(),
-        }));
-    }
-    else {
-        actions.push(createInstallAction({
-            agent: "claude",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH,
-            state: "planned",
-            mode: claudeCommandSurface.present ? "replace" : "create",
-            summary: claudeCommandSurface.present
-                ? "Replace the existing Claude `/gdh-onboard` command with the managed GDH command."
-                : "Create the managed Claude `/gdh-onboard` command.",
-            content: renderClaudeOnboardCommand(),
-        }));
-    }
+    actions.push(planSkillInstallAction("claude", targetPath, adapter, CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH, renderClaudeOnboardCommand, "gdh-onboard"), planSkillInstallAction("claude", targetPath, adapter, CLAUDE_STATUS_COMMAND_RELATIVE_PATH, renderClaudeStatusCommand, "gdh-status"), planSkillInstallAction("claude", targetPath, adapter, CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH, renderClaudeMigrateCommand, "gdh-migrate"), planSkillInstallAction("claude", targetPath, adapter, CLAUDE_CHECK_COMMAND_RELATIVE_PATH, renderClaudeCheckCommand, "gdh-check"), planSkillInstallAction("claude", targetPath, adapter, CLAUDE_PREPARE_COMMAND_RELATIVE_PATH, renderClaudePrepareCommand, "gdh-prepare"), planSkillInstallAction("claude", targetPath, adapter, CLAUDE_VERIFY_COMMAND_RELATIVE_PATH, renderClaudeVerifyCommand, "gdh-verify"));
     return actions;
 }
 function planCursorInstallActions(targetPath, adapter) {
@@ -1167,35 +1831,7 @@ function planCursorInstallActions(targetPath, adapter) {
             content: renderCursorRule(),
         }));
     }
-    const cursorSkillSurface = adapter.surfaces.find((surface) => surface.relativePath === CURSOR_ONBOARD_SKILL_RELATIVE_PATH);
-    if (!cursorSkillSurface || cursorSkillSurface.state === "ready") {
-        actions.push(createInstallAction({
-            agent: "cursor",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_ONBOARD_SKILL_RELATIVE_PATH,
-            state: "unchanged",
-            mode: "unchanged",
-            summary: "The managed Cursor `/gdh-onboard` skill already matches the expected GDH content.",
-            content: renderCursorOnboardSkill(),
-        }));
-    }
-    else {
-        actions.push(createInstallAction({
-            agent: "cursor",
-            kind: "write_file",
-            scope: "repo",
-            targetPath,
-            relativePath: CURSOR_ONBOARD_SKILL_RELATIVE_PATH,
-            state: "planned",
-            mode: cursorSkillSurface.present ? "replace" : "create",
-            summary: cursorSkillSurface.present
-                ? "Replace the existing Cursor `/gdh-onboard` skill with the managed GDH skill."
-                : "Create the managed Cursor `/gdh-onboard` skill.",
-            content: renderCursorOnboardSkill(),
-        }));
-    }
+    actions.push(planSkillInstallAction("cursor", targetPath, adapter, CURSOR_ONBOARD_SKILL_RELATIVE_PATH, renderCursorOnboardSkill, "gdh-onboard"), planSkillInstallAction("cursor", targetPath, adapter, CURSOR_STATUS_SKILL_RELATIVE_PATH, renderCursorStatusSkill, "gdh-status"), planSkillInstallAction("cursor", targetPath, adapter, CURSOR_MIGRATE_SKILL_RELATIVE_PATH, renderCursorMigrateSkill, "gdh-migrate"), planSkillInstallAction("cursor", targetPath, adapter, CURSOR_CHECK_SKILL_RELATIVE_PATH, renderCursorCheckSkill, "gdh-check"), planSkillInstallAction("cursor", targetPath, adapter, CURSOR_PREPARE_SKILL_RELATIVE_PATH, renderCursorPrepareSkill, "gdh-prepare"), planSkillInstallAction("cursor", targetPath, adapter, CURSOR_VERIFY_SKILL_RELATIVE_PATH, renderCursorVerifySkill, "gdh-verify"));
     return actions;
 }
 function dedupeInstallActions(actions) {