@skillcap/gdh 0.18.2 → 0.19.1

package/INSTALL-BUNDLE.json

@@ -1,5 +1,5 @@
 {
   "product": "GDH",
-  "version": "0.18.2",
+  "version": "0.19.1",
   "installMode": "packaged_install"
 }

package/README.md

@@ -19,7 +19,7 @@ Then open your agent in that project and run:
 /gdh-onboard
 ```
 
-GDH writes the project guidance, command surfaces, MCP config, and local state that supported agents use for future work. Setup records the resolved GDH version in the target project so later updates can migrate that project deliberately.
+GDH writes the project guidance, agent skill surfaces, MCP config, and local state that supported agents use for future work. Setup records the resolved GDH version in the target project so later updates can migrate that project deliberately.
 
 ## Requirements
 
@@ -32,7 +32,7 @@ GDH writes the project guidance, command surfaces, MCP config, and local state t
 ## What It Does
 
 - Finds Godot project roots and writes `.gdh/project.yaml` plus `.gdh-state/` derived state.
-- Installs agent commands and skills such as `/gdh-status`, `/gdh-prepare`, `/gdh-check`, `/gdh-verify`, `/gdh-migrate`, and `/gdh-update`.
+- Installs agent commands and skills such as `/gdh-status`, `/gdh-prepare`, `/gdh-check`, `/gdh-migrate`, and `/gdh-update`.
 - Exposes MCP tools for project status, authoring checks, docs lookup, runtime bridge operations, and verification.
 - Keeps generated target-project files inside the managed project, not in GDH's own implementation repo.
 
@@ -42,8 +42,8 @@ GDH writes the project guidance, command surfaces, MCP config, and local state t
 npx -y @skillcap/gdh@latest setup
 gdh status
 gdh target prepare --dry-run
-gdh authoring check
-gdh verify recommend --since main
+gdh authoring check --mode final
+gdh authoring check --mode post-edit --changed res://scripts/player.gd --format compact
 gdh self-update --dry-run --target .
 ```
 

package/RELEASE-SPAN-UPDATE-CONTRACTS.json

