@skillcap/gdh 0.5.0 → 0.7.0

package/INSTALL-BUNDLE.json

@@ -1,5 +1,5 @@
 {
   "product": "GDH",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "installMode": "packaged_install"
 }

package/README.md

@@ -1,128 +1,111 @@
 # GDH
 
-GDH is a Godot-specific authoring and validation harness for agentic development.
+> Godot authoring and validation harness for AI agents
 
-It helps teams:
+[![npm](https://img.shields.io/npm/v/@skillcap/gdh)](https://www.npmjs.com/package/@skillcap/gdh)
+[![license](https://img.shields.io/github/license/Skillcap-Studio/gdh)](LICENSE)
 
-- detect the real Godot target inside a repo or monorepo
-- scaffold the minimal durable GDH project surface under `.gdh/`
-- configure supported agents against one canonical guidance chain
-- search and fetch official version-aware Godot docs through stable CLI and MCP surfaces with explicit provenance plus bounded machine-local cache fallback
-- run authoring and runtime validation through explicit, inspectable surfaces
-- make evidence-backed "done" decisions instead of trusting confidence alone
+GDH detects your Godot project, configures your AI agents, and gives them the context they need to author, validate, and verify Godot work with real evidence instead of guesswork.
 
-GDH is not a planning system, release orchestrator, or generic code-editing framework.
+![GDH setup demo](demo.gif)
 
-## Status
+## Install
 
-GDH now ships the current `0.5.0` release line and remains ready for broader internal use within the documented support contract.
+```sh
+npx -y @skillcap/gdh@0.7.0 setup
+```
 
-The current release line is `0.5.0` at the `broader_internal_release` stage.
+Replace `0.7.0` with the GDH version you want to pin this project to. `gdh setup` records the pinned version in `.gdh/project.yaml`; every managed surface generated from that config invokes GDH at that exact pinned version, so future sessions stay reproducible.
 
-That release-stage label applies only to the documented support window in [runtime-support-matrix.md](docs/development/runtime-support-matrix.md) and [runtime-release-readiness.md](docs/development/runtime-release-readiness.md). It is not a blanket claim that every Godot project shape is supported or that this implementation checkout should behave like a GDH-managed target repo.
+The full install and update contract lives in [install-and-update.md](docs/development/install-and-update.md).
 
-This repository is the GDH implementation repo. Here, the authoritative product truth is the source, tests, release artifacts, and `.planning/` surfaces in this checkout. Treat `gdh setup`, `gdh status`, and `/gdh-onboard` in this repo as product smoke-check paths only, not as the primary way to learn the state of GDH itself.
+## Requirements
 
-Release history is split intentionally:
+- **Node.js** ≥ 20 (per `package.json` engines)
+- **Godot** 4.4 through 4.6 stable — see [runtime-support-matrix.md](docs/development/runtime-support-matrix.md) for the full bounded support contract
+- **Host OS** macOS for the currently supported development environment
+- **Yarn 4** via `corepack` (required only for contributors working on the GDH implementation repo itself; end users invoking `npx @skillcap/gdh` do not need Yarn)
 
-- generated release history lives in [CHANGELOG.md](CHANGELOG.md)
-- curated operator-facing release notes live under [docs/releases/](docs/releases/README.md)
-- retained internal pre-public release history lives under [docs/releases/internal/](docs/releases/internal/README.md) and `internal/v...` tags
-- milestone archive history is tracked separately in `.planning/` and under `milestone/vX.Y` tags, not product release tags
+## Quick Start
 
-See:
+```sh
+# 1. Run setup in your Godot project
+npx -y @skillcap/gdh@0.7.0 setup
 
-- [STATE.md](.planning/STATE.md)
-- [ROADMAP.md](.planning/ROADMAP.md)
-- [docs/development/runtime-release-readiness.md](docs/development/runtime-release-readiness.md)
-- [docs/development/runtime-support-matrix.md](docs/development/runtime-support-matrix.md)
+# 2. Open your AI agent (Claude, Cursor, Codex) in the repo
 
-## Install
+# 3. Run the onboarding handoff
+/gdh-onboard
+```
 
-The install/setup flow below is for using GDH on another target repository.
+That's it. GDH handles detection, scaffolding, and agent configuration. The agent takes over from `/gdh-onboard`.
 
-If you are contributing to GDH itself in this repo, start from the contributor docs in [docs/development/install-and-update.md](docs/development/install-and-update.md), [docs/development/conventions.md](docs/development/conventions.md), and [.planning/](.planning/).
+## What GDH Does
 
-GDH is published to npm as `@skillcap/gdh`. The supported install path is to invoke it via `npx` at a pinned version so `gdh setup` can record that exact version in `.gdh/project.yaml` and every managed surface (MCP launcher, agent skills, hooks) runs at the same version.
+### Detects your Godot target
 
-```sh
-npx -y @skillcap/gdh@0.4.1 setup
-```
+Finds the Godot project inside your repo or monorepo automatically. Handles nested targets, worktrees, and non-obvious layouts.
 
-Replace `0.4.1` with the GDH version you want to pin this project to. `gdh setup` records the pinned version in `.gdh/project.yaml` as `gdh_version:`; every managed surface generated from that config invokes GDH at that exact pinned version, so future sessions stay reproducible.
+### Configures your AI agents
 
-The full install and update contract lives in [docs/development/install-and-update.md](docs/development/install-and-update.md).
+Scaffolds a minimal `.gdh/` surface and wires up agent-specific guidance so Claude, Cursor, and Codex know how to work with your project from the first session — all pinned to one canonical guidance chain.
 
-For the current shipped `0.4.1` line, the one supported public package target is `@skillcap/gdh`, and the supported operator-facing executable is `gdh`.
-The canonical public git-versus-npm boundary for maintainers lives in [docs/development/open-source-maintainer-contract.md](docs/development/open-source-maintainer-contract.md).
+### Searches Godot docs with version awareness
 
-After GDH is installed, the main human entrypoint is:
+Fetches and searches official Godot documentation through CLI and MCP surfaces, pinned to your project's engine version. Bounded machine-local cache, explicit provenance.
 
-```sh
-gdh setup
-```
+### Validates with evidence
 
-## The Setup Experience
+Runs authoring and runtime checks through inspectable surfaces. Agents get structured results they can reason about, not just pass/fail.
 
-`gdh setup` is the guided setup wizard for a GDH-managed target repository.
+### Signals completion with evidence
 
-It:
+Evidence-backed "done" decisions replace confidence-based guessing. Run records capture what happened; verification scenarios define what must be true.
 
-- detects the repo root from the current directory when possible
-- finds the Godot target, including nested targets inside monorepos
-- asks which supported agents to configure
-- applies the minimal GDH repo surface and agent reinforcement
-- installs the agent-specific `/gdh-onboard` handoff entrypoint for the selected agents
-- always ends with the exact next step to continue in an agent
+### What GDH does not do
 
-The intended flow is:
+GDH is not a general project planner, PR/release orchestrator, or generic codebase knowledge system. It does not manage non-Godot runtimes. Use it for Godot-specific authoring, validation, worktree/import handling, and evidence-backed done decisions — and hand the rest to tools built for those jobs.
 
-1. Install GDH.
-2. Run `gdh setup`.
-3. Open one of the configured agents in the repo.
-4. Run `/gdh-onboard`.
+## Core Concepts
 
-## What `/gdh-onboard` Should Do
+| Concept | What it is |
+|---------|-----------|
+| **Target** | The Godot project root or subproject GDH operates on |
+| **Run configuration** | How GDH launches a target |
+| **Verification scenario** | What GDH verifies once a target is running |
+| **Run record** | Structured evidence from one execution or verification run |
 
-`/gdh-onboard` is the agent-side handoff after setup on a GDH-managed target repository.
+## Daily Usage
 
-Its job is to:
+Normal usage happens through your AI agent, not by memorizing CLI commands.
 
-- inspect the GDH surfaces that setup created
-- confirm target readiness and current capability availability
-- review draft run configurations and verification scenarios
-- ask the human only for unresolved facts GDH could not infer safely
-- run the first safe readiness and validation checks
-- report what is ready, what is blocked, and what the next development step is
+1. Open your agent in the repo
+2. The agent uses GDH surfaces to check readiness, pick validation, run checks
+3. You intervene only for narrow decisions or missing environment input
 
-## Daily Usage
+The CLI exists for advanced operators, debugging, and automation. See [Advanced CLI Usage](docs/development/advanced-cli-usage.md).
 
-Normal usage should happen through an agent, not through humans memorizing raw GDH commands.
+## Documentation
 
-The expected daily loop is:
+- [Install and Update](docs/development/install-and-update.md) — alternative install modes, updating
+- [Advanced CLI Usage](docs/development/advanced-cli-usage.md) — raw CLI reference
+- [Runtime Support Matrix](docs/development/runtime-support-matrix.md) — what's supported today
+- [Runtime Release Readiness](docs/development/runtime-release-readiness.md) — current release stage
 
-1. The human opens the configured agent in the repo.
-2. The agent uses GDH surfaces to inspect readiness, choose validation, and run the right checks.
-3. The human intervenes only when GDH or the project needs a narrow decision or missing environment input.
+## Status
 
-The raw CLI still exists for advanced operators, debugging, and automation, but it is no longer the main README path.
+GDH now ships the current `0.7.0` release line and remains ready for broader internal use within the documented support contract. The current release line is `0.7.0` at the `broader_internal_release` stage.
 
-## Advanced Docs
+The release-stage label applies only to the documented support window in [runtime-support-matrix.md](docs/development/runtime-support-matrix.md) and [runtime-release-readiness.md](docs/development/runtime-release-readiness.md). It is not a blanket claim that every Godot project shape is supported or that this implementation checkout should behave like a GDH-managed target repo.
 
-Use these when you need deeper operational detail:
+This repository is the GDH implementation repo. Treat `gdh setup`, `gdh status`, and `/gdh-onboard` here as product smoke-check paths, not as the primary way to learn the state of GDH itself — authoritative product truth lives in the source, tests, release artifacts, and `.planning/` surfaces in this checkout.
 
-- [Install And Update](docs/development/install-and-update.md)
-- [Advanced CLI Usage](docs/development/advanced-cli-usage.md)
-- [Open-Source Maintainer Contract](docs/development/open-source-maintainer-contract.md)
-- [Runtime Support Matrix](docs/development/runtime-support-matrix.md)
-- [Runtime Release Readiness](docs/development/runtime-release-readiness.md)
+### Support
 
-## Core Concepts
+- **Issues:** [github.com/Skillcap-Studio/gdh/issues](https://github.com/Skillcap-Studio/gdh/issues) — reproducible bugs, concrete feature requests, documentation problems
+- **Contributing:** see [CONTRIBUTING.md](CONTRIBUTING.md) for workflow and commit policy
 
-- `target`: the Godot project root or subproject path GDH operates on
-- `run configuration`: how GDH launches a target
-- `verification scenario`: what GDH verifies once a target is running
-- `run record`: the structured evidence GDH keeps from one runtime execution or verification run
+This repo does not currently promise a dedicated public support channel for project-specific troubleshooting; keep issues focused and reproducible.
 
 ## Development
 
@@ -134,8 +117,6 @@ If you are working on the GDH implementation repo itself, use these contributor
 - [docs/development/open-source-maintainer-contract.md](docs/development/open-source-maintainer-contract.md)
 - [fixtures/README.md](fixtures/README.md)
 
-Release history now lives in the generated root [CHANGELOG.md](CHANGELOG.md). Curated human release notes live under [docs/releases/](docs/releases/README.md), and the canonical local maintainer release sequence lives in [docs/development/release-workflow.md](docs/development/release-workflow.md).
-
-When you are cutting a GDH release inside this repo with Claude, Codex, or Cursor, use `/gdh-release` so the agent loads the canonical release guidance and runs `corepack yarn check:public-release` before `release:apply`. Use `/gdh-migration-verify` for the dedicated migration-proof step before the final release gate and apply step. Use `/gdh-publish` only when you explicitly want the already-cut release published to npm; `/gdh-release` stops before npm publish.
+When cutting a GDH release in this repo with Claude, Codex, or Cursor, use `/gdh-release` so the agent loads the canonical release guidance and runs `corepack yarn check:public-release` before `release:apply`. Use `/gdh-migration-verify` for the dedicated migration-proof step before the final release gate. Use `/gdh-publish` only when you explicitly want an already-cut release published to npm.
 
-Contributor commits in this repo follow the Conventional Commit policy documented in [docs/development/conventions.md](docs/development/conventions.md). That doc is the canonical source for allowed types, scope guidance, and local hook setup.
+Release history lives in the generated root [CHANGELOG.md](CHANGELOG.md); curated release notes live under [docs/releases/](docs/releases/README.md).

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

@@ -0,0 +1,74 @@
+/**
+ * Relative path of the Claude Code per-project settings file in a managed
+ * target. This is the file GDH patches to register its SessionStart hook.
+ */
+export declare const CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
+/**
+ * Exact command literal GDH uses to invoke the SessionStart parent hook.
+ *
+ * Idempotency in `patchClaudeSettingsForGdhSessionStart` is gated on an exact
+ * match against this literal. Keep it in one place so the renderer, the
+ * settings patcher, and `gdh verify drift` all agree on the canonical
+ * command string.
+ */
+export declare const GDH_SESSION_START_HOOK_COMMAND = "node .claude/hooks/gdh-check-update.js";
+/**
+ * Patch-merge .claude/settings.json so the GDH SessionStart hook is
+ * registered idempotently without clobbering sibling content.
+ *
+ * Strategy A (locked by Plan 02): exact command-literal match.
+ *   - Parses `existingContent` as JSON. If empty / invalid / non-object,
+ *     starts from a fresh `{}` — treating corruption as "last writer wins"
+ *     for this narrow hook entry.
+ *   - Ensures `hooks.SessionStart` exists as an array.
+ *   - Appends the GDH entry ONLY if no group already contains a command
+ *     whose `command` string equals `GDH_SESSION_START_HOOK_COMMAND`.
+ *   - Preserves every other top-level key (e.g. env, and the sibling
+ *     status-line key which Plan 03 will handle separately),
+ *     preserves every non-SessionStart hook family (PreToolUse, PostToolUse),
+ *     and preserves every sibling SessionStart entry (e.g. GSD's hook).
+ *
+ * Output: 2-space-indented JSON ending in a trailing newline. Passes
+ * `JSON.parse` cleanly. Re-applying the function to its own output is
+ * byte-identical to the first application (idempotency proof).
+ *
+ * This function DOES NOT read or write any status-line key — planner-lock #2
+ * is resolved separately in Plan 03. Keeping the Plan 02 blast radius tight
+ * to UPD-01 (SessionStart hook only).
+ */
+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).
+ *
+ * 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,
+ *     permissions, etc.). Composes cleanly with
+ *     `patchClaudeSettingsForGdhSessionStart` (idempotent + commutative,
+ *     proven by the Task 1 Test J suite).
+ *
+ * Input handling:
+ *   - Empty string / whitespace-only → fresh `{}` base (GDH-only output).
+ *   - Invalid JSON → fresh `{}` base (silent-failure, matches
+ *     `patchClaudeSettingsForGdhSessionStart` posture).
+ *   - Non-object JSON (e.g. `"hello"`, `[1, 2]`) → fresh `{}` base.
+ *
+ * Output: 2-space-indented JSON ending in a trailing newline. Passes
+ * `JSON.parse` cleanly. Re-applying this function to its own output is
+ * byte-identical (idempotency — Tests C, D, F).
+ *
+ * Circular-import note: `claude-statusline-render.ts` (source of
+ * `GDH_STATUSLINE_COMMAND`) imports ONLY `@gdh/core` — it MUST NOT import
+ * from this file. If a future change introduces a circular edge, extract
+ * `GDH_STATUSLINE_COMMAND` into a third module (e.g. claude-surface-constants.ts)
+ * that both sides import from.
+ */
+export declare function patchClaudeSettingsForGdhStatusline(existingContent: string): string;
+//# sourceMappingURL=claude-settings-patch.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,158 @@
+import { GDH_STATUSLINE_COMMAND } from "./claude-statusline-render.js";
+/**
+ * Relative path of the Claude Code per-project settings file in a managed
+ * target. This is the file GDH patches to register its SessionStart hook.
+ */
+export const CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
+/**
+ * Exact command literal GDH uses to invoke the SessionStart parent hook.
+ *
+ * Idempotency in `patchClaudeSettingsForGdhSessionStart` is gated on an exact
+ * match against this literal. Keep it in one place so the renderer, the
+ * settings patcher, and `gdh verify drift` all agree on the canonical
+ * command string.
+ */
+export const GDH_SESSION_START_HOOK_COMMAND = "node .claude/hooks/gdh-check-update.js";
+function hasGdhSessionStartHook(sessionStart) {
+    for (const group of sessionStart) {
+        if (!group || !Array.isArray(group.hooks))
+            continue;
+        for (const h of group.hooks) {
+            if (h !== null &&
+                typeof h === "object" &&
+                h.type === "command" &&
+                h.command === GDH_SESSION_START_HOOK_COMMAND) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Patch-merge .claude/settings.json so the GDH SessionStart hook is
+ * registered idempotently without clobbering sibling content.
+ *
+ * Strategy A (locked by Plan 02): exact command-literal match.
+ *   - Parses `existingContent` as JSON. If empty / invalid / non-object,
+ *     starts from a fresh `{}` — treating corruption as "last writer wins"
+ *     for this narrow hook entry.
+ *   - Ensures `hooks.SessionStart` exists as an array.
+ *   - Appends the GDH entry ONLY if no group already contains a command
+ *     whose `command` string equals `GDH_SESSION_START_HOOK_COMMAND`.
+ *   - Preserves every other top-level key (e.g. env, and the sibling
+ *     status-line key which Plan 03 will handle separately),
+ *     preserves every non-SessionStart hook family (PreToolUse, PostToolUse),
+ *     and preserves every sibling SessionStart entry (e.g. GSD's hook).
+ *
+ * Output: 2-space-indented JSON ending in a trailing newline. Passes
+ * `JSON.parse` cleanly. Re-applying the function to its own output is
+ * byte-identical to the first application (idempotency proof).
+ *
+ * This function DOES NOT read or write any status-line key — planner-lock #2
+ * is resolved separately in Plan 03. Keeping the Plan 02 blast radius tight
+ * to UPD-01 (SessionStart hook only).
+ */
+export function patchClaudeSettingsForGdhSessionStart(existingContent) {
+    let settings;
+    try {
+        const trimmed = existingContent.trim();
+        if (trimmed.length === 0) {
+            settings = {};
+        }
+        else {
+            const parsed = JSON.parse(trimmed);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                settings = parsed;
+            }
+            else {
+                settings = {};
+            }
+        }
+    }
+    catch {
+        settings = {};
+    }
+    const existingHooks = settings.hooks;
+    const hooks = existingHooks !== null && typeof existingHooks === "object"
+        ? { ...existingHooks }
+        : {};
+    const existingSessionStart = hooks.SessionStart;
+    const sessionStart = Array.isArray(existingSessionStart)
+        ? [...existingSessionStart]
+        : [];
+    if (!hasGdhSessionStartHook(sessionStart)) {
+        sessionStart.push({
+            hooks: [
+                { type: "command", command: GDH_SESSION_START_HOOK_COMMAND },
+            ],
+        });
+    }
+    hooks.SessionStart = sessionStart;
+    settings.hooks = hooks;
+    return `${JSON.stringify(settings, null, 2)}\n`;
+}
+/**
+ * Patch-merge .claude/settings.json so the GDH statusline is registered ONLY
+ * when no existing `statusLine` entry is configured (write-if-absent).
+ *
+ * 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,
+ *     permissions, etc.). Composes cleanly with
+ *     `patchClaudeSettingsForGdhSessionStart` (idempotent + commutative,
+ *     proven by the Task 1 Test J suite).
+ *
+ * Input handling:
+ *   - Empty string / whitespace-only → fresh `{}` base (GDH-only output).
+ *   - Invalid JSON → fresh `{}` base (silent-failure, matches
+ *     `patchClaudeSettingsForGdhSessionStart` posture).
+ *   - Non-object JSON (e.g. `"hello"`, `[1, 2]`) → fresh `{}` base.
+ *
+ * Output: 2-space-indented JSON ending in a trailing newline. Passes
+ * `JSON.parse` cleanly. Re-applying this function to its own output is
+ * byte-identical (idempotency — Tests C, D, F).
+ *
+ * Circular-import note: `claude-statusline-render.ts` (source of
+ * `GDH_STATUSLINE_COMMAND`) imports ONLY `@gdh/core` — it MUST NOT import
+ * from this file. If a future change introduces a circular edge, extract
+ * `GDH_STATUSLINE_COMMAND` into a third module (e.g. claude-surface-constants.ts)
+ * that both sides import from.
+ */
+export function patchClaudeSettingsForGdhStatusline(existingContent) {
+    let settings;
+    try {
+        const trimmed = existingContent.trim();
+        if (trimmed.length === 0) {
+            settings = {};
+        }
+        else {
+            const parsed = JSON.parse(trimmed);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                settings = parsed;
+            }
+            else {
+                settings = {};
+            }
+        }
+    }
+    catch {
+        settings = {};
+    }
+    // Write-if-absent semantics: any existing truthy statusLine value is
+    // preserved verbatim (D-18 — another tool already owns the slot, we
+    // silently no-op for UPD-02 on this target).
+    if (settings.statusLine === undefined || settings.statusLine === null) {
+        settings.statusLine = {
+            type: "command",
+            command: GDH_STATUSLINE_COMMAND,
+        };
+    }
+    return `${JSON.stringify(settings, null, 2)}\n`;
+}
+//# sourceMappingURL=claude-settings-patch.js.map

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

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

package/node_modules/@gdh/adapters/dist/claude-statusline-render.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Relative path of the managed Claude statusline renderer script. This is
+ * the .js file Claude Code invokes on every prompt render when the managed
+ * target has registered `statusLine.command = "node .claude/hooks/gdh-statusline.js"`
+ * in its `.claude/settings.json`.
+ */
+export declare const CLAUDE_STATUSLINE_RELATIVE_PATH = ".claude/hooks/gdh-statusline.js";
+/**
+ * Exact command literal GDH uses to register its statusline in
+ * `.claude/settings.json`.
+ *
+ * `patchClaudeSettingsForGdhStatusline` (in claude-settings-patch.ts) imports
+ * this constant and writes it into the `statusLine.command` field ONLY when
+ * the target has no pre-existing `statusLine` registration (write-if-absent
+ * policy — planner-lock #2 resolution per D-18). If another tool already owns
+ * the slot, GDH leaves it untouched and UPD-02 silently no-ops on that repo;
+ * the universal cross-adapter detection surface is MCP `_meta` (UPD-03).
+ */
+export declare const GDH_STATUSLINE_COMMAND = "node .claude/hooks/gdh-statusline.js";
+/**
+ * Render the Claude statusline source that will be baked into a managed
+ * Claude target at the given pinned GDH version.
+ *
+ * The returned string is written verbatim to `.claude/hooks/gdh-statusline.js`
+ * by the adapter install pipeline. At runtime, Claude Code invokes the
+ * rendered script (when `statusLine.command` points at it — see D-18 /
+ * planner-lock #2) on every prompt render; the script reads the shared
+ * cache at `~/.cache/gdh/update-check.json` and prints the yellow
+ * `⬆ /gdh-update │ ` indicator when `cache.updateAvailable` is truthy.
+ *
+ * Invariants enforced by this renderer (see 11-03-PLAN):
+ *   - shebang on line 1; a hook-version marker on line 2 for drift detection
+ *   - cache path literal `path.join(homeDir, '.cache', 'gdh', 'update-check.json')`
+ *   - yellow ANSI arrow + `/gdh-update` hint + trailing ` │ ` separator (Pattern S5)
+ *   - silent-failure on every I/O + parse op (try/catch) — D-06
+ *   - output goes to `process.stdout` (Claude Code's statusline convention)
+ *   - no drift-scanning branch (GSD-only surface; out of UPD-02 scope per D-18)
+ *   - no legacy-prefix literal anywhere in emitted content
+ *
+ * The `_pinnedVersion` parameter is accepted for API symmetry with the hook
+ * and worker renderers. The statusline body does NOT consume it — the emitted
+ * script reads the cache whose `pinned` field was baked at the worker-level
+ * pin and doesn't need re-threading. If a future plan decides to bake a
+ * version-specific hint format into the statusline, this signature is ready.
+ *
+ * The baked script is deliberately dependency-free — it imports only Node
+ * built-ins and does NOT resolve @gdh/core at runtime. Every string in the
+ * output is literal JavaScript.
+ */
+export declare function renderClaudeUpdateStatusline(_pinnedVersion?: string): string;
+//# sourceMappingURL=claude-statusline-render.d.ts.map

package/node_modules/@gdh/adapters/dist/claude-statusline-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-statusline-render.d.ts","sourceRoot":"","sources":["../src/claude-statusline-render.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,oCACT,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,yCAAyC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,4BAA4B,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CA4B5E"}

package/node_modules/@gdh/adapters/dist/claude-statusline-render.js

@@ -0,0 +1,80 @@
+import { GDH_UPDATE_HOOK_VERSION } from "@gdh/core";
+/**
+ * Relative path of the managed Claude statusline renderer script. This is
+ * the .js file Claude Code invokes on every prompt render when the managed
+ * target has registered `statusLine.command = "node .claude/hooks/gdh-statusline.js"`
+ * in its `.claude/settings.json`.
+ */
+export const CLAUDE_STATUSLINE_RELATIVE_PATH = ".claude/hooks/gdh-statusline.js";
+/**
+ * Exact command literal GDH uses to register its statusline in
+ * `.claude/settings.json`.
+ *
+ * `patchClaudeSettingsForGdhStatusline` (in claude-settings-patch.ts) imports
+ * this constant and writes it into the `statusLine.command` field ONLY when
+ * the target has no pre-existing `statusLine` registration (write-if-absent
+ * policy — planner-lock #2 resolution per D-18). If another tool already owns
+ * the slot, GDH leaves it untouched and UPD-02 silently no-ops on that repo;
+ * the universal cross-adapter detection surface is MCP `_meta` (UPD-03).
+ */
+export const GDH_STATUSLINE_COMMAND = "node .claude/hooks/gdh-statusline.js";
+/**
+ * Render the Claude statusline source that will be baked into a managed
+ * Claude target at the given pinned GDH version.
+ *
+ * The returned string is written verbatim to `.claude/hooks/gdh-statusline.js`
+ * by the adapter install pipeline. At runtime, Claude Code invokes the
+ * rendered script (when `statusLine.command` points at it — see D-18 /
+ * planner-lock #2) on every prompt render; the script reads the shared
+ * cache at `~/.cache/gdh/update-check.json` and prints the yellow
+ * `⬆ /gdh-update │ ` indicator when `cache.updateAvailable` is truthy.
+ *
+ * Invariants enforced by this renderer (see 11-03-PLAN):
+ *   - shebang on line 1; a hook-version marker on line 2 for drift detection
+ *   - cache path literal `path.join(homeDir, '.cache', 'gdh', 'update-check.json')`
+ *   - yellow ANSI arrow + `/gdh-update` hint + trailing ` │ ` separator (Pattern S5)
+ *   - silent-failure on every I/O + parse op (try/catch) — D-06
+ *   - output goes to `process.stdout` (Claude Code's statusline convention)
+ *   - no drift-scanning branch (GSD-only surface; out of UPD-02 scope per D-18)
+ *   - no legacy-prefix literal anywhere in emitted content
+ *
+ * The `_pinnedVersion` parameter is accepted for API symmetry with the hook
+ * and worker renderers. The statusline body does NOT consume it — the emitted
+ * script reads the cache whose `pinned` field was baked at the worker-level
+ * pin and doesn't need re-threading. If a future plan decides to bake a
+ * version-specific hint format into the statusline, this signature is ready.
+ *
+ * The baked script is deliberately dependency-free — it imports only Node
+ * built-ins and does NOT resolve @gdh/core at runtime. Every string in the
+ * output is literal JavaScript.
+ */
+export function renderClaudeUpdateStatusline(_pinnedVersion) {
+    return [
+        "#!/usr/bin/env node",
+        `// gdh-hook-version: ${GDH_UPDATE_HOOK_VERSION}`,
+        "// Claude statusline: emits an upgrade hint when ~/.cache/gdh/update-check.json reports stale.",
+        "// Cache written by .claude/hooks/gdh-check-update-worker.js on SessionStart (UPD-01).",
+        "// Silent offline degrade per D-06 — missing/corrupt cache writes the empty string.",
+        "",
+        "const fs = require('fs');",
+        "const path = require('path');",
+        "const os = require('os');",
+        "",
+        "const homeDir = os.homedir();",
+        "const cacheFile = path.join(homeDir, '.cache', 'gdh', 'update-check.json');",
+        "",
+        "let gdhUpdate = '';",
+        "if (fs.existsSync(cacheFile)) {",
+        "  try {",
+        "    const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));",
+        "    if (cache && cache.updateAvailable) {",
+        "      gdhUpdate = '\\x1b[33m⬆ /gdh-update\\x1b[0m │ ';",
+        "    }",
+        "  } catch (e) {}",
+        "}",
+        "",
+        "process.stdout.write(gdhUpdate);",
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=claude-statusline-render.js.map

package/node_modules/@gdh/adapters/dist/claude-statusline-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-statusline-render.js","sourceRoot":"","sources":["../src/claude-statusline-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAC1C,iCAAiC,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,sCAAsC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,4BAA4B,CAAC,cAAuB;IAClE,OAAO;QACL,qBAAqB;QACrB,wBAAwB,uBAAuB,EAAE;QACjD,gGAAgG;QAChG,wFAAwF;QACxF,qFAAqF;QACrF,EAAE;QACF,2BAA2B;QAC3B,+BAA+B;QAC/B,2BAA2B;QAC3B,EAAE;QACF,+BAA+B;QAC/B,6EAA6E;QAC7E,EAAE;QACF,qBAAqB;QACrB,iCAAiC;QACjC,SAAS;QACT,mEAAmE;QACnE,2CAA2C;QAC3C,wDAAwD;QACxD,OAAO;QACP,kBAAkB;QAClB,GAAG;QACH,EAAE;QACF,kCAAkC;QAClC,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,35 @@
+/**
+ * Relative path of the managed Claude SessionStart parent hook script.
+ * This is the .js file Claude Code invokes when a session opens on a
+ * GDH-managed target; it spawns the worker that refreshes the update cache.
+ */
+export declare const CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH = ".claude/hooks/gdh-check-update.js";
+/**
+ * Relative path of the managed Claude background worker script the parent
+ * hook spawns. The worker performs the HTTPS probe and writes the cache.
+ */
+export declare const CLAUDE_CHECK_UPDATE_WORKER_RELATIVE_PATH = ".claude/hooks/gdh-check-update-worker.js";
+/**
+ * Render the Claude SessionStart parent hook source that will be baked into
+ * a managed Claude target at the given pinned GDH version.
+ *
+ * The returned string is written verbatim to
+ * `.claude/hooks/gdh-check-update.js` by the adapter install pipeline.
+ *
+ * Invariants enforced by this renderer (see 11-02-PLAN):
+ *   - shebang on line 1; a hook-version marker on line 2 for drift detection
+ *   - dev-mode short-circuit on GDH_DEV_REPO runs BEFORE spawn()
+ *   - spawn uses detached:true + child.unref() + windowsHide:true + stdio:'ignore'
+ *   - pinned version flows to the worker via GDH_PINNED_VERSION env var
+ *   - cache file path flows to the worker via GDH_CACHE_FILE env var
+ *   - cache dir (~/.cache/gdh/) is created with fs.mkdirSync recursive:true
+ *
+ * The body wraps everything after the requires in an IIFE so `return` exits
+ * cleanly (Node's CommonJS module body does not allow top-level return).
+ *
+ * The baked script is deliberately dependency-free — it imports only Node
+ * built-ins and does NOT resolve @gdh/core at runtime. Every string in the
+ * output is literal JavaScript.
+ */
+export declare function renderClaudeCheckUpdateHook(pinnedVersion: string): string;
+//# sourceMappingURL=claude-update-hook-render.d.ts.map