@skillcap/gdh 2.0.1 → 3.0.1

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,16 +1275,18 @@ 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") {
+    const codexHookConfigSurface = adapter.surfaces.find((surface) => surface.kind === "hook_config" &&
+        surface.scope === "repo" &&
+        surface.relativePath === CODEX_PROJECT_CONFIG_RELATIVE_PATH);
+    const shouldRepairCodexProjectConfig = projectMcp.enabled &&
+        (projectMcp.codexProjectFile.state !== "ready" ||
+            codexHookConfigSurface?.state !== "ready");
+    if (shouldRepairCodexProjectConfig) {
         const absolutePath = path.join(integrationRootPath, CODEX_PROJECT_CONFIG_RELATIVE_PATH);
         const existingContent = fsSync.existsSync(absolutePath)
             ? fsSync.readFileSync(absolutePath, "utf8")
@@ -1342,8 +1300,8 @@ function planCodexRepoInstallActions(targetPath, adapter, pinnedVersion, project
             state: "planned",
             mode: projectMcp.codexProjectFile.present ? "replace" : "create",
             summary: projectMcp.codexProjectFile.present
-                ? `Replace the managed \`[mcp_servers.${GDH_MCP_SERVER_NAME}]\` section in .codex/config.toml while preserving any non-GDH content.`
-                : `Create .codex/config.toml with the managed \`[mcp_servers.${GDH_MCP_SERVER_NAME}]\` entry so Codex can discover the project MCP server without a user-global registration.`,
+                ? "Refresh .codex/config.toml with the managed Codex MCP section and authoring hook block while preserving any non-GDH content."
+                : `Create .codex/config.toml with the managed \`[mcp_servers.${GDH_MCP_SERVER_NAME}]\` entry and authoring hook block so Codex can discover GDH without a user-global registration.`,
             content: renderManagedCodexProjectConfig(existingContent, pinnedVersion),
         }));
     }
@@ -1663,18 +1621,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 +1638,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.",
@@ -3335,7 +3279,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";