@skillcap/gdh 2.0.0 → 3.0.0

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

@@ -12,8 +12,7 @@ import { inspectRuntimeBridgeBroker, inspectRuntimeBridgeSurface, inspectRuntime
 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_RELATIVE_PATH, renderGdhAuthoringHook, } from "./authoring-hook-render.js";
-import { computeStateRelativePathFromHook } from "./authoring-hook-state-path.js";
+import { GDH_AUTHORING_HOOK_RELATIVE_PATH, renderGdhAuthoringHook, } from "./authoring-hook-render.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";
@@ -340,42 +339,6 @@ function summarizeRuntimeBridgeBrokerLifecycleForStatus(lifecycle) {
     }
     return "Runtime bridge broker state is unavailable; inspect with `gdh bridge session doctor`.";
 }
-export async function createGsdSnapshot(targetPath, options = {}) {
-    const context = await buildAuthoringContext(targetPath);
-    const effectiveRepoState = deriveRepoState(context);
-    const files = normalizeChangedFiles(options.files ?? []);
-    const guidance = await getGuidanceStatus(context.targetPath);
-    const [audit, guidanceResolve] = await Promise.all([
-        inspectGuidanceAudit(context.targetPath),
-        resolveGuidanceQuery(context.targetPath, {
-            taskTypes: ["authoring"],
-            capabilities: context.status.effectiveCapabilities,
-            repoState: effectiveRepoState,
-            keywords: [],
-        }),
-    ]);
-    const guidanceStatus = {
-        targetPath: context.targetPath,
-        projectConfigPresent: context.projectConfig !== null,
-        authoringReadiness: context.status.readiness,
-        effectiveRepoState,
-        guidance,
-        audit,
-    };
-    return {
-        targetPath: context.targetPath,
-        adapter: {
-            adapter: "gsd",
-            enabledByDefault: false,
-            state: "disabled_by_default",
-            summary: "The GSD bridge is an optional read-mostly adapter over stable GDH outputs and is not required for core GDH behavior.",
-        },
-        files,
-        status: context.status,
-        guidanceStatus,
-        guidanceResolve,
-    };
-}
 function normalizePortableRelativePath(relativePath) {
     const normalized = relativePath.split(path.sep).join("/");
     return normalized === "" ? "." : normalized.replace(/\/+$/, "");
@@ -643,7 +606,7 @@ function inspectCodexAuthoringHookConfig(targetPath, content, enabled) {
     const ready = content !== null &&
         /^\s*codex_hooks\s*=\s*true\s*$/m.test(content) &&
         content.includes("# BEGIN GDH managed authoring hooks") &&
-        content.includes(CODEX_AUTHORING_HOOK_RELATIVE_PATH);
+        content.includes(GDH_AUTHORING_HOOK_RELATIVE_PATH);
     return createSurfaceStatus({
         kind: "hook_config",
         scope: "repo",
@@ -742,7 +705,7 @@ async function inspectCodexAdapter(targetPath, guidance, projectMcp, pinnedVersi
         .readFile(path.resolve(targetPath, CODEX_RUN_GAME_SKILL_RELATIVE_PATH), "utf8")
         .catch(() => null);
     const codexAuthoringHookContent = await fs
-        .readFile(path.join(projectMcp.integrationRootPath, CODEX_AUTHORING_HOOK_RELATIVE_PATH), "utf8")
+        .readFile(path.join(projectMcp.integrationRootPath, GDH_AUTHORING_HOOK_RELATIVE_PATH), "utf8")
         .catch(() => null);
     const codexProjectConfigContent = await fs
         .readFile(path.join(projectMcp.integrationRootPath, CODEX_PROJECT_CONFIG_RELATIVE_PATH), "utf8")
@@ -758,8 +721,6 @@ async function inspectCodexAdapter(targetPath, guidance, projectMcp, pinnedVersi
         : renderGdhAuthoringHook({
             pinnedVersion,
             targetRelativePath: path.relative(projectMcp.integrationRootPath, targetPath) || ".",
-            agent: "codex",
-            stateRelativePathFromHook: computeStateRelativePathFromHook(projectMcp.integrationRootPath, CODEX_AUTHORING_HOOK_RELATIVE_PATH, projectMcp.integrationRootPath),
         });
     const surfaces = [
         createSurfaceStatus({
@@ -807,7 +768,7 @@ async function inspectCodexAdapter(targetPath, guidance, projectMcp, pinnedVersi
         ...inspectCodexSkillSurface(targetPath, CODEX_UPDATE_SKILL_RELATIVE_PATH, codexUpdateContent, expectedCodexUpdateSkill, "gdh-update"),
         ...inspectCodexSkillSurface(targetPath, CODEX_PREPARE_SKILL_RELATIVE_PATH, codexPrepareContent, expectedCodexPrepareSkill, "gdh-prepare"),
         ...inspectCodexSkillSurface(targetPath, CODEX_RUN_GAME_SKILL_RELATIVE_PATH, codexRunGameContent, expectedCodexRunGameSkill, "gdh-run-game"),
-        inspectManagedHookSurface("codex", projectMcp.integrationRootPath, CODEX_AUTHORING_HOOK_RELATIVE_PATH, codexAuthoringHookContent, expectedCodexAuthoringHook, "authoring guard"),
+        inspectManagedHookSurface("codex", projectMcp.integrationRootPath, GDH_AUTHORING_HOOK_RELATIVE_PATH, codexAuthoringHookContent, expectedCodexAuthoringHook, "authoring guard"),
         inspectCodexAuthoringHookConfig(projectMcp.integrationRootPath, codexProjectConfigContent, projectMcp.enabled),
     ];
     if (projectMcp.enabled) {
@@ -871,7 +832,7 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp, pinnedVers
         .readFile(path.join(targetPath, CLAUDE_STATUSLINE_RELATIVE_PATH), "utf8")
         .catch(() => null);
     const claudeAuthoringHookContent = await fs
-        .readFile(path.join(targetPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH), "utf8")
+        .readFile(path.join(targetPath, GDH_AUTHORING_HOOK_RELATIVE_PATH), "utf8")
         .catch(() => null);
     let detectedTarget = null;
     if (lstat?.isSymbolicLink()) {
@@ -886,11 +847,6 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp, pinnedVers
         : renderGdhAuthoringHook({
             pinnedVersion,
             targetRelativePath: ".",
-            agent: "claude",
-            // inspectClaudeAdapter previews the same-repo install: hook lives at
-            // `<targetPath>/.claude/hooks/gdh-authoring-guard.js`; state lives at
-            // `<targetPath>/.gdh-state/`. Compute the relative from the hook dir.
-            stateRelativePathFromHook: computeStateRelativePathFromHook(targetPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, targetPath),
         });
     const expectedClaudeStatusCommand = pinnedVersion === null ? null : renderClaudeStatusCommand(pinnedVersion);
     const expectedClaudeMigrateCommand = pinnedVersion === null ? null : renderClaudeMigrateCommand(pinnedVersion);
@@ -948,7 +904,7 @@ async function inspectClaudeAdapter(targetPath, guidance, projectMcp, pinnedVers
         inspectManagedHookSurface("claude", targetPath, CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH, claudeCheckUpdateHookContent, expectedClaudeCheckUpdateHook, "gdh-check-update-hook"),
         inspectManagedHookSurface("claude", targetPath, CLAUDE_CHECK_UPDATE_WORKER_RELATIVE_PATH, claudeCheckUpdateWorkerContent, expectedClaudeCheckUpdateWorker, "gdh-check-update-worker"),
         inspectManagedHookSurface("claude", targetPath, CLAUDE_STATUSLINE_RELATIVE_PATH, claudeStatuslineContent, expectedClaudeStatusline, "gdh-statusline"),
-        inspectManagedHookSurface("claude", targetPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, claudeAuthoringHookContent, expectedClaudeAuthoringHook, "authoring guard"),
+        inspectManagedHookSurface("claude", targetPath, GDH_AUTHORING_HOOK_RELATIVE_PATH, claudeAuthoringHookContent, expectedClaudeAuthoringHook, "authoring guard"),
     ];
     if (path.resolve(projectMcp.integrationRootPath) !== path.resolve(targetPath)) {
         surfaces.push(...(await inspectRootSymlinkSurfaces({
@@ -1319,13 +1275,9 @@ function planCodexRepoInstallActions(targetPath, adapter, pinnedVersion, project
         planSkillInstallAction("codex", targetPath, adapter, CODEX_UPDATE_SKILL_RELATIVE_PATH, renderCodexUpdateSkill, "gdh-update", pinnedVersion),
         planSkillInstallAction("codex", targetPath, adapter, CODEX_PREPARE_SKILL_RELATIVE_PATH, renderCodexPrepareSkill, "gdh-prepare", pinnedVersion),
         planSkillInstallAction("codex", targetPath, adapter, CODEX_RUN_GAME_SKILL_RELATIVE_PATH, renderCodexRunGameSkill, "gdh-run-game", pinnedVersion),
-        planSkillInstallAction("codex", integrationRootPath, adapter, CODEX_AUTHORING_HOOK_RELATIVE_PATH, (version) => renderGdhAuthoringHook({
+        planSkillInstallAction("codex", integrationRootPath, adapter, GDH_AUTHORING_HOOK_RELATIVE_PATH, (version) => renderGdhAuthoringHook({
             pinnedVersion: version,
             targetRelativePath: path.relative(integrationRootPath, targetPath) || ".",
-            agent: "codex",
-            // Codex install-action: hook installed at integrationRootPath; state
-            // root lives at integrationRootPath/.gdh-state.
-            stateRelativePathFromHook: computeStateRelativePathFromHook(integrationRootPath, CODEX_AUTHORING_HOOK_RELATIVE_PATH, integrationRootPath),
         }), "authoring guard", pinnedVersion),
     ];
     if (projectMcp.enabled && projectMcp.codexProjectFile.state !== "ready") {
@@ -1663,18 +1615,9 @@ function planClaudeInstallActions(targetPath, adapter, pinnedVersion, integratio
     // statusLine slot automatically because that would shadow user/global
     // statusline content. Users can manually point their config at
     // gdh-statusline.js later; the baked file is a no-op until wired.
-    planHookInstallAction("claude", targetPath, adapter, CLAUDE_STATUSLINE_RELATIVE_PATH, renderClaudeUpdateStatusline, "gdh-statusline", pinnedVersion), planHookInstallAction("claude", targetPath, adapter, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, (version) => renderGdhAuthoringHook({
+    planHookInstallAction("claude", targetPath, adapter, CLAUDE_STATUSLINE_RELATIVE_PATH, renderClaudeUpdateStatusline, "gdh-statusline", pinnedVersion), planHookInstallAction("claude", targetPath, adapter, GDH_AUTHORING_HOOK_RELATIVE_PATH, (version) => renderGdhAuthoringHook({
         pinnedVersion: version,
         targetRelativePath: ".",
-        agent: "claude",
-        // Claude install-action target install: hook lives at
-        // `<targetPath>/.claude/hooks/...`; state root lives at
-        // `<integrationRootPath>/.gdh-state/`. In the same-repo case,
-        // integrationRootPath equals targetPath; in the monorepo nested-target
-        // case (where this same hook is also installed at the target alongside
-        // a separate root-launched hook from site #5), the state remains at
-        // integrationRootPath/.gdh-state, so use integrationRootPath here.
-        stateRelativePathFromHook: computeStateRelativePathFromHook(targetPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, integrationRootPath),
     }), "authoring guard", pinnedVersion));
     if (path.resolve(integrationRootPath) !== path.resolve(targetPath)) {
         const rootTargetRelativePath = path.relative(integrationRootPath, targetPath) || ".";
@@ -1689,15 +1632,10 @@ function planClaudeInstallActions(targetPath, adapter, pinnedVersion, integratio
         }), planDirectWriteFileAction({
             agent: "claude",
             targetPath: integrationRootPath,
-            relativePath: CLAUDE_AUTHORING_HOOK_RELATIVE_PATH,
+            relativePath: GDH_AUTHORING_HOOK_RELATIVE_PATH,
             content: renderGdhAuthoringHook({
                 pinnedVersion,
                 targetRelativePath: rootTargetRelativePath,
-                agent: "claude",
-                // Root-launched Claude install in monorepo nested-target case: hook
-                // lives at `<integrationRootPath>/.claude/hooks/...`; state lives at
-                // `<integrationRootPath>/.gdh-state/`.
-                stateRelativePathFromHook: computeStateRelativePathFromHook(integrationRootPath, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, integrationRootPath),
             }),
             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.",
@@ -2434,10 +2372,21 @@ async function isDefaultRulesBoilerplate(targetPath, projectConfig) {
     return actual === expected || isPriorDefaultRulesBoilerplate(actual);
 }
 function isPriorDefaultRulesBoilerplate(content) {
-    // v0.26.8 changed only the default authoring-validation wording to stop
-    // telling agents to rerun hook-owned checks during edit loops. Prior v3
-    // boilerplate is still GDH-owned default content, so it is safe to refresh.
-    const priorV3Default = `version: ${GDH_RULES_SCHEMA_VERSION}
+    // Each entry below is a prior-version GDH-owned default rules body that is
+    // safe to refresh to the current default during `gdh migrate --apply`. The
+    // `version:` line is interpolated to the CURRENT schema version because
+    // `coerceRulesDocument` normalizes the on-disk header before this comparison.
+    // Append a new entry here when the live default body changes; removing an
+    // older entry drops chain support for targets last touched at that wording.
+    //
+    // - v0.18-v0.26.7 wording: "Run `gdh authoring check` after changing Godot
+    //   source or project configuration files." Also the locked s2c2→s2c3
+    //   transform output, so chain matrix runs from v0.18.0 land here.
+    // - v0.26.8-v2.0.0 wording: "Do not rerun authoring checks during normal
+    //   hooked edits..." Stopped telling agents to rerun hook-owned checks but
+    //   still positioned `authoring-check` as a CLI-shaped verb.
+    const priorRulesBoilerplateBodies = [
+        `version: ${GDH_RULES_SCHEMA_VERSION}
 hard_rules:
   - id: "authoring-validation-evidence"
     summary: "Use GDH authoring check evidence when judging Godot code validity."
@@ -2500,8 +2449,73 @@ path_scopes:
         kind: "editor_validation"
         required: true
         summary: "Arrange editor-side validation for \`EditorPlugin\` and plugin configuration changes before claiming code validity."
-`;
-    return content === priorV3Default;
+`,
+        `version: ${GDH_RULES_SCHEMA_VERSION}
+hard_rules:
+  - id: "authoring-validation-evidence"
+    summary: "Use managed authoring validation evidence when judging Godot code validity."
+    rationale: "Authoring validity should come from GDH diagnostics or final validation evidence, not readiness guesses."
+    validation_expectations:
+      []
+soft_guidance:
+  - id: "prefer-gdh-surfaces"
+    summary: "Prefer GDH status, target-prepare, authoring, import-refresh, and guidance surfaces over ad hoc Godot-state guesses."
+    rationale: "GDH exists to make Godot authoring and validation constraints inspectable instead of folklore-driven."
+    validation_expectations:
+      []
+prohibited_patterns:
+  - id: "generated-godot-state-is-not-truth"
+    summary: "Do not treat \`.godot/\` generated state as durable project truth or hand-edit it unless a project-specific rule says otherwise."
+    rationale: "Generated import/editor state is environment-sensitive and should not become the source of truth for agents."
+    validation_expectations:
+      []
+  - id: "dont-copy-project-local-env-files-by-default"
+    summary: "Do not copy project-local env files such as \`.env.local\` as part of default GDH target preparation unless project-specific guidance explicitly says to do so."
+    rationale: "Default GDH preparation should stay deterministic and should not silently inherit machine-local env behavior from another checkout."
+    validation_expectations:
+      []
+path_scopes:
+  - id: "authoring-files"
+    summary: "Authoring-facing Godot source and project files rely on managed hook feedback during edits and explicit validation evidence at handoff."
+    path_globs:
+      - "**/*.gd"
+      - "**/*.tscn"
+      - "**/*.tres"
+      - "project.godot"
+    hard_rules:
+      []
+    soft_guidance:
+      []
+    prohibited_patterns:
+      []
+    validation_expectations:
+      - id: "authoring-check"
+        kind: "authoring_check"
+        required: true
+        summary: "Do not rerun authoring checks during normal hooked edits; collect explicit authoring-check evidence only for handoff, unsupported file types, missing hooks, or recovery."
+  - id: "editor-plugin-files"
+    summary: "EditorPlugin and plugin configuration work requires editor-side validation, not only runtime confidence."
+    path_globs:
+      - "addons/**/plugin.gd"
+      - "addons/**/plugin.cfg"
+    hard_rules:
+      []
+    soft_guidance:
+      - id: "surface-editor-validation"
+        summary: "Surface editor-side caveats explicitly when plugin or \`@tool\` work is involved."
+        rationale: "Phase 3 already detects editor-side caveats at the point of use and Phase 4 should preserve that distinction."
+        validation_expectations:
+          []
+    prohibited_patterns:
+      []
+    validation_expectations:
+      - id: "editor-validation"
+        kind: "editor_validation"
+        required: true
+        summary: "Arrange editor-side validation for \`EditorPlugin\` and plugin configuration changes before claiming code validity."
+`,
+    ];
+    return priorRulesBoilerplateBodies.includes(content);
 }
 function inspectAgentContractLifecycleSurface(targetPath, guidanceStatus) {
     const status = guidanceStatus.agentContract;
@@ -3259,7 +3273,7 @@ function normalizeChangedFiles(files) {
 }
 export { CLAUDE_STATUSLINE_RELATIVE_PATH } from "./claude-statusline-render.js";
 export { CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH } from "./claude-update-hook-render.js";
-export { CLAUDE_AUTHORING_HOOK_COMMAND, CLAUDE_AUTHORING_HOOK_RELATIVE_PATH, CODEX_AUTHORING_HOOK_COMMAND, CODEX_AUTHORING_HOOK_RELATIVE_PATH, } from "./authoring-hook-render.js";
+export { CLAUDE_AUTHORING_HOOK_COMMAND, CODEX_AUTHORING_HOOK_COMMAND, GDH_AUTHORING_HOOK_RELATIVE_PATH, } from "./authoring-hook-render.js";
 export { bumpAndRebakePin, } from "./self-update-mechanics.js";
 export { deriveExpectedRenderSet, runInventorySweep, } from "./inventory-sweep.js";
 export { BACKUP_MANIFEST_RELATIVE_PATH, BACKUP_RELATIVE_PATH, BACKUP_STAGING_RELATIVE_PATH, detectClass1MarkerDrift, driftResultToPreservationNotes, readBackupManifest, restoreFromDurableBackup, writeDurableBackup, } from "./durable-backup.js";