@@ -218,8 +218,8 @@
       "releaseHighlights": {
         "summary": "`v0.3.0` reshapes GDH's agent integration surface. MCP is now strictly for Godot engine interaction (11 tools). Project management workflows move to 5 new agent skills generated during `gdh setup` for Claude, Codex, and Cursor.",
         "operatorChanges": [
-          "**5 new agent skills:** `/gdh-status`, `/gdh-migrate`, `/gdh-check`, `/gdh-prepare`, `/gdh-verify` — generated for all three supported agents during `gdh setup`.",
-          "**MCP scope reduction:** Removed 6 non-engine MCP tools (`status.get`, `guidance.resolve`, `verify.recommend`, `verify.done`, `verify.inspect`, `verify.readiness`). These workflows are now handled by agent skills + CLI.",
+          "**Agent workflow skills:** `/gdh-status`, `/gdh-migrate`, `/gdh-check`, and `/gdh-prepare` generated for all three supported agents during `gdh setup`.",
+          "**MCP scope reduction:** Removed non-engine MCP tools for status, guidance, and verification administration. These workflows are now handled by agent skills + CLI.",
           "**MCP retains 11 engine tools:** `docs.*`, `target.prepare`, `authoring.check`, `run-config.*`, `bridge.*`, `verify.run`.",
           "Existing targets need `gdh setup --yes` re-run to pick up the new skills."
         ]
@@ -1274,7 +1274,7 @@
       "version": "0.17.0",
       "releaseTag": "v0.17.0",
       "migrationStatus": "required",
-      "summary": "v0.17.0 completes real Godot authoring validation policy and guidance. The release changes GDH_GUIDANCE_UNIT_VERSION (6 -> 7) and GDH_RULES_SCHEMA_VERSION (1 -> 2), so managed targets need `gdh migrate --apply` to refresh generated guidance with the managed LSP lifecycle, validator-family split, and done-policy evidence rules, plus manual review for project-owned stale rules files.",
+      "summary": "v0.17.0 completes real Godot authoring validation guidance. The release changes GDH_GUIDANCE_UNIT_VERSION (6 -> 7) and GDH_RULES_SCHEMA_VERSION (1 -> 2), so managed targets need `gdh migrate --apply` to refresh generated guidance with the managed LSP lifecycle and validator-family split, plus manual review for project-owned stale rules files.",
       "releaseHighlights": {
         "summary": "v0.17.0 makes authoring validation real instead of lifecycle-shaped. GDH now manages a Godot LSP protocol client, separates LSP process health from diagnostic evidence, collects GDScript diagnostics, validates `.tscn` and `.tres` resources through Godot, and teaches agents that required authoring checks stay blocked when evidence is unavailable or degraded.",
         "operatorChanges": [
@@ -1282,7 +1282,7 @@
           "**LSP state is worktree-safe.** Managed LSP identity includes worktree, project, launcher, editor binary, and editor version data; GDH mutates registry state through a lock and exposes bounded `gdh lsp prune` / `gdh lsp stop` cleanup commands.",
           "**GDScript diagnostics are collected through the LSP.** `gdh authoring check` can surface real `.gd` diagnostics with source, severity, range, and provenance instead of a placeholder readiness result.",
           "**Scene and resource files have their own validator.** `.tscn` and `.tres` files route through the `godot_scene_resource` validator, while unsupported authoring files remain manual-validation work.",
-          "**Done policy is validator-aware.** `gdh verify recommend` and `gdh verify done` distinguish `gdscript_lsp`, `godot_scene_resource`, and unsupported authoring surfaces so agents do not claim completion from incomplete evidence.",
+          "**Authoring checks are validator-aware.** `gdh authoring check` distinguishes `gdscript_lsp`, `godot_scene_resource`, and unsupported authoring surfaces so agents do not claim code validity from incomplete evidence.",
           "**Generated guidance rejects fake readiness.** Managed guidance and adapter skills now tell agents to use `gdh authoring check` for evidence and treat lifecycle-only LSP status as operational visibility."
         ]
       },
@@ -1343,15 +1343,14 @@
             "id": "validate_authoring_evidence",
             "kind": "mechanical",
             "summary": "Collect real authoring validator evidence.",
-            "detail": "Run `gdh authoring check`, then use `gdh verify recommend` and `gdh verify done` for changed files. Required authoring checks remain blocked when validator evidence is unavailable, degraded, or missing.",
+            "detail": "Run `gdh authoring check` for changed files. Required authoring checks remain blocked when validator evidence is unavailable, degraded, or missing.",
             "commands": [
               "gdh authoring check",
-              "gdh verify recommend",
-              "gdh verify done"
+              "gdh authoring check"
             ],
             "validationCommands": [
               "gdh authoring check",
-              "gdh verify done"
+              "gdh authoring check"
             ]
           }
         ]
@@ -1694,6 +1693,144 @@
           }
         ]
       }
