@skillcap/gdh 0.18.1 → 0.19.0

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

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { buildGdhStatusResult, CLAUDE_CHECK_COMMAND_RELATIVE_PATH, CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH, CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH, CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH, CLAUDE_PREPARE_COMMAND_RELATIVE_PATH, CLAUDE_STATUS_COMMAND_RELATIVE_PATH, CLAUDE_VERIFY_COMMAND_RELATIVE_PATH, CODEX_CHECK_SKILL_RELATIVE_PATH, CODEX_MIGRATE_SKILL_RELATIVE_PATH, CODEX_ONBOARD_SKILL_RELATIVE_PATH, CODEX_PREPARE_SKILL_RELATIVE_PATH, CODEX_STATUS_SKILL_RELATIVE_PATH, CODEX_VERIFY_SKILL_RELATIVE_PATH, CURSOR_CHECK_SKILL_RELATIVE_PATH, CURSOR_MIGRATE_SKILL_RELATIVE_PATH, CURSOR_ONBOARD_SKILL_RELATIVE_PATH, CURSOR_PREPARE_SKILL_RELATIVE_PATH, CURSOR_STATUS_SKILL_RELATIVE_PATH, CURSOR_VERIFY_SKILL_RELATIVE_PATH, createGsdSnapshot, getSupportedAgentAdaptersStatus, installSupportedAgentAdapters, } from "@gdh/adapters";
+import { buildGdhStatusResult, CLAUDE_CHECK_SKILL_RELATIVE_PATH, CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH, CLAUDE_MIGRATE_SKILL_RELATIVE_PATH, CLAUDE_ONBOARD_SKILL_RELATIVE_PATH, CLAUDE_PREPARE_SKILL_RELATIVE_PATH, CLAUDE_SCAN_SKILL_RELATIVE_PATH, CLAUDE_STATUS_SKILL_RELATIVE_PATH, CODEX_CHECK_SKILL_RELATIVE_PATH, CODEX_MIGRATE_SKILL_RELATIVE_PATH, CODEX_ONBOARD_SKILL_RELATIVE_PATH, CODEX_PREPARE_SKILL_RELATIVE_PATH, CODEX_SCAN_SKILL_RELATIVE_PATH, CODEX_STATUS_SKILL_RELATIVE_PATH, CURSOR_CHECK_SKILL_RELATIVE_PATH, CURSOR_MIGRATE_SKILL_RELATIVE_PATH, CURSOR_ONBOARD_SKILL_RELATIVE_PATH, CURSOR_PREPARE_SKILL_RELATIVE_PATH, CURSOR_SCAN_SKILL_RELATIVE_PATH, CURSOR_STATUS_SKILL_RELATIVE_PATH, createGsdSnapshot, getSupportedAgentAdaptersStatus, installSupportedAgentAdapters, } from "@gdh/adapters";
 import { checkManagedLsp, doctorManagedLsp, getManagedLspStatus, hasCompleteOnboardingSurface, inspectCacheState, pruneCacheState, pruneManagedLsp, readProjectConfig, readWorktreeState, resolveAuthoringStatus, resolvePinnedVersion, resolveProjectRoot, resolveTargetGodotDocsVersion, restartManagedLsp, runAuthoringCheck, runImportRefresh, runTargetPrepare, runWarmup, stopManagedLsp, } from "@gdh/authoring";
 import { definePackageBoundary, GDH_AUTHORING_DOGFOOD_VERSION, GDH_AUTHORING_SLICE_REPORT_VERSION, GDH_PRODUCT_NAME, resolveCurrentGdhInstall, resolveGdhProductMetadata, } from "@gdh/core";
 import { fetchOfficialGodotDoc, getGuidanceStatus, resolveGuidanceQuery, searchOfficialGodotDocs, } from "@gdh/docs";
@@ -12,7 +12,7 @@ import { createMcpManifest, invokeMcpTool, serveMcpOverStdio } from "@gdh/mcp";
 import { inspectAuthoringEffectiveness, inspectAuthoringSessions, inspectGuidanceAudit, recordAuthoringSessionEvent, } from "@gdh/observability";
 import { checkRuntimeRecipe, inspectRuntimeBridgeSurface, installRuntimeBridgeSurface, listRuntimeRecipes, removeRuntimeBridgeSurface, repairRuntimeBridgeSurface, runRuntimeRecipe, showRuntimeRecipe, } from "@gdh/runtime";
 import { applyRepairableOnboardingWrites, onboardGodotProject, persistInventoryForTarget, readInventoryCacheOrScan, scanGodotProjectInventory, } from "@gdh/scan";
-import { evaluateDonePolicy, exerciseRuntimeCorpusEntry, inspectRuntimeCorpusStatus, inspectRuntimeVerificationBundleState, inspectRuntimeVerificationReadiness, listRuntimeScenarios, materializeRuntimeCorpusEntry, recommendValidationForChange, recordRuntimeCorpusValidation, runRuntimeVerificationScenario, showRuntimeScenario, } from "@gdh/verify";
+import { exerciseRuntimeCorpusEntry, inspectRuntimeCorpusStatus, inspectRuntimeVerificationBundleState, inspectRuntimeVerificationReadiness, listRuntimeScenarios, materializeRuntimeCorpusEntry, recordRuntimeCorpusValidation, runRuntimeVerificationScenario, showRuntimeScenario, } from "@gdh/verify";
 import { migrateProjectLifecycleSurface } from "./migrate.js";
 import { presentPublicRuntimeTerms } from "./public-terms.js";
 import { runSelfUpdateCommand } from "./self-update.js";