+    },
+    {
+      "version": "0.19.0",
+      "releaseTag": "v0.19.0",
+      "migrationStatus": "required",
+      "summary": "v0.19.0 ships the bridge broker contract, authoring validator hooks and guidance, shared Markdown skill rendering, Claude project skills under `.claude/skills/gdh-*/SKILL.md`, and removal of the retired `/gdh-verify` policy surface. Managed targets need `gdh migrate --apply` because GDH_RULES_SCHEMA_VERSION moves 2 -> 3, GDH_AGENT_CONTRACT_VERSION moves 2 -> 3, GDH_GUIDANCE_INDEX_VERSION moves 2 -> 3, and GDH_GUIDANCE_UNIT_VERSION moves 9 -> 11.",
+      "releaseHighlights": {
+        "summary": "v0.19.0 ships the next authoring and agent-adapter hardening slice: the runtime package now has a target-local bridge broker contract, GDH authoring validation is wired into agent hooks and clearer skill guidance, shipped skills are generated from one shared Markdown definition set across Claude, Codex, and Cursor, and the retired `/gdh-verify` policy surface is removed. Managed targets need `gdh migrate --apply` after update because rules, guidance, and agent-contract surface versions moved.",
+        "operatorChanges": [
+          "**Runtime bridge broker contract added.** GDH now defines the target-local bridge broker identity, lifecycle, state, and ownership contract that later reconnectable CLI/MCP bridge clients build on. This release establishes the contract; later phases implement the full broker lifecycle and reconnecting clients.",
+          "**Authoring hooks route agents through GDH validation.** Generated Codex and Claude hook surfaces now run fast post-edit checks and final authoring checks using GDH authoring diagnostics, with skill guidance updated to distinguish validation evidence from LSP lifecycle visibility.",
+          "**Shipped skill rendering is shared and Markdown-native.** Claude, Codex, and Cursor skills now render from one `GDH_SKILL_DEFINITIONS` map. Current skill bodies use Markdown headings plus a neutral `GDH_MANAGED_AGENT_SKILL` marker instead of GDH-specific XML wrapper tags.",
+          "**Claude canonical skill path changed.** GDH now writes Claude project skills to `.claude/skills/gdh-*/SKILL.md`. Old GDH-managed `.claude/commands/gdh/*.md` command files are removed only when GDH can prove ownership; user-authored command files are preserved.",
+          "**Rules and migrate guidance tightened.** The default rules schema moves to version 3 to reflect the updated authoring-validation wording. Default prior-version rules are auto-refreshable; customized prior-version rules stay on manual review.",
+          "**`/gdh-verify` is retired.** Agents should use `/gdh-check` and the authoring-check path for code-validity evidence."
+        ]
+      },
+      "updateContract": {
+        "summary": "Managed targets need release-specific migration for v0.19.0 because rules, guidance, and agent contract surfaces changed. After self-update, run `gdh migrate --apply` to refresh generated guidance, agent instruction blocks, adapter skills, hooks, and default rules where safe. Customized prior-version rules require manual review.",
+        "steps": [
+          {
+            "id": "verify_post_update_status",
+            "kind": "mechanical",
+            "summary": "Run the standard post-update lifecycle check.",
+            "detail": "Start with `gdh status` so GDH can report whether the target needs rules, guidance, agent-contract, or adapter migration for v0.19.0.",
+            "commands": [
+              "gdh status"
+            ],
+            "validationCommands": [
+              "gdh status"
+            ]
+          },
+          {
+            "id": "apply_managed_surface_migration",
+            "kind": "mechanical",
+            "summary": "Refresh managed guidance, agent contract, adapter skills, hooks, and default rules.",
+            "detail": "Run `gdh migrate --apply` when status or migrate preview reports outdated guidance, agent contract, adapter skills, hooks, or default rules. This re-bakes Claude, Codex, and Cursor skills at the current pin and moves Claude GDH-owned skills to `.claude/skills/gdh-*/SKILL.md`.",
+            "commands": [
+              "gdh migrate --apply"
+            ],
+            "validationCommands": [
+              "gdh guidance status",
+              "gdh status",
+              "gdh verify drift"
+            ]
+          },
+          {
+            "id": "review_custom_rules_schema_v3",
+            "kind": "manual_review",
+            "summary": "Review customized prior-version rules before adopting schema version 3.",
+            "detail": "If GDH reports `rules_version_unrecognized`, inspect `.gdh/rules.yaml`. Default boilerplate should be refreshed by `gdh migrate --apply`; customized project rules must be ported into a schema version 3 file or explicitly accepted by the project owner.",
+            "commands": [
+              "gdh migrate"
+            ],
+            "validationCommands": [
+              "gdh status"
+            ]
+          },
+          {
+            "id": "use_authoring_check_for_validation_evidence",
+            "kind": "agent_reasoning",
+            "summary": "Use authoring-check diagnostics instead of readiness guesses.",
+            "detail": "After migration, agents should use `/gdh-check` or `gdh authoring check` for Godot code-validity evidence. LSP lifecycle commands explain availability and cleanup only; they are not proof that code is valid.",
+            "commands": [
+              "gdh authoring check --mode final"
+            ],
+            "validationCommands": [
+              "gdh authoring check --mode final"
+            ]
+          },
+          {
+            "id": "confirm_broker_contract_scope",
+            "kind": "agent_reasoning",
+            "summary": "Treat the bridge broker as a contract foundation, not a full reconnecting runtime yet.",
+            "detail": "v0.19.0 defines the target-local broker contract in GDH runtime code. Do not assume full broker lifecycle ownership or reconnectable bridge clients are available until later v1.16 phases ship them.",
+            "commands": [
+              "gdh status"
+            ],
+            "validationCommands": [
+              "gdh status"
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.19.1",
+      "releaseTag": "v0.19.1",
+      "migrationStatus": "no_op",
+      "summary": "v0.19.1 hardens supported-agent adapter behavior without changing managed schema or lifecycle surface versions. Claude adapter install no longer auto-registers GDH in Claude Code's single project `statusLine` slot, removes only the exact old GDH-managed statusLine entry during repair/update, and preserves custom statuslines. Generated gdh-update, gdh-status, and gdh-onboard skill guidance is clearer, but no release-scoped schema migration is required.",
+      "releaseHighlights": {
+        "summary": "v0.19.1 hardens supported-agent adapter behavior from dogfooding feedback. Claude project installs no longer auto-own Claude Code's single `statusLine` slot, so existing user or global statuslines stay visible. The release also tightens generated `/gdh-update`, `/gdh-status`, and `/gdh-onboard` skill guidance so agents have clearer operational context during update, status, and onboarding flows.",
+        "operatorChanges": [
+          "**Claude statusline ownership is non-destructive.** GDH still bakes `.claude/hooks/gdh-statusline.js` as an optional script, but adapter install no longer writes a project-level `statusLine` entry when one is absent. This prevents GDH from shadowing user/global Claude statuslines.",
+          "**Old GDH-managed statusline entries are cleaned up safely.** Adapter repair/update removes only the exact prior GDH-managed `statusLine` entry. Custom, user-owned, or tool-owned statuslines are preserved.",
+          "**Shipped skill guidance is clearer.** `/gdh-update` now emphasizes terminal-state follow-through, drift verification, explicit target handling, and stale MCP cleanup boundaries. `/gdh-status` and `/gdh-onboard` define the operational terms agents need instead of assuming project-specific vocabulary is already known."
+        ]
+      },
+      "updateContract": {
+        "summary": "No release-scoped managed schema migration is required for v0.19.1. After self-update, the adapter re-bake path applies the Claude statusline cleanup automatically: exact old GDH-managed statusLine ownership is removed, custom statuslines are preserved, and the optional GDH statusline script remains available for projects that explicitly opt into it.",
+        "steps": [
+          {
+            "id": "rebake_agent_adapters",
+            "kind": "mechanical",
+            "summary": "Re-bake supported-agent surfaces at the new GDH pin.",
+            "detail": "`gdh self-update` re-runs the adapter install path. If an agent needs to repair surfaces manually, run `gdh adapters install <target>` for repo-local agent surfaces.",
+            "commands": [
+              "gdh adapters install <target>"
+            ],
+            "validationCommands": [
+              "gdh adapters status <target>",
+              "gdh verify drift <target>"
+            ]
+          },
+          {
+            "id": "preserve_claude_statusline",
+            "kind": "agent_reasoning",
+            "summary": "Do not replace project or user Claude statuslines with GDH's optional statusline script.",
+            "detail": "Claude Code exposes one statusLine command slot. GDH no longer auto-registers its optional statusline script because a project-level entry can shadow a user's global/custom statusline. If a project deliberately wants the GDH hint, it can configure `.claude/hooks/gdh-statusline.js` itself.",
+            "commands": [],
+            "validationCommands": [
+              "gdh adapters status <target>"
+            ]
+          },
+          {
+            "id": "verify_custom_statusline_survived",
+            "kind": "mechanical",
+            "summary": "When a project had a custom Claude statusLine, confirm it remains configured.",
+            "detail": "Inspect `.claude/settings.json` only when statusline behavior is relevant. Custom statusLine entries should remain unchanged; only the exact prior GDH-managed command is removed.",
+            "commands": [
+              "gdh adapters status <target>"
+            ],
+            "validationCommands": [
+              "gdh adapters status <target>"
+            ]
+          }
+        ]
+      }
     }
   ]
 }

package/node_modules/@gdh/adapters/dist/authoring-hook-render.d.ts

@@ -0,0 +1,10 @@
+export declare const CLAUDE_AUTHORING_HOOK_RELATIVE_PATH = ".claude/hooks/gdh-authoring-guard.js";
+export declare const CODEX_AUTHORING_HOOK_RELATIVE_PATH = ".codex/hooks/gdh-authoring-guard.js";
+export declare const CLAUDE_AUTHORING_HOOK_COMMAND = "node -e \"const fs=require('fs'),path=require('path');let d=process.cwd();for(;;){const f=path.join(d,'.claude/hooks/gdh-authoring-guard.js');if(fs.existsSync(f)){require(f);break}const p=path.dirname(d);if(p===d)throw new Error('GDH Claude authoring hook not found');d=p}\"";
+export declare const CODEX_AUTHORING_HOOK_COMMAND = "node -e \"const fs=require('fs'),path=require('path');let d=process.cwd();for(;;){const f=path.join(d,'.codex/hooks/gdh-authoring-guard.js');if(fs.existsSync(f)){require(f);break}const p=path.dirname(d);if(p===d)throw new Error('GDH Codex authoring hook not found');d=p}\"";
+export declare function renderGdhAuthoringHook(input: {
+    readonly pinnedVersion: string;
+    readonly targetRelativePath: string;
+    readonly agent: "codex" | "claude";
+}): string;
+//# sourceMappingURL=authoring-hook-render.d.ts.map

package/node_modules/@gdh/adapters/dist/authoring-hook-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-hook-render.d.ts","sourceRoot":"","sources":["../src/authoring-hook-render.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mCAAmC,yCAAyC,CAAC;AAC1F,eAAO,MAAM,kCAAkC,wCAAwC,CAAC;AACxF,eAAO,MAAM,6BAA6B,uRAC4O,CAAC;AACvR,eAAO,MAAM,4BAA4B,qRAC2O,CAAC;AAErR,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;CACpC,GAAG,MAAM,CA+IT"}

package/node_modules/@gdh/adapters/dist/authoring-hook-render.js

@@ -0,0 +1,150 @@
+import { GDH_UPDATE_HOOK_VERSION } from "@gdh/core";
+export const CLAUDE_AUTHORING_HOOK_RELATIVE_PATH = ".claude/hooks/gdh-authoring-guard.js";
+export const CODEX_AUTHORING_HOOK_RELATIVE_PATH = ".codex/hooks/gdh-authoring-guard.js";
+export const CLAUDE_AUTHORING_HOOK_COMMAND = "node -e \"const fs=require('fs'),path=require('path');let d=process.cwd();for(;;){const f=path.join(d,'.claude/hooks/gdh-authoring-guard.js');if(fs.existsSync(f)){require(f);break}const p=path.dirname(d);if(p===d)throw new Error('GDH Claude authoring hook not found');d=p}\"";
+export const CODEX_AUTHORING_HOOK_COMMAND = "node -e \"const fs=require('fs'),path=require('path');let d=process.cwd();for(;;){const f=path.join(d,'.codex/hooks/gdh-authoring-guard.js');if(fs.existsSync(f)){require(f);break}const p=path.dirname(d);if(p===d)throw new Error('GDH Codex authoring hook not found');d=p}\"";
+export function renderGdhAuthoringHook(input) {
+    return [
+        "#!/usr/bin/env node",
+        `// gdh-hook-version: ${GDH_UPDATE_HOOK_VERSION}`,
+        "// GDH authoring validation hook. Dependency-free by design.",
+        `const PINNED_VERSION = ${JSON.stringify(input.pinnedVersion)};`,
+        `const TARGET_RELATIVE_PATH = ${JSON.stringify(input.targetRelativePath)};`,
+        `const AGENT = ${JSON.stringify(input.agent)};`,
+        "",
+        "const fs = require('fs');",
+        "const path = require('path');",
+        "const crypto = require('crypto');",
+        "const { spawnSync } = require('child_process');",
+        "",
+        "const AUTHORING_EXTENSIONS = new Set(['.gd', '.tscn', '.tres']);",
+        "let CURRENT_EVENT = '';",
+        "",
+        "main();",
+        "",
+        "function main() {",
+        "  const input = readHookInput();",
+        "  const targetRoot = resolveTargetRoot(input);",
+        "  const hookEvent = String(input.hook_event_name || '');",
+        "  CURRENT_EVENT = hookEvent;",
+        "  if (!targetRoot) return allow();",
+        "  if (hookEvent === 'PostToolUse' || hookEvent === 'FileChanged') return handlePostEdit(input, targetRoot);",
+        "  if (hookEvent === 'Stop') return handleStop(input, targetRoot);",
+        "  return allow();",
+        "}",
+        "",
+        "function handlePostEdit(input, targetRoot) {",
+        "  const changed = collectChangedFiles(input, targetRoot);",
+        "  const authoring = changed.filter(isAuthoringPath);",
+        "  if (authoring.length === 0) return allow();",
+        "  const state = readDirtyState(targetRoot);",
+        "  const dirtyFiles = unique([...(state.dirtyFiles || []), ...authoring]);",
+        "  writeDirtyState(targetRoot, { dirtyFiles, updatedAt: new Date().toISOString(), lastBlockedHash: state.lastBlockedHash || null });",
+        "  const scoped = authoring.filter((file) => AUTHORING_EXTENSIONS.has(path.extname(file).toLowerCase()));",
+        "  if (scoped.length === 0) return allow();",
+        "  const result = runGdh(targetRoot, ['authoring', 'check', '--target', targetRoot, '--mode', 'post-edit', '--format', 'compact', ...scoped.flatMap((file) => ['--changed', file])]);",
+        "  if (!result.ok || !/Completion allowed\\./.test(result.output)) {",
+        "    return block(`GDH post-edit authoring check needs attention.\\n${result.output || result.error || 'No check output.'}`);",
+        "  }",
+        "  return allow();",
+        "}",
+        "",
+        "function handleStop(input, targetRoot) {",
+        "  const state = readDirtyState(targetRoot);",
+        "  const dirtyFiles = unique(state.dirtyFiles || []);",
+        "  if (dirtyFiles.length === 0) return allow();",
+        "  const result = runGdh(targetRoot, ['authoring', 'check', '--target', targetRoot, '--mode', 'final', '--format', 'compact']);",
+        "  if (result.ok && /Completion allowed\\./.test(result.output)) {",
+        "    clearDirtyState(targetRoot);",
+        "    return allow();",
+        "  }",
+        "  const dirtyHash = hash(JSON.stringify(dirtyFiles));",
+        "  if (input.stop_hook_active === true && state.lastBlockedHash === dirtyHash) return allow();",
+        "  writeDirtyState(targetRoot, { dirtyFiles, updatedAt: new Date().toISOString(), lastBlockedHash: dirtyHash });",
+        "  return block(`GDH final authoring check is not clean for changed authoring files. Continue fixing before stopping.\\n${result.output || result.error || 'No check output.'}`);",
+        "}",
+        "",
+        "function runGdh(targetRoot, args) {",
+        "  const result = spawnSync('npx', ['-y', `@skillcap/gdh@${PINNED_VERSION}`, ...args], {",
+        "    cwd: targetRoot,",
+        "    encoding: 'utf8',",
+        "    windowsHide: true,",
+        "    timeout: 120000,",
+        "  });",
+        "  const output = `${result.stdout || ''}${result.stderr || ''}`.trim();",
+        "  return { ok: result.status === 0, output, error: result.error ? String(result.error.message || result.error) : '' };",
+        "}",
+        "",
+        "function collectChangedFiles(input, targetRoot) {",
+        "  const files = [];",
+        "  addFile(files, input.file_path, targetRoot);",
+        "  addFromToolPayload(files, input.tool_input, targetRoot);",
+        "  addFromToolPayload(files, input.tool_response, targetRoot);",
+        "  const command = input && input.tool_input && typeof input.tool_input.command === 'string' ? input.tool_input.command : '';",
+        "  for (const file of parsePatchFileNames(command)) addFile(files, file, targetRoot);",
+        "  return unique(files);",
+        "}",
+        "",
+        "function addFromToolPayload(files, payload, targetRoot) {",
+        "  if (!payload || typeof payload !== 'object') return;",
+        "  addFile(files, payload.file_path, targetRoot);",
+        "  addFile(files, payload.filePath, targetRoot);",
+        "  addFile(files, payload.path, targetRoot);",
+        "  if (Array.isArray(payload.file_paths)) for (const file of payload.file_paths) addFile(files, file, targetRoot);",
+        "  if (Array.isArray(payload.files)) for (const file of payload.files) addFile(files, file, targetRoot);",
+        "}",
+        "",
+        "function parsePatchFileNames(command) {",
+        "  const files = [];",
+        "  const pattern = /^\\*\\*\\* (?:Add|Update|Delete) File: (.+)$/gm;",
+        "  let match;",
+        "  while ((match = pattern.exec(command)) !== null) files.push(match[1].trim());",
+        "  return files;",
+        "}",
+        "",
+        "function addFile(files, value, targetRoot) {",
+        "  if (typeof value !== 'string' || value.trim() === '') return;",
+        "  const normalized = normalizeToTargetRelative(value.trim(), targetRoot);",
+        "  if (normalized) files.push(normalized);",
+        "}",
+        "",
+        "function normalizeToTargetRelative(value, targetRoot) {",
+        "  if (value.startsWith('res://')) return value.slice('res://'.length);",
+        "  const absolute = path.isAbsolute(value) ? path.resolve(value) : path.resolve(targetRoot, value);",
+        "  const relative = path.relative(targetRoot, absolute);",
+        "  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;",
+        "  return relative.split(path.sep).join('/');",
+        "}",
+        "",
+        "function isAuthoringPath(file) {",
+        "  if (file === 'project.godot' || file.endsWith('/project.godot')) return true;",
+        "  return AUTHORING_EXTENSIONS.has(path.extname(file).toLowerCase());",
+        "}",
+        "",
+        "function resolveTargetRoot(input) {",
+        "  const base = path.resolve(__dirname, '..', '..');",
+        "  const fromScript = path.resolve(base, TARGET_RELATIVE_PATH || '.');",
+        "  if (fs.existsSync(fromScript)) return fromScript;",
+        "  if (input && typeof input.cwd === 'string') return input.cwd;",
+        "  return process.cwd();",
+        "}",
+        "",
+        "function dirtyStatePath(targetRoot) { return path.join(targetRoot, '.gdh-state', 'agent-hooks', 'authoring-dirty.json'); }",
+        "function readDirtyState(targetRoot) { try { return JSON.parse(fs.readFileSync(dirtyStatePath(targetRoot), 'utf8')); } catch { return { dirtyFiles: [], lastBlockedHash: null }; } }",
+        "function writeDirtyState(targetRoot, state) { const file = dirtyStatePath(targetRoot); fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\\n`, 'utf8'); }",
+        "function clearDirtyState(targetRoot) { try { fs.rmSync(dirtyStatePath(targetRoot), { force: true }); } catch {} }",
+        "function unique(values) { return [...new Set(values.filter(Boolean))].sort(); }",
+        "function hash(value) { return crypto.createHash('sha256').update(value).digest('hex'); }",
+        "function readHookInput() { try { return JSON.parse(fs.readFileSync(0, 'utf8') || '{}'); } catch { return {}; } }",
+        "",
+        "function allow() { process.exit(0); }",
+        "function block(reason) {",
+        "  const payload = { decision: 'block', reason };",
+        "  if (AGENT === 'codex') payload.hookSpecificOutput = { hookEventName: CURRENT_EVENT, additionalContext: reason };",
+        "  process.stdout.write(`${JSON.stringify(payload)}\\n`);",
+        "  process.exit(0);",
+        "}",
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=authoring-hook-render.js.map

package/node_modules/@gdh/adapters/dist/authoring-hook-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-hook-render.js","sourceRoot":"","sources":["../src/authoring-hook-render.ts"],"names":[],"mappings":"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"}

package/node_modules/@gdh/adapters/dist/claude-settings-patch.d.ts

@@ -12,6 +12,7 @@ export declare const CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
  * command string.
  */
 export declare const GDH_SESSION_START_HOOK_COMMAND = "node .claude/hooks/gdh-check-update.js";
+export declare const GDH_AUTHORING_HOOK_COMMAND = "node -e \"const fs=require('fs'),path=require('path');let d=process.cwd();for(;;){const f=path.join(d,'.claude/hooks/gdh-authoring-guard.js');if(fs.existsSync(f)){require(f);break}const p=path.dirname(d);if(p===d)throw new Error('GDH Claude authoring hook not found');d=p}\"";
 /**
  * Patch-merge .claude/settings.json so the GDH SessionStart hook is
  * registered idempotently without clobbering sibling content.
@@ -38,21 +39,22 @@ export declare const GDH_SESSION_START_HOOK_COMMAND = "node .claude/hooks/gdh-ch
  */
 export declare function patchClaudeSettingsForGdhSessionStart(existingContent: string): string;
 /**
- * Patch-merge .claude/settings.json so the GDH statusline is registered ONLY
- * when no existing `statusLine` entry is configured (write-if-absent).
+ * Patch-merge .claude/settings.json so GDH does not own Claude's single
+ * statusLine slot automatically.
  *
- * Planner-lock #2 resolution (Plan 03) — per D-18:
- *   - If `settings.statusLine` is present as ANY truthy value, leave it
- *     untouched. GDH does not clobber a user-configured statusline; other
- *     tools (e.g. GSD) can own the slot, and UPD-02 silently no-ops for
- *     that target. The universal cross-adapter detection surface is MCP
- *     `_meta` (UPD-03), so a no-op here is acceptable degradation.
- *   - If `settings.statusLine` is `undefined` or `null`, register GDH's
- *     `{ type: "command", command: "node .claude/hooks/gdh-statusline.js" }`.
- *   - Preserves every sibling top-level key verbatim (hooks, env,
+ * Claude Code exposes one project `statusLine` command. Project settings can
+ * shadow user/global statusline configuration, so GDH must not create a
+ * project-level statusLine entry just to show update hints. The SessionStart
+ * hook, MCP `_meta`, and CLI banner are the non-destructive update surfaces.
+ *
+ * Migration behavior:
+ *   - If `settings.statusLine` is the exact old GDH-managed entry, remove it.
+ *     This lets existing targets fall back to user/global statusline behavior.
+ *   - If `settings.statusLine` is absent, null, or anything else, leave it
+ *     untouched. GDH does not compose or guess at other tools' commands.
+ *   - Preserve every sibling top-level key verbatim (hooks, env,
  *     permissions, etc.). Composes cleanly with
- *     `patchClaudeSettingsForGdhSessionStart` (idempotent + commutative,
- *     proven by the Task 1 Test J suite).
+ *     `patchClaudeSettingsForGdhSessionStart` and authoring hook patches.
  *
  * Input handling:
  *   - Empty string / whitespace-only → fresh `{}` base (GDH-only output).
@@ -71,4 +73,5 @@ export declare function patchClaudeSettingsForGdhSessionStart(existingContent: s
  * that both sides import from.
  */
 export declare function patchClaudeSettingsForGdhStatusline(existingContent: string): string;
+export declare function patchClaudeSettingsForGdhAuthoringHooks(existingContent: string): string;
 //# sourceMappingURL=claude-settings-patch.d.ts.map

package/node_modules/@gdh/adapters/dist/claude-settings-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-settings-patch.d.ts","sourceRoot":"","sources":["../src/claude-settings-patch.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,6BAA6B,0BAA0B,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,2CACD,CAAC;AA6C3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qCAAqC,CACnD,eAAe,EAAE,MAAM,GACtB,MAAM,CA4CR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,mCAAmC,CACjD,eAAe,EAAE,MAAM,GACtB,MAAM,CA6BR"}
+{"version":3,"file":"claude-settings-patch.d.ts","sourceRoot":"","sources":["../src/claude-settings-patch.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,6BAA6B,0BAA0B,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,2CAA2C,CAAC;AACvF,eAAO,MAAM,0BAA0B,uRAAgC,CAAC;AA8DxE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qCAAqC,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAuCrF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mCAAmC,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAQnF;AAeD,wBAAgB,uCAAuC,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CA2CvF"}