@@ -695,24 +695,24 @@ async function runDocsFetchCommand(args, io) {
     }
 }
 async function runAuthoringCheckCommand(args, io) {
+    const usage = [
+        "Usage: gdh authoring check [target] [--mode final|post-edit] [--changed <path>...] [--severity-policy errors|all] [--format json|compact]",
+        "Usage: gdh authoring check --target <path> [--mode final|post-edit] [--changed <path>...] [--severity-policy errors|all] [--format json|compact]",
+        "",
+        "Run GDH authoring validation and print structured JSON by default.",
+        "Use --mode post-edit with --changed for fast scoped feedback after edits.",
+        "Use --mode final before claiming code-validity for task completion.",
+    ].join("\n");
     if (args.includes("--help")) {
-        io.stdout.write([
-            "Usage: gdh authoring check [target]",
-            "Usage: gdh authoring check --target <path>",
-            "",
-            "Run the current GDH authoring-check flow and print a structured result as JSON.",
-        ].join("\n") + "\n");
+        io.stdout.write(`${usage}\n`);
         return 0;
     }
-    const parsedTarget = parseSingleTargetPathArg(args, {
-        usage: "Usage: gdh authoring check [target]\nUsage: gdh authoring check --target <path>\n",
-        allowTargetOption: true,
-    });
-    if (parsedTarget.error !== null) {
-        io.stderr.write(parsedTarget.error);
+    const parsed = parseAuthoringCheckArgs(args, usage);
+    if (parsed.error !== null) {
+        io.stderr.write(parsed.error);
         return 1;
     }
-    const targetPath = parsedTarget.targetPath;
+    const { targetPath, mode, changedFiles, severityPolicy, outputFormat } = parsed;
     const commandStartedAtMs = Date.now();
     try {
         const context = await buildAuthoringContext(targetPath);
@@ -720,15 +720,18 @@ async function runAuthoringCheckCommand(args, io) {
             targetPath,
             status: context.status,
             projectConfig: context.projectConfig,
+            mode,
+            changedFiles,
+            severityPolicy,
         });
         await recordSessionEvent(targetPath, {
             commandStartedAtMs,
             kind: "authoring_check",
-            command: "gdh authoring check",
+            command: formatAuthoringCheckCommand({ mode, changedFiles, severityPolicy, outputFormat }),
             state: result.status === "unavailable" ? "blocked" : "succeeded",
             summary: result.summary,
             validation: {
-                changedFiles: [],
+                changedFiles,
                 recommendedKinds: ["authoring_check"],
                 performedKinds: result.status === "passed" ||
                     result.status === "diagnostics" ||
@@ -737,14 +740,19 @@ async function runAuthoringCheckCommand(args, io) {
                     : [],
             },
         });
-        writeJsonResult(io, result, { presentRuntimeTerms: true });
+        if (outputFormat === "compact") {
+            io.stdout.write(formatCompactAuthoringCheckResult(result));
+        }
+        else {
+            writeJsonResult(io, result, { presentRuntimeTerms: true });
+        }
         return 0;
     }
     catch (error) {
         await recordSessionEvent(targetPath, {
             commandStartedAtMs,
             kind: "authoring_check",
-            command: "gdh authoring check",
+            command: formatAuthoringCheckCommand({ mode, changedFiles, severityPolicy, outputFormat }),
             state: "failed",
             summary: "GDH authoring check failed before producing a result.",
             errorMessage: formatCliError(error),
@@ -753,6 +761,151 @@ async function runAuthoringCheckCommand(args, io) {
         return 1;
     }
 }
+function parseAuthoringCheckArgs(args, usage) {
+    const optionNames = new Set(["--target", "--mode", "--changed", "--severity-policy", "--format"]);
+    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
+        usage,
+        optionsWithValues: [...optionNames],
+    });
+    if (unsupportedOptionsError !== null) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: unsupportedOptionsError,
+        };
+    }
+    for (const optionName of optionNames) {
+        if (args.includes(optionName) && hasMissingOptionValue(args, optionName)) {
+            return {
+                targetPath: path.resolve("."),
+                mode: "final",
+                changedFiles: [],
+                severityPolicy: "errors",
+                outputFormat: "json",
+                error: `Usage error: ${optionName} requires a value.\n${usage}`,
+            };
+        }
+    }
+    const targetOptionValue = readSingleOptionValue(args, "--target");
+    const positionalArgs = extractPositionalArgs(args, optionNames);
+    if (positionalArgs.length > 1) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: `Usage error: command accepts at most one target path.\n${usage}`,
+        };
+    }
+    if (targetOptionValue !== null && positionalArgs.length > 0) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: `Usage error: choose either a positional target path or --target <path>.\n${usage}`,
+        };
+    }
+    const modeValue = readSingleOptionValue(args, "--mode") ?? "final";
+    const mode = normalizeAuthoringCheckMode(modeValue);
+    if (mode === null) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: `Usage error: --mode must be final or post-edit.\n${usage}`,
+        };
+    }
+    const severityPolicyValue = readSingleOptionValue(args, "--severity-policy") ?? "errors";
+    const severityPolicy = severityPolicyValue === "errors" || severityPolicyValue === "all" ? severityPolicyValue : null;
+    if (severityPolicy === null) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: `Usage error: --severity-policy must be errors or all.\n${usage}`,
+        };
+    }
+    const outputFormatValue = readSingleOptionValue(args, "--format") ?? "json";
+    const outputFormat = outputFormatValue === "json" || outputFormatValue === "compact" ? outputFormatValue : null;
+    if (outputFormat === null) {
+        return {
+            targetPath: path.resolve("."),
+            mode: "final",
+            changedFiles: [],
+            severityPolicy: "errors",
+            outputFormat: "json",
+            error: `Usage error: --format must be json or compact.\n${usage}`,
+        };
+    }
+    return {
+        targetPath: path.resolve(targetOptionValue ?? positionalArgs[0] ?? "."),
+        mode,
+        changedFiles: collectOptionValues(args, "--changed"),
+        severityPolicy,
+        outputFormat,
+        error: null,
+    };
+}
+function normalizeAuthoringCheckMode(value) {
+    if (value === "final") {
+        return "final";
+    }
+    if (value === "post-edit" || value === "post_edit") {
+        return "post_edit";
+    }
+    return null;
+}
+function hasMissingOptionValue(args, optionName) {
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== optionName) {
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--")) {
+            return true;
+        }
+    }
+    return false;
+}
+function formatAuthoringCheckCommand(input) {
+    const args = [
+        "gdh authoring check",
+        `--mode ${input.mode === "post_edit" ? "post-edit" : "final"}`,
+        ...input.changedFiles.map((changedFile) => `--changed ${changedFile}`),
+        `--severity-policy ${input.severityPolicy}`,
+        `--format ${input.outputFormat}`,
+    ];
+    return args.join(" ");
+}
+function formatCompactAuthoringCheckResult(result) {
+    const lines = result.diagnostics.map((diagnostic) => {
+        const pathPart = diagnostic.path === null ? "<unknown>" : `res://${diagnostic.path}`;
+        const line = diagnostic.line === null ? "" : `:${diagnostic.line + 1}`;
+        const column = diagnostic.column === null ? "" : `:${diagnostic.column + 1}`;
+        return `${pathPart}${line}${column} [${diagnostic.severity}] ${diagnostic.message}`;
+    });
+    const summary = result.blockingSummary;
+    const outcome = summary.state === "blocked"
+        ? "Completion blocked."
+        : summary.state === "unconfirmed"
+            ? "Completion unconfirmed."
+            : "Completion allowed.";
+    lines.push(`${summary.errorCount} errors, ${summary.warningCount} warnings, ${summary.infoCount} info. ${outcome}`);
+    if (summary.reasons.length > 0) {
+        lines.push(`Reasons: ${summary.reasons.join(", ")}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
 async function runLspStatusCommand(args, io) {
     if (args.includes("--help")) {
         io.stdout.write([
@@ -1103,7 +1256,7 @@ async function runAdaptersCommand(args, io) {
             "  status [target] [--integration-root <path>]      Inspect supported-agent reinforcement status as JSON.",
             "  install [target] [--dry-run] [--agent <name>] [--user] [--dev-repo <path>] [--integration-root <path>]",
             "                                                   Install or repair supported-agent reinforcement surfaces.",
-            "  gsd snapshot [target] [--files <path>] [--performed <kind>]  Export a read-mostly GSD projection as JSON.",
+            "  gsd snapshot [target] [--files <path>]  Export a read-mostly GSD projection as JSON.",
             "",
             "Supported agents: codex, claude, cursor",
         ].join("\n") + "\n");
@@ -1123,7 +1276,7 @@ async function runAdaptersCommand(args, io) {
         "",
         "Usage: gdh adapters status [target] [--integration-root <path>]",
         "Usage: gdh adapters install [target] [--dry-run] [--agent <name>] [--user] [--dev-repo <path>] [--integration-root <path>]",
-        "Usage: gdh adapters gsd snapshot [target] [--files <path>] [--performed <kind>]",
+        "Usage: gdh adapters gsd snapshot [target] [--files <path>]",
     ].join("\n") + "\n");
     return 1;
 }
@@ -1134,7 +1287,7 @@ async function runGsdAdapterCommand(args, io) {
             "Usage: gdh adapters gsd <command> [target]",
             "",
             "Commands:",
-            "  snapshot [target] [--files <path>] [--performed <kind>]  Export a read-mostly GSD projection as JSON.",
+            "  snapshot [target] [--files <path>]  Export a read-mostly GSD projection as JSON.",
         ].join("\n") + "\n");
         return 0;
     }
@@ -1144,7 +1297,7 @@ async function runGsdAdapterCommand(args, io) {
     io.stderr.write([
         `Unknown adapters gsd command: ${subcommand}`,
         "",
-        "Usage: gdh adapters gsd snapshot [target] [--files <path>] [--performed <kind>]",
+        "Usage: gdh adapters gsd snapshot [target] [--files <path>]",
     ].join("\n") + "\n");
     return 1;
 }
@@ -1366,10 +1519,6 @@ async function runVerifyCommand(args, io) {
             "                                                  Inspect or record runtime corpus release-readiness evidence as JSON.",
             "  drift [target]",
             "                                                  Check whether baked `@skillcap/gdh@<version>` literals (skills + commands) match .gdh/project.yaml gdh_version.",
-            "  recommend [target] --files <path> [--files <path>...]",
-            "                                                  Recommend authoring-first validation requirements for the supplied change set.",
-            "  done [target] --files <path> [--files <path>...] [--performed <kind>]",
-            "                                                  Evaluate whether the supplied change set is eligible to be called done.",
         ].join("\n") + "\n");
         return 0;
     }
@@ -1383,12 +1532,6 @@ async function runVerifyCommand(args, io) {
         const verifyTargetPath = rest.find((arg) => !arg.startsWith("--")) ?? ".";
         await emitUpdateBannerIfStale(verifyTargetPath, io);
     }
-    if (subcommand === "recommend") {
-        return runVerifyRecommendCommand(rest, io);
-    }
-    if (subcommand === "done") {
-        return runVerifyDoneCommand(rest, io);
-    }
     if (subcommand === "run") {
         return runVerifyRunCommand(rest, io);
     }
@@ -1415,8 +1558,6 @@ async function runVerifyCommand(args, io) {
         "Usage: gdh verify corpus exercise --entry <id> [--manifest <path>] [--workspace-root <path>] [--no-prepare]",
         "Usage: gdh verify corpus record --entry <id> --target <path> [--manifest <path>] [--workspace-root <path>]",
         "Usage: gdh verify drift [target]",
-        "Usage: gdh verify recommend [target] --files <path> [--files <path>...]",
-        "Usage: gdh verify done [target] --files <path> [--files <path>...] [--performed <kind>]",
     ].join("\n") + "\n");
     return 1;
 }
@@ -2186,23 +2327,23 @@ async function runAdaptersInstallCommand(args, io) {
 async function runGsdSnapshotCommand(args, io) {
     if (args.includes("--help")) {
         io.stdout.write([
-            "Usage: gdh adapters gsd snapshot [target] [--files <path>] [--performed <kind>]",
+            "Usage: gdh adapters gsd snapshot [target] [--files <path>]",
             "",
             "Export a read-mostly GSD projection over current GDH status, guidance, and validation surfaces as JSON.",
         ].join("\n") + "\n");
         return 0;
     }
     const unsupportedOptionsError = findUnsupportedOptionsError(args, {
-        usage: "Usage: gdh adapters gsd snapshot [target] [--files <path>] [--performed <kind>]\n",
-        optionsWithValues: ["--files", "--performed"],
+        usage: "Usage: gdh adapters gsd snapshot [target] [--files <path>]\n",
+        optionsWithValues: ["--files"],
     });
     if (unsupportedOptionsError !== null) {
         io.stderr.write(unsupportedOptionsError);
         return 1;
     }
     const { targetPath, error: targetPathError } = parseOptionalPositionalTargetPath(args, {
-        usage: "Usage: gdh adapters gsd snapshot [target] [--files <path>] [--performed <kind>]\n",
-        additionalOptionsWithValues: new Set(["--files", "--performed"]),
+        usage: "Usage: gdh adapters gsd snapshot [target] [--files <path>]\n",
+        additionalOptionsWithValues: new Set(["--files"]),
     });
     if (targetPathError !== null) {
         io.stderr.write(targetPathError);
@@ -2211,7 +2352,6 @@ async function runGsdSnapshotCommand(args, io) {
     try {
         const result = await createGsdSnapshot(targetPath, {
             files: collectOptionValues(args, "--files"),
-            performed: collectPerformedValidationKinds(args),
         });
         io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         return 0;
@@ -2376,149 +2516,6 @@ async function buildAuthoringContext(targetPath, io) {
         status,
     };
 }
-async function runVerifyRecommendCommand(args, io) {
-    if (args.includes("--help")) {
-        io.stdout.write([
-            "Usage: gdh verify recommend [target] --files <path> [--files <path>...]",
-            "",
-            "Recommend authoring-first validation requirements for the supplied change set as JSON.",
-        ].join("\n") + "\n");
-        return 0;
-    }
-    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
-        usage: "Usage: gdh verify recommend [target] --files <path> [--files <path>...]\n",
-        optionsWithValues: ["--files"],
-    });
-    if (unsupportedOptionsError !== null) {
-        io.stderr.write(unsupportedOptionsError);
-        return 1;
-    }
-    const { targetPath, error: targetPathError } = parseOptionalPositionalTargetPath(args, {
-        usage: "Usage: gdh verify recommend [target] --files <path> [--files <path>...]\n",
-        additionalOptionsWithValues: new Set(["--files"]),
-    });
-    if (targetPathError !== null) {
-        io.stderr.write(targetPathError);
-        return 1;
-    }
-    const files = collectOptionValues(args, "--files");
-    if (files.length === 0) {
-        io.stderr.write("Usage error: gdh verify recommend requires at least one --files <path> argument.\n");
-        return 1;
-    }
-    const commandStartedAtMs = Date.now();
-    try {
-        const context = await buildAuthoringContext(targetPath);
-        const result = await recommendValidationForChange({
-            targetPath,
-            inventory: context.inventory,
-            status: context.status,
-            projectConfig: context.projectConfig,
-            files,
-        });
-        await recordSessionEvent(targetPath, {
-            commandStartedAtMs,
-            kind: "verify_recommend",
-            command: "gdh verify recommend",
-            state: result.recommendations.length === 0 ? "blocked" : "succeeded",
-            summary: result.summary,
-            changedFiles: files,
-            guidance: buildGuidanceSnapshot(result.guidance),
-            validation: {
-                changedFiles: files,
-                recommendedKinds: result.recommendations.map((item) => item.kind),
-                performedKinds: [],
-            },
-        });
-        io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        await recordSessionEvent(targetPath, {
-            commandStartedAtMs,
-            kind: "verify_recommend",
-            command: "gdh verify recommend",
-            state: "failed",
-            summary: "Validation recommendation failed before producing a result.",
-            changedFiles: files,
-            errorMessage: formatCliError(error),
-        });
-        io.stderr.write(`Failed to recommend validation for "${targetPath}": ${formatCliError(error)}\n`);
-        return 1;
-    }
-}
-async function runVerifyDoneCommand(args, io) {
-    if (args.includes("--help")) {
-        io.stdout.write([
-            "Usage: gdh verify done [target] --files <path> [--files <path>...] [--performed <kind>]",
-            "",
-            "Evaluate whether the supplied change set is eligible to be called done as JSON.",
-        ].join("\n") + "\n");
-        return 0;
-    }
-    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
-        usage: "Usage: gdh verify done [target] --files <path> [--files <path>...] [--performed <kind>]\n",
-        optionsWithValues: ["--files", "--performed"],
-    });
-    if (unsupportedOptionsError !== null) {
-        io.stderr.write(unsupportedOptionsError);
-        return 1;
-    }
-    const { targetPath, error: targetPathError } = parseOptionalPositionalTargetPath(args, {
-        usage: "Usage: gdh verify done [target] --files <path> [--files <path>...] [--performed <kind>]\n",
-        additionalOptionsWithValues: new Set(["--files", "--performed"]),
-    });
-    if (targetPathError !== null) {
-        io.stderr.write(targetPathError);
-        return 1;
-    }
-    const files = collectOptionValues(args, "--files");
-    if (files.length === 0) {
-        io.stderr.write("Usage error: gdh verify done requires at least one --files <path> argument.\n");
-        return 1;
-    }
-    const commandStartedAtMs = Date.now();
-    try {
-        const context = await buildAuthoringContext(targetPath);
-        const result = await evaluateDonePolicy({
-            targetPath,
-            inventory: context.inventory,
-            status: context.status,
-            projectConfig: context.projectConfig,
-            files,
-            performed: collectPerformedValidationKinds(args),
-        });
-        await recordSessionEvent(targetPath, {
-            commandStartedAtMs,
-            kind: "verify_done",
-            command: "gdh verify done",
-            state: result.status === "done" ? "succeeded" : "blocked",
-            summary: result.summary,
-            changedFiles: files,
-            guidance: buildGuidanceSnapshot(result.recommendation.guidance),
-            validation: {
-                changedFiles: files,
-                recommendedKinds: result.recommendation.recommendations.map((item) => item.kind),
-                performedKinds: result.performedValidations.map((item) => item.kind),
-            },
-        });
-        io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        await recordSessionEvent(targetPath, {
-            commandStartedAtMs,
-            kind: "verify_done",
-            command: "gdh verify done",
-            state: "failed",
-            summary: "Done-policy evaluation failed before producing a result.",
-            changedFiles: files,
-            errorMessage: formatCliError(error),
-        });
-        io.stderr.write(`Failed to evaluate done policy for "${targetPath}": ${formatCliError(error)}\n`);
-        return 1;
-    }
-}
 async function runVerifyRunCommand(args, io) {
     if (args.includes("--help")) {
         io.stdout.write([
@@ -2731,19 +2728,19 @@ const VERIFY_DRIFT_SCANNED_FILES = [
     { relativePath: CODEX_MIGRATE_SKILL_RELATIVE_PATH, description: "Codex gdh-migrate skill" },
     { relativePath: CODEX_CHECK_SKILL_RELATIVE_PATH, description: "Codex gdh-check skill" },
     { relativePath: CODEX_PREPARE_SKILL_RELATIVE_PATH, description: "Codex gdh-prepare skill" },
-    { relativePath: CODEX_VERIFY_SKILL_RELATIVE_PATH, description: "Codex gdh-verify skill" },
+    { relativePath: CODEX_SCAN_SKILL_RELATIVE_PATH, description: "Codex gdh-scan skill" },
     { relativePath: CURSOR_ONBOARD_SKILL_RELATIVE_PATH, description: "Cursor gdh-onboard skill" },
     { relativePath: CURSOR_STATUS_SKILL_RELATIVE_PATH, description: "Cursor gdh-status skill" },
     { relativePath: CURSOR_MIGRATE_SKILL_RELATIVE_PATH, description: "Cursor gdh-migrate skill" },
     { relativePath: CURSOR_CHECK_SKILL_RELATIVE_PATH, description: "Cursor gdh-check skill" },
     { relativePath: CURSOR_PREPARE_SKILL_RELATIVE_PATH, description: "Cursor gdh-prepare skill" },
-    { relativePath: CURSOR_VERIFY_SKILL_RELATIVE_PATH, description: "Cursor gdh-verify skill" },
-    { relativePath: CLAUDE_ONBOARD_COMMAND_RELATIVE_PATH, description: "Claude gdh/onboard command" },
-    { relativePath: CLAUDE_STATUS_COMMAND_RELATIVE_PATH, description: "Claude gdh/status command" },
-    { relativePath: CLAUDE_MIGRATE_COMMAND_RELATIVE_PATH, description: "Claude gdh/migrate command" },
-    { relativePath: CLAUDE_CHECK_COMMAND_RELATIVE_PATH, description: "Claude gdh/check command" },
-    { relativePath: CLAUDE_PREPARE_COMMAND_RELATIVE_PATH, description: "Claude gdh/prepare command" },
-    { relativePath: CLAUDE_VERIFY_COMMAND_RELATIVE_PATH, description: "Claude gdh/verify command" },
+    { relativePath: CURSOR_SCAN_SKILL_RELATIVE_PATH, description: "Cursor gdh-scan skill" },
+    { relativePath: CLAUDE_ONBOARD_SKILL_RELATIVE_PATH, description: "Claude gdh-onboard skill" },
+    { relativePath: CLAUDE_STATUS_SKILL_RELATIVE_PATH, description: "Claude gdh-status skill" },
+    { relativePath: CLAUDE_MIGRATE_SKILL_RELATIVE_PATH, description: "Claude gdh-migrate skill" },
+    { relativePath: CLAUDE_CHECK_SKILL_RELATIVE_PATH, description: "Claude gdh-check skill" },
+    { relativePath: CLAUDE_PREPARE_SKILL_RELATIVE_PATH, description: "Claude gdh-prepare skill" },
+    { relativePath: CLAUDE_SCAN_SKILL_RELATIVE_PATH, description: "Claude gdh-scan skill" },
     // Phase 12 extension — close the Phase 11 coverage gap (research §Baked Version Surface Inventory rows 26-28).
     // These files are re-baked at pin time and must be audited by MIG-02's post-condition invariant.
     //
@@ -2771,7 +2768,7 @@ const VERIFY_DRIFT_SCANNED_FILES = [
     // statusline IS re-baked on every `gdh adapters install` via the renderer pipeline, which ensures
     // it stays current with the hook version; pin-literal drift detection is not applicable here.
     //
-    // Intentionally excluded: the Claude /gdh-update command (.claude/commands/gdh/update.md) —
+    // Intentionally excluded: the Claude /gdh-update skill (.claude/skills/gdh-update/SKILL.md) —
     // the rendered command shells out to `npx -y @skillcap/gdh@latest self-update` (LITERAL @latest,
     // not @<pinnedVersion>). The shellout MUST bake @latest so the NEW CLI performs the update,
     // not the OLD (potentially buggy) pinned one. Because @latest is not a semver literal, the
@@ -2794,7 +2791,7 @@ async function runVerifyDriftCommand(args, io) {
             "Usage: gdh verify drift [target]",
             "",
             "Compares every baked `@skillcap/gdh@<version>` literal across the managed",
-            "surfaces (regenerated Codex/Cursor/Claude skill + command files) against",
+            "surfaces (regenerated Codex/Cursor/Claude skill files and hooks) against",
             ".gdh/project.yaml gdh_version. Exits 1 and",
             "emits a structured JSON result when ANY file's baked version diverges from",
             "the pinned value. Covers ROADMAP Success Criterion #3 (one source of truth).",
@@ -3463,13 +3460,12 @@ async function runAuthoringSliceDoctor(targetPath) {
             adapters: null,
             dogfood,
             authoringCheck: null,
-            donePolicy: null,
         };
     }
     if (dogfood.state === "blocked" ||
         dogfood.onboarding === null ||
         dogfood.status === null ||
-        dogfood.validationRecommendation === null) {
+        dogfood.guidanceResolve === null) {
         const classification = classifyBlockedDogfoodResult(dogfood);
         return {
             version: GDH_AUTHORING_SLICE_REPORT_VERSION,
@@ -3482,7 +3478,6 @@ async function runAuthoringSliceDoctor(targetPath) {
             adapters: null,
             dogfood,
             authoringCheck: null,
-            donePolicy: null,
         };
     }
     const validation = await evaluateAuthoringSliceValidation(targetPath);
@@ -3490,7 +3485,6 @@ async function runAuthoringSliceDoctor(targetPath) {
         dogfood,
         adapters: validation.adapters,
         authoringCheck: validation.authoringCheck,
-        donePolicy: validation.donePolicy,
     });
     return {
         version: GDH_AUTHORING_SLICE_REPORT_VERSION,
@@ -3503,7 +3497,6 @@ async function runAuthoringSliceDoctor(targetPath) {
         adapters: validation.adapters,
         dogfood,
         authoringCheck: validation.authoringCheck,
-        donePolicy: validation.donePolicy,
     };
 }
 async function executeAuthoringDogfoodTarget(input) {
@@ -3527,7 +3520,6 @@ async function executeAuthoringDogfoodTarget(input) {
             status: null,
             guidanceStatus: null,
             guidanceResolve: null,
-            validationRecommendation: null,
             sessionInspection: null,
             blockedReason: input.kind === "pilot" ? "pilot_target_missing" : "fixture_target_missing",
             errorMessage: null,
@@ -3577,7 +3569,6 @@ async function executeAuthoringDogfoodTarget(input) {
                 status: null,
                 guidanceStatus: null,
                 guidanceResolve: null,
-                validationRecommendation: null,
                 sessionInspection,
                 blockedReason: onboarding.status === "ready" ? "selected_project_missing" : "onboarding_unresolved",
                 errorMessage: null,
@@ -3614,52 +3605,35 @@ async function executeAuthoringDogfoodTarget(input) {
                 status: context.status,
                 guidanceStatus,
                 guidanceResolve: null,
-                validationRecommendation: null,
                 sessionInspection,
                 blockedReason: "no_representative_changed_files",
                 errorMessage: null,
             };
         }
-        const validationRecommendation = await recommendValidationForChange({
-            targetPath: workingCopy.targetPath,
-            inventory: context.inventory,
-            status: context.status,
-            projectConfig: context.projectConfig,
-            files: changedFiles,
+        const guidanceResolve = await resolveGuidanceQuery(workingCopy.targetPath, {
+            taskTypes: ["authoring"],
+            capabilities: context.status.effectiveCapabilities,
+            repoState: deriveGuidanceRepoState(context),
+            keywords: [],
         });
         await recordAuthoringSessionEvent(workingCopy.targetPath, {
             sessionId,
             kind: "guidance_resolve",
             command: "gdh guidance resolve",
-            state: validationRecommendation.guidance.requiredUnits.length > 0 ||
-                validationRecommendation.guidance.recommendedUnits.length > 0
+            state: guidanceResolve.requiredUnits.length > 0 || guidanceResolve.recommendedUnits.length > 0
                 ? "succeeded"
                 : "blocked",
-            summary: validationRecommendation.guidance.status.summary,
-            guidance: buildGuidanceSnapshot(validationRecommendation.guidance),
+            summary: guidanceResolve.status.summary,
+            guidance: buildGuidanceSnapshot(guidanceResolve),
             changedFiles,
         });
-        await recordAuthoringSessionEvent(workingCopy.targetPath, {
-            sessionId,
-            kind: "verify_recommend",
-            command: "gdh verify recommend",
-            state: validationRecommendation.recommendations.length > 0 ? "succeeded" : "blocked",
-            summary: validationRecommendation.summary,
-            changedFiles,
-            guidance: buildGuidanceSnapshot(validationRecommendation.guidance),
-            validation: {
-                changedFiles,
-                recommendedKinds: validationRecommendation.recommendations.map((item) => item.kind),
-                performedKinds: [],
-            },
-        });
         const sessionInspection = await inspectAuthoringSessions(workingCopy.targetPath, {
             sessionId,
         });
         const state = isHealthyDogfoodTarget({
             readiness: context.status.readiness,
             guidanceState: guidanceStatus.state,
-            recommendationCount: validationRecommendation.recommendations.length,
+            guidanceUnitCount: guidanceResolve.requiredUnits.length + guidanceResolve.recommendedUnits.length,
             sessionState: sessionInspection.state,
         })
             ? "passed"
@@ -3668,15 +3642,14 @@ async function executeAuthoringDogfoodTarget(input) {
             target,
             state,
             summary: state === "passed"
-                ? "Dogfood exercised onboarding, readiness, guidance, validation recommendation, and session evidence successfully."
+                ? "Dogfood exercised onboarding, readiness, guidance resolution, and session evidence successfully."
                 : "Dogfood exercised the target, but one or more authoring-slice surfaces stayed blocked or incomplete.",
             changedFiles,
             inventory: onboarding.inventory,
             onboarding,
             status: context.status,
             guidanceStatus,
-            guidanceResolve: validationRecommendation.guidance,
-            validationRecommendation,
+            guidanceResolve,
             sessionInspection,
             blockedReason: state === "passed" ? null : "authoring_slice_incomplete",
             errorMessage: null,
@@ -3693,7 +3666,6 @@ async function executeAuthoringDogfoodTarget(input) {
             status: null,
             guidanceStatus: null,
             guidanceResolve: null,
-            validationRecommendation: null,
             sessionInspection: null,
             blockedReason: null,
             errorMessage: formatCliError(error),
@@ -3752,10 +3724,6 @@ async function evaluateAuthoringSliceValidation(targetPath) {
             throw new Error("Authoring-slice validation requires an onboarded target with a selected primary project.");
         }
         const context = await buildAuthoringContext(workingCopy.targetPath);
-        const changedFiles = deriveDogfoodChangedFiles(onboarding.selectedProject);
-        if (changedFiles.length === 0) {
-            throw new Error("Authoring-slice validation could not derive a representative authoring change set.");
-        }
         const adapters = await getSupportedAgentAdaptersStatus(workingCopy.targetPath, {
             includeUserLocal: false,
         });
@@ -3764,18 +3732,9 @@ async function evaluateAuthoringSliceValidation(targetPath) {
             status: context.status,
             projectConfig: context.projectConfig,
         });
-        const donePolicy = await evaluateDonePolicy({
-            targetPath: workingCopy.targetPath,
-            inventory: context.inventory,
-            status: context.status,
-            projectConfig: context.projectConfig,
-            files: changedFiles,
-            performed: [],
-        });
         return {
             adapters,
             authoringCheck,
-            donePolicy,
         };
     }
     finally {
@@ -3831,7 +3790,7 @@ function classifyAuthoringSliceValidation(input) {
             ].filter((reason) => reason !== null),
         };
     }
-    if (input.authoringCheck.status === "passed" && input.donePolicy.status === "done") {
+    if (input.authoringCheck.status === "passed") {
         return {
             state: "ready",
             summary: "The current authoring-first slice is healthy enough for internal use on this target.",
@@ -3857,22 +3816,6 @@ function classifyAuthoringSliceValidation(input) {
             reasons: input.authoringCheck.diagnostics.map((diagnostic) => diagnostic.message),
         };
     }
-    if (input.donePolicy.status === "not_done") {
-        return {
-            state: "degraded",
-            summary: "The authoring-first slice ran, but the work would still not be eligible to be called done with the current validation evidence.",
-            failureClass: "agent_judgment_issue",
-            reasons: input.donePolicy.reasons,
-        };
-    }
-    if (input.donePolicy.status === "blocked") {
-        return {
-            state: "blocked",
-            summary: "The authoring-first slice remains blocked because a required validation surface is still unavailable.",
-            failureClass: "environment_issue",
-            reasons: input.donePolicy.reasons,
-        };
-    }
     if (input.authoringCheck.status === "degraded") {
         return {
             state: "degraded",
@@ -3897,7 +3840,7 @@ function normalizeRelativePath(value) {
 function isHealthyDogfoodTarget(input) {
     return (input.readiness === "authorable" &&
         input.guidanceState === "ready" &&
-        input.recommendationCount > 0 &&
+        input.guidanceUnitCount > 0 &&
         input.sessionState === "available");
 }
 function summarizeAuthoringDogfoodState(results) {
@@ -3952,7 +3895,7 @@ function renderHelp() {
         "  docs fetch <ref-or-url> [target] [--project <relative-path>]  Fetch one official version-aware Godot docs page or section.",
         "  adapters status [target] [--integration-root <path>] Inspect supported-agent reinforcement status.",
         "  adapters install [target] [--dry-run] [--agent <name>] [--user] [--dev-repo <path>] [--integration-root <path>] Install or repair supported-agent reinforcement.",
-        "  adapters gsd snapshot [target] [--files <path>] [--performed <kind>] Export a read-only GSD projection.",
+        "  adapters gsd snapshot [target] [--files <path>] Export a read-only GSD projection.",
         "  authoring check [target] Run the current authoring-check entrypoint.",
         "  lsp <status|check|stop|restart|prune|doctor> [target] Manage authoring.lsp lifecycle state.",
         "  warmup [target] [--dry-run] Inspect or apply authoring worktree warmup.",
@@ -3985,8 +3928,6 @@ function renderHelp() {
         "  verify corpus materialize --entry <id> Materialize one runtime corpus entry into GDH-managed source state.",
         "  verify corpus exercise --entry <id> Exercise one runtime corpus entry through onboarding and runtime verification.",
         "  verify corpus record --entry <id> --target <path> Record runtime corpus evidence for one target.",
-        "  verify recommend [target] --files <path> Recommend validation requirements.",
-        "  verify done [target] --files <path> Evaluate whether a change is done.",
         "  cache inspect [target] Inspect namespaced authoring cache state.",
         "  cache prune [target] [--scope <scope>] Remove namespaced authoring cache state.",
         "  migrate [target] [--apply] Plan or apply current GDH project-surface migrations.",
@@ -4201,21 +4142,6 @@ function deriveGuidanceRepoState(context) {
     }
     return [...repoState];
 }
-function collectPerformedValidationKinds(args) {
-    return collectOptionValues(args, "--performed").flatMap((value) => {
-        switch (value) {
-            case "authoring_check":
-            case "unit_tests":
-            case "integration_tests":
-            case "editor_validation":
-            case "runtime_scenario":
-            case "manual_review":
-                return [value];
-            default:
-                return [];
-        }
-    });
-}
 function extractRecipePositionalArgs(args) {
     return extractPositionalArgs(args, new Set(["--provider", "--param", "--feature", "--no-feature", "--env"]));
 }