@skillcap/gdh 0.23.0 → 0.25.0

package/INSTALL-BUNDLE.json

@@ -1,5 +1,5 @@
 {
   "product": "GDH",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "installMode": "packaged_install"
 }

package/RELEASE-SPAN-UPDATE-CONTRACTS.json

@@ -2492,6 +2492,128 @@
           }
         ]
       }
+    },
+    {
+      "version": "0.24.0",
+      "releaseTag": "v0.24.0",
+      "migrationStatus": "required",
+      "summary": "v0.24.0 ships v1.18 Migration Chain Integrity. Five managed-surface version constants bump (GDH_AGENT_CONTRACT_VERSION 8 -> 9, GDH_GUIDANCE_INDEX_VERSION 4 -> 5, GDH_GUIDANCE_UNIT_VERSION 17 -> 18, GDH_UPDATE_HOOK_VERSION 5 -> 6, GDH_RUNTIME_BRIDGE_SURFACE_VERSION 11 -> 12). The migration registry adds entry s3c8_to_s3c9_register_runtime_bridge_autoload — a class-3 project-native register_autoload op that writes the GDHBridge autoload entry into project.godot deterministically, replacing the pre-v0.24 manual editor plugin-enable detour the chain matrix flagged as compatibility_degraded.",
+      "releaseHighlights": {
+        "summary": "v0.24.0 ships the v1.18 Migration Chain Integrity milestone. GDH now guarantees that every supported version listed in `docs/product/SUPPORTED-VERSIONS.md` reaches HEAD through `gdh self-update` without manual editor intervention. The release adds a falsifiable five-condition `release:apply` gate (registry completeness, chain matrix, corpus parity, goldens, migration-verify outcome `pass`), a typed managed-surface drift manifest with module-load `assertClassRegistered` guards, deterministic GDHBridge autoload registration during install/repair/self-update, a single-direction migration registry with paired golden fixtures, durable backup with crash-resilient restore, render-inventory orphan sweeping, and a `bumpAndRebakePin` 12-step orchestrator that composes all of the above.",
+        "operatorChanges": [
+          "**Deterministic GDHBridge autoload registration.** `gdh setup`, `gdh self-update`, and `gdh migrate --apply` now write the GDHBridge autoload entry into `project.godot` directly. Pre-v0.24, agents driving self-update had to instruct the operator to open the Godot editor and enable the GDH Runtime Bridge plugin so it could register the autoload itself. The chain matrix flagged that detour as `compatibility_degraded`; v0.24 closes it as a class-3 project-native `register_autoload` op on the v1.18 manifest allowlist.",
+          "**Migration chain matrix.** `npm run test:migration-chain` exercises every supported version (v0.18.0 through v0.23.0) end-to-end against HEAD via the installed tarball. `release:apply` invokes the matrix in-process and refuses to tag on non-zero exit.",
+          "**Five-condition release-apply gate.** `corepack yarn release:apply` enforces five machine-verifiable conditions before tagging: registry completeness (every `surfaceVersionChange` has a bracketing `MIGRATION_REGISTRY_ENTRIES` entry), chain matrix exit 0, corpus parity (`SUPPORTED-VERSIONS.md` rows match `tests/fixtures/migration-corpus/v<version>/` directories), goldens exit 0, and migration-verify outcome `pass`. There is no env-flag bypass, no `--force`, no skip-attestation file.",
+          "**Managed surface drift classification.** `GDH_MANAGED_SURFACE_CLASSES` from `@gdh/core` is the typed source of truth for the three drift classes (deterministic / user-data / project-native). Every managed-surface renderer carries a module-load `assertClassRegistered` guard that aborts the install pipeline if the manifest and a renderer drift.",
+          "**Local pre-commit and pre-push hooks.** `corepack yarn hooks:install` installs simple-git-hooks. Pre-commit catches schema-affecting diffs without paired migration entries and goldens; pre-push runs the adjacent star-case chain test plus all goldens. Hooks are bypass-able by `git commit --no-verify` and `git push --no-verify` — these are git-level escapes that no hook framework can prevent.",
+          "**Maintainer release skills.** `/gdh-dev:release`, `/gdh-dev:migration-verify`, and `/gdh-dev:publish` (Claude) and the Codex/Cursor equivalents now own the end-to-end release flow. `/gdh-dev:migration-verify` is a thin wrapper around `node scripts/release-lib/migration-verify.mjs` and consumes its locked JSON outcome contract.",
+          "**Durable backup.** `bumpAndRebakePin` step 5 writes a directory-level durable backup at `.gdh-state/backup/` via the staged-rename strategy (`.gdh-state/backup.new/` → atomic `fs.rename`). Restore is byte-equal round-trip; user-edit drift is detected by absence of any KNOWN_GDH_MARKERS and persisted in the manifest's `preservation_notes`.",
+          "**Render-inventory orphan sweeping.** `bumpAndRebakePin` writes `.gdh-state/render-inventory.json` after each successful re-bake; the next run computes set-diff against the previous inventory and deletes orphaned managed files. Symlink-safe (`fs.lstat` existence probe + `fs.rm` unlink semantics) and path-traversal-gated.",
+          "**Migration-verifier JSON outcome contract.** `scripts/release-lib/migration-verify.mjs` returns one of `pass | blocked | incomplete` over six conditions (artifacts, registry completeness, release-note/manifest/verification consistency, corpus parity, chain matrix, goldens). Both `/gdh-dev:migration-verify` and `release:apply` consume the same JSON; `release:apply` passes pre-computed chain + goldens evidence so the helper does not double-spawn."
+        ]
+      },
+      "updateContract": {
+        "summary": "Managed targets need release-specific migration for v0.24.0 because five managed-surface version constants bumped and the migration registry now writes the GDHBridge autoload entry into project.godot deterministically. After self-update, run gdh migrate --apply, then validate adapter status, drift, and the deterministic autoload registration.",
+        "steps": [
+          {
+            "id": "self_update_runtime_workflow_package",
+            "kind": "mechanical",
+            "summary": "Install the v0.24.0 GDH package.",
+            "detail": "Run gdh self-update so the new managed surface contract versions and the s3c8_to_s3c9_register_runtime_bridge_autoload registry entry are available to the host.",
+            "commands": [
+              "gdh self-update --apply"
+            ],
+            "validationCommands": [
+              "gdh status"
+            ]
+          },
+          {
+            "id": "rebake_v118_managed_surfaces",
+            "kind": "mechanical",
+            "summary": "Re-bake managed AGENTS.md, guidance, and hook surfaces; register the GDHBridge autoload in project.godot.",
+            "detail": "Run gdh migrate --apply so agent contract version 9 writes the new AGENTS.md contract block, guidance index version 5 and unit version 18 write the refreshed guidance, hook version 6 writes managed hook scripts, and the v1.18 register_autoload op writes the GDHBridge autoload entry into project.godot if it is missing.",
+            "commands": [
+              "gdh migrate --apply"
+            ],
+            "validationCommands": [
+              "gdh adapters status",
+              "gdh verify drift",
+              "gdh status"
+            ]
+          },
+          {
+            "id": "verify_runtime_bridge_autoload_registered",
+            "kind": "agent_reasoning",
+            "summary": "Confirm the GDHBridge autoload is registered deterministically in project.godot.",
+            "detail": "Open project.godot and confirm an `[autoload]` section contains `GDHBridge=\"*res://addons/gdh_bridge/runtime/gdh_runtime_bridge.gd\"`. Pre-v0.24 targets that relied on the manual editor plugin-enable detour pick up the entry automatically during gdh migrate --apply. No editor session is required.",
+            "commands": [
+              "gdh status"
+            ],
+            "validationCommands": [
+              "gdh status",
+              "gdh authoring check --mode final"
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.25.0",
+      "releaseTag": "v0.25.0",
+      "migrationStatus": "required",
+      "summary": "v0.25.0 ships v1.19 Target Surface Containment. Four managed-surface version constants bump (GDH_AGENT_CONTRACT_VERSION 9 -> 10, GDH_GUIDANCE_INDEX_VERSION 5 -> 6, GDH_GUIDANCE_UNIT_VERSION 18 -> 19, GDH_UPDATE_HOOK_VERSION 6 -> 7). Existing managed targets need deterministic re-bake so generated guidance moves under .gdh/guidance, onboarding lives in generated skills, validation check skills are retired, and managed hooks/statusline outputs refresh from template assets. No new class-2 or class-3 migration registry entry is introduced.",
+      "releaseHighlights": {
+        "summary": "v0.25.0 ships the v1.19 Target Surface Containment milestone. GDH no longer generates target-project guidance under `docs/agent/`; managed guidance now lives under `.gdh/guidance/`, workflow instructions live inside generated `gdh-*` skills, validation check skills are retired in favor of hooks/MCP/CLI evidence, and generated renderer bodies now come from tracked template assets instead of large inline strings. The release also contains maintainer safety fixes: setup/tests no longer write developer-global MCP or npm state, test runs block host Godot discovery by default, and the default pre-push hook runs only the cheap migration-golden guard.",
+        "operatorChanges": [
+          "**Generated guidance is contained under `.gdh/guidance/`.** Managed target projects receive `.gdh/guidance/README.md` and the deeper guidance units there. `docs/agent/` is no longer a generated target-project surface, so target project docs do not absorb GDH-owned operating manuals as project truth.",
+          "**Onboarding is a skill.** The generated onboarding workflow now lives in `gdh-onboard` for Claude, Codex, and Cursor instead of a loose `00-gdh-onboarding.md` guidance document.",
+          "**Validation check skills are retired.** GDH no longer ships generated `gdh-check` skills as instruction surfaces. Authoring evidence remains available through managed hooks, MCP/CLI status, and explicit `gdh authoring check` commands.",
+          "**Managed renderers use template assets.** Guidance and hook/statusline renderer bodies are read from tracked `.tpl` assets during build/package assembly, which makes generated output easier to review and keeps source files out of giant string-literal drift.",
+          "**Maintainer setup and tests are contained.** GDH development tests now use repo/test-local config homes for MCP and npm package flows, and the default integration environment disables host Godot discovery/spawning unless a test opts in.",
+          "**Release pre-push is cheaper.** The repo pre-push hook runs migration goldens only. The full migration chain remains enforced by `release:apply`, where it has the correct release-version context."
+        ]
+      },
+      "updateContract": {
+        "summary": "Managed targets need deterministic re-bake for v0.25.0 because agent contract, guidance index, guidance unit, and update-hook surface versions changed. After self-update, run gdh migrate --apply, then validate adapter status, drift, and lifecycle health.",
+        "steps": [
+          {
+            "id": "self_update_target_surface_containment_package",
+            "kind": "mechanical",
+            "summary": "Install the v0.25.0 GDH package.",
+            "detail": "Run gdh self-update so the v0.25.0 renderers, template assets, managed-surface versions, and cleanup behavior are available to the host.",
+            "commands": [
+              "gdh self-update --apply"
+            ],
+            "validationCommands": [
+              "gdh status"
+            ]
+          },
+          {
+            "id": "rebake_v119_managed_surfaces",
+            "kind": "mechanical",
+            "summary": "Re-bake managed AGENTS.md, skills, guidance, and hooks.",
+            "detail": "Run gdh migrate --apply so agent contract version 10 refreshes the managed AGENTS.md block and generated skills, guidance index version 6 and unit version 19 write `.gdh/guidance/`, hook version 7 refreshes hook/statusline outputs, and render-inventory cleanup removes stale GDH-owned generated guidance outside `.gdh`.",
+            "commands": [
+              "gdh migrate --apply"
+            ],
+            "validationCommands": [
+              "gdh adapters status",
+              "gdh verify drift",
+              "gdh status"
+            ]
+          },
+          {
+            "id": "review_project_docs_for_gdh_leakage",
+            "kind": "manual_review",
+            "summary": "Review any remaining project-owned docs for stale copied GDH prose.",
+            "detail": "GDH removes managed outputs it owns. If a target project manually copied old `docs/agent/*` prose into project-owned docs, treat that as project content and review it manually instead of deleting it automatically.",
+            "commands": [],
+            "validationCommands": [
+              "gdh status"
+            ]
+          }
+        ]
+      }
     }
   ]
 }

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

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

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

@@ -1,138 +1,16 @@
-import { GDH_UPDATE_HOOK_VERSION } from "@gdh/core";
+import { GDH_UPDATE_HOOK_VERSION, assertClassRegistered } from "@gdh/core";
+import { renderAdapterTemplate } from "./template-assets.js";
+assertClassRegistered("authoring_hook", "deterministic");
 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 { 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);",
-        "  return allow();",
-        "}",
-        "",
-        "function handlePostEdit(input, targetRoot) {",
-        "  const changed = collectChangedFiles(input, targetRoot);",
-        "  const authoring = changed.filter(isAuthoringValidationPath);",
-        "  if (authoring.length === 0) return allow();",
-        "  const changedArgs = authoring.flatMap((file) => ['--changed', file]);",
-        "  // Attempt to refresh the diagnostics broker for changed files.",
-        "  // Broker refresh failure is non-fatal: the authoring check falls back to direct LSP.",
-        "  runGdh(targetRoot, ['authoring', 'diagnostics', 'refresh', '--target', targetRoot, ...changedArgs]);",
-        "  // Run compact authoring check. When broker was refreshed, this uses the fresh snapshot.",
-        "  // When broker is unavailable, this falls back to direct LSP post-edit collection.",
-        "  const result = runGdh(targetRoot, ['authoring', 'check', '--target', targetRoot, '--mode', 'post-edit', '--format', 'compact', ...changedArgs]);",
-        "  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 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 baseCwd = input && typeof input.cwd === 'string' ? input.cwd : process.cwd();",
-        "  const files = [];",
-        "  addFile(files, input.file_path, targetRoot, baseCwd);",
-        "  addFromToolPayload(files, input.tool_input, targetRoot, baseCwd);",
-        "  addFromToolPayload(files, input.tool_response, targetRoot, baseCwd);",
-        "  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, baseCwd);",
-        "  return unique(files);",
-        "}",
-        "",
-        "function addFromToolPayload(files, payload, targetRoot, baseCwd) {",
-        "  if (!payload || typeof payload !== 'object') return;",
-        "  addFile(files, payload.file_path, targetRoot, baseCwd);",
-        "  addFile(files, payload.filePath, targetRoot, baseCwd);",
-        "  addFile(files, payload.path, targetRoot, baseCwd);",
-        "  if (Array.isArray(payload.file_paths)) for (const file of payload.file_paths) addFile(files, file, targetRoot, baseCwd);",
-        "  if (Array.isArray(payload.files)) for (const file of payload.files) addFile(files, file, targetRoot, baseCwd);",
-        "}",
-        "",
-        "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, baseCwd) {",
-        "  if (typeof value !== 'string' || value.trim() === '') return;",
-        "  const normalized = normalizeToTargetRelative(value.trim(), targetRoot, baseCwd);",
-        "  if (normalized) files.push(normalized);",
-        "}",
-        "",
-        "function normalizeToTargetRelative(value, targetRoot, baseCwd) {",
-        "  if (value.startsWith('res://')) return value.slice('res://'.length);",
-        "  const canonicalTargetRoot = canonicalPath(targetRoot);",
-        "  const canonicalBaseCwd = canonicalPath(baseCwd || targetRoot);",
-        "  const absolute = path.isAbsolute(value) ? canonicalPath(value) : path.resolve(canonicalBaseCwd, value);",
-        "  const relative = path.relative(canonicalTargetRoot, absolute);",
-        "  if ((relative.startsWith('..') || path.isAbsolute(relative)) && !path.isAbsolute(value) && isInside(canonicalTargetRoot, canonicalBaseCwd)) {",
-        "    const fallbackRelative = path.relative(canonicalTargetRoot, path.resolve(canonicalTargetRoot, value));",
-        "    if (!fallbackRelative.startsWith('..') && !path.isAbsolute(fallbackRelative)) return fallbackRelative.split(path.sep).join('/');",
-        "  }",
-        "  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;",
-        "  return relative.split(path.sep).join('/');",
-        "}",
-        "function isInside(root, candidate) { const rel = path.relative(root, path.resolve(candidate)); return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel)); }",
-        "function canonicalPath(value) { try { return fs.realpathSync.native ? fs.realpathSync.native(value) : fs.realpathSync(value); } catch { return path.resolve(value); } }",
-        "",
-        "function isAuthoringValidationPath(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 unique(values) { return [...new Set(values.filter(Boolean))].sort(); }",
-        "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");
+    return renderAdapterTemplate("authoring-hook.js.tpl", {
+        hookVersion: String(GDH_UPDATE_HOOK_VERSION),
+        pinnedVersionJson: JSON.stringify(input.pinnedVersion),
+        targetRelativePathJson: JSON.stringify(input.targetRelativePath),
+        agentJson: JSON.stringify(input.agent),
+    });
 }
 //# sourceMappingURL=authoring-hook-render.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"authoring-hook-render.js","sourceRoot":"","sources":["../src/authoring-hook-render.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"authoring-hook-render.js","sourceRoot":"","sources":["../src/authoring-hook-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAE3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,qBAAqB,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAAC;AAEzD,MAAM,CAAC,MAAM,mCAAmC,GAAG,sCAAsC,CAAC;AAC1F,MAAM,CAAC,MAAM,kCAAkC,GAAG,qCAAqC,CAAC;AACxF,MAAM,CAAC,MAAM,6BAA6B,GACxC,oRAAoR,CAAC;AACvR,MAAM,CAAC,MAAM,4BAA4B,GACvC,kRAAkR,CAAC;AAErR,MAAM,UAAU,sBAAsB,CAAC,KAItC;IACC,OAAO,qBAAqB,CAAC,uBAAuB,EAAE;QACpD,WAAW,EAAE,MAAM,CAAC,uBAAuB,CAAC;QAC5C,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC;QACtD,sBAAsB,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,kBAAkB,CAAC;QAChE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;KACvC,CAAC,CAAC;AACL,CAAC"}

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

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

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

@@ -1,4 +1,6 @@
-import { GDH_UPDATE_HOOK_VERSION } from "@gdh/core";
+import { GDH_UPDATE_HOOK_VERSION, assertClassRegistered } from "@gdh/core";
+import { renderAdapterTemplate } from "./template-assets.js";
+assertClassRegistered("claude_statusline", "deterministic");
 /**
  * Relative path of the optional managed Claude statusline renderer script.
  * GDH bakes this file so projects can opt into it manually, but adapter
@@ -48,32 +50,8 @@ export const GDH_STATUSLINE_COMMAND = "node .claude/hooks/gdh-statusline.js";
  * 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");
+    return renderAdapterTemplate("claude-statusline.js.tpl", {
+        hookVersion: String(GDH_UPDATE_HOOK_VERSION),
+    });
 }
 //# sourceMappingURL=claude-statusline-render.js.map

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

@@ -1 +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;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAC1C,iCAAiC,CAAC;AAEpC;;;;;;;;GAQG;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"}
+{"version":3,"file":"claude-statusline-render.js","sourceRoot":"","sources":["../src/claude-statusline-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAE3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,qBAAqB,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAC1C,iCAAiC,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,sCAAsC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,4BAA4B,CAAC,cAAuB;IAClE,OAAO,qBAAqB,CAAC,0BAA0B,EAAE;QACvD,WAAW,EAAE,MAAM,CAAC,uBAAuB,CAAC;KAC7C,CAAC,CAAC;AACL,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"claude-update-hook-render.d.ts","sourceRoot":"","sources":["../src/claude-update-hook-render.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,sCAAsC,sCACd,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,wCAAwC,6CACT,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAwCzE"}
+{"version":3,"file":"claude-update-hook-render.d.ts","sourceRoot":"","sources":["../src/claude-update-hook-render.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,sCAAsC,sCACd,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,wCAAwC,6CACT,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAKzE"}

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

@@ -1,4 +1,6 @@
-import { GDH_UPDATE_HOOK_VERSION } from "@gdh/core";
+import { GDH_UPDATE_HOOK_VERSION, assertClassRegistered } from "@gdh/core";
+import { renderAdapterTemplate } from "./template-assets.js";
+assertClassRegistered("claude_update_hook", "deterministic");
 /**
  * Relative path of the managed Claude SessionStart parent hook script.
  * This is the .js file Claude Code invokes when a session opens on a
@@ -33,44 +35,9 @@ export const CLAUDE_CHECK_UPDATE_WORKER_RELATIVE_PATH = ".claude/hooks/gdh-check
  * output is literal JavaScript.
  */
 export function renderClaudeCheckUpdateHook(pinnedVersion) {
-    return [
-        "#!/usr/bin/env node",
-        `// gdh-hook-version: ${GDH_UPDATE_HOOK_VERSION}`,
-        "// Check for GDH updates in background, write result to cache.",
-        "// Called by Claude Code SessionStart hook — runs once per session.",
-        "// Baked by @gdh/adapters at the pinned gdh_version — regenerated by gdh self-update.",
-        "",
-        "const fs = require('fs');",
-        "const path = require('path');",
-        "const os = require('os');",
-        "const { spawn } = require('child_process');",
-        "",
-        "(function () {",
-        "  // Dev-mode short-circuit: contributors running from source must never see an update signal.",
-        "  // (Baked script cannot read .gdh-state/local-paths.json without @gdh/core; env var covers the contributor case.)",
-        "  if (process.env.GDH_DEV_REPO && process.env.GDH_DEV_REPO.trim()) return;",
-        "",
-        "  const homeDir = os.homedir();",
-        "  const cacheDir = path.join(homeDir, '.cache', 'gdh');",
-        "  const cacheFile = path.join(cacheDir, 'update-check.json');",
-        "",
-        "  try { fs.mkdirSync(cacheDir, { recursive: true }); } catch (e) {}",
-        "",
-        "  const workerPath = path.join(__dirname, 'gdh-check-update-worker.js');",
-        "  const child = spawn(process.execPath, [workerPath], {",
-        "    stdio: 'ignore',",
-        "    windowsHide: true,",
-        "    detached: true,",
-        "    env: {",
-        "      ...process.env,",
-        "      GDH_CACHE_FILE: cacheFile,",
-        `      GDH_PINNED_VERSION: ${JSON.stringify(pinnedVersion)},`,
-        "    },",
-        "  });",
-        "",
-        "  child.unref();",
-        "})();",
-        "",
-    ].join("\n");
+    return renderAdapterTemplate("claude-check-update-hook.js.tpl", {
+        hookVersion: String(GDH_UPDATE_HOOK_VERSION),
+        pinnedVersionJson: JSON.stringify(pinnedVersion),
+    });
 }
 //# sourceMappingURL=claude-update-hook-render.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"claude-update-hook-render.js","sourceRoot":"","sources":["../src/claude-update-hook-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEpD;;;;GAIG;AACH,MAAM,CAAC,MAAM,sCAAsC,GACjD,mCAAmC,CAAC;AAEtC;;;GAGG;AACH,MAAM,CAAC,MAAM,wCAAwC,GACnD,0CAA0C,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,2BAA2B,CAAC,aAAqB;IAC/D,OAAO;QACL,qBAAqB;QACrB,wBAAwB,uBAAuB,EAAE;QACjD,gEAAgE;QAChE,qEAAqE;QACrE,uFAAuF;QACvF,EAAE;QACF,2BAA2B;QAC3B,+BAA+B;QAC/B,2BAA2B;QAC3B,6CAA6C;QAC7C,EAAE;QACF,gBAAgB;QAChB,gGAAgG;QAChG,qHAAqH;QACrH,4EAA4E;QAC5E,EAAE;QACF,iCAAiC;QACjC,yDAAyD;QACzD,+DAA+D;QAC/D,EAAE;QACF,qEAAqE;QACrE,EAAE;QACF,0EAA0E;QAC1E,yDAAyD;QACzD,sBAAsB;QACtB,wBAAwB;QACxB,qBAAqB;QACrB,YAAY;QACZ,uBAAuB;QACvB,kCAAkC;QAClC,6BAA6B,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;QAC7D,QAAQ;QACR,OAAO;QACP,EAAE;QACF,kBAAkB;QAClB,OAAO;QACP,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"claude-update-hook-render.js","sourceRoot":"","sources":["../src/claude-update-hook-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAE3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,qBAAqB,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAC;AAE7D;;;;GAIG;AACH,MAAM,CAAC,MAAM,sCAAsC,GACjD,mCAAmC,CAAC;AAEtC;;;GAGG;AACH,MAAM,CAAC,MAAM,wCAAwC,GACnD,0CAA0C,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,2BAA2B,CAAC,aAAqB;IAC/D,OAAO,qBAAqB,CAAC,iCAAiC,EAAE;QAC9D,WAAW,EAAE,MAAM,CAAC,uBAAuB,CAAC;QAC5C,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;KACjD,CAAC,CAAC;AACL,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"claude-update-worker-render.d.ts","sourceRoot":"","sources":["../src/claude-update-worker-render.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,6BAA6B,CAC3C,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAsER"}
+{"version":3,"file":"claude-update-worker-render.d.ts","sourceRoot":"","sources":["../src/claude-update-worker-render.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,6BAA6B,CAC3C,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAOR"}

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

@@ -1,4 +1,6 @@
-import { GDH_UPDATE_HOOK_VERSION, GDH_UPDATE_REGISTRY_URL, } from "@gdh/core";
+import { GDH_UPDATE_HOOK_VERSION, GDH_UPDATE_REGISTRY_URL, assertClassRegistered, } from "@gdh/core";
+import { renderAdapterTemplate } from "./template-assets.js";
+assertClassRegistered("claude_update_worker", "deterministic");
 /**
  * Render the background worker source that is spawned (detached + unref) by
  * the SessionStart parent hook. The worker performs the HTTPS probe against
@@ -28,72 +30,9 @@ import { GDH_UPDATE_HOOK_VERSION, GDH_UPDATE_REGISTRY_URL, } from "@gdh/core";
 export function renderClaudeCheckUpdateWorker(_pinnedVersion) {
     // _pinnedVersion is accepted for API uniformity with the hook renderer;
     // the worker body itself reads process.env.GDH_PINNED_VERSION at runtime.
-    return [
-        "#!/usr/bin/env node",
-        `// gdh-hook-version: ${GDH_UPDATE_HOOK_VERSION}`,
-        "// Background worker spawned by the GDH SessionStart parent hook.",
-        "// Probes https://registry.npmjs.org/@skillcap/gdh/latest and writes the",
-        "// result to the per-user cache at ~/.cache/gdh/update-check.json.",
-        "// Exits silently on any failure — D-06 silent-failure contract.",
-        "",
-        "'use strict';",
-        "",
-        "const fs = require('fs');",
-        "",
-        "// Compare semver: true if a is strictly newer than b.",
-        "// Strips pre-release suffixes (e.g. '3-beta.1' → '3') to avoid NaN from Number().",
-        "function isNewer(a, b) {",
-        "  const pa = (a || '').split('.').map(s => Number(s.replace(/-.*/, '')) || 0);",
-        "  const pb = (b || '').split('.').map(s => Number(s.replace(/-.*/, '')) || 0);",
-        "  for (let i = 0; i < 3; i++) {",
-        "    if (pa[i] > pb[i]) return true;",
-        "    if (pa[i] < pb[i]) return false;",
-        "  }",
-        "  return false;",
-        "}",
-        "",
-        "(async () => {",
-        "  // Dev-mode short-circuit: contributors running from source must never see an update signal.",
-        "  // (Baked worker checks ONLY the env var — cannot read local-paths.json without @gdh/core.)",
-        "  if (process.env.GDH_DEV_REPO && process.env.GDH_DEV_REPO.trim()) return;",
-        "",
-        "  const pinned = process.env.GDH_PINNED_VERSION;",
-        "  if (!pinned) return;",
-        "",
-        "  const cacheFile = process.env.GDH_CACHE_FILE;",
-        "  if (!cacheFile) return;",
-        "",
-        "  let res = null;",
-        "  try {",
-        `    res = await fetch(${JSON.stringify(GDH_UPDATE_REGISTRY_URL)}, {`,
-        "      signal: AbortSignal.timeout(10000),",
-        "    });",
-        "  } catch (e) {}",
-        "",
-        "  let latest = null;",
-        "  if (res && res.ok) {",
-        "    try {",
-        "      const body = await res.json();",
-        "      if (typeof body.version === 'string') {",
-        "        latest = body.version;",
-        "      }",
-        "    } catch (e) {}",
-        "  }",
-        "",
-        "  // Offline / registry 5xx / parse error — write nothing per D-06.",
-        "  if (latest === null) return;",
-        "",
-        "  const result = {",
-        "    pinned,",
-        "    latest,",
-        "    checkedAt: new Date().toISOString(),",
-        "    source: 'npm-registry-latest',",
-        "    updateAvailable: isNewer(latest, pinned),",
-        "  };",
-        "",
-        "  try { fs.writeFileSync(cacheFile, JSON.stringify(result, null, 2)); } catch (e) {}",
-        "})();",
-        "",
-    ].join("\n");
+    return renderAdapterTemplate("claude-check-update-worker.js.tpl", {
+        hookVersion: String(GDH_UPDATE_HOOK_VERSION),
+        registryUrlJson: JSON.stringify(GDH_UPDATE_REGISTRY_URL),
+    });
 }
 //# sourceMappingURL=claude-update-worker-render.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"claude-update-worker-render.js","sourceRoot":"","sources":["../src/claude-update-worker-render.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,cAAuB;IAEvB,wEAAwE;IACxE,0EAA0E;IAC1E,OAAO;QACL,qBAAqB;QACrB,wBAAwB,uBAAuB,EAAE;QACjD,mEAAmE;QACnE,0EAA0E;QAC1E,oEAAoE;QACpE,kEAAkE;QAClE,EAAE;QACF,eAAe;QACf,EAAE;QACF,2BAA2B;QAC3B,EAAE;QACF,wDAAwD;QACxD,oFAAoF;QACpF,0BAA0B;QAC1B,gFAAgF;QAChF,gFAAgF;QAChF,iCAAiC;QACjC,qCAAqC;QACrC,sCAAsC;QACtC,KAAK;QACL,iBAAiB;QACjB,GAAG;QACH,EAAE;QACF,gBAAgB;QAChB,gGAAgG;QAChG,+FAA+F;QAC/F,4EAA4E;QAC5E,EAAE;QACF,kDAAkD;QAClD,wBAAwB;QACxB,EAAE;QACF,iDAAiD;QACjD,2BAA2B;QAC3B,EAAE;QACF,mBAAmB;QACnB,SAAS;QACT,yBAAyB,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,KAAK;QACrE,2CAA2C;QAC3C,SAAS;QACT,kBAAkB;QAClB,EAAE;QACF,sBAAsB;QACtB,wBAAwB;QACxB,WAAW;QACX,sCAAsC;QACtC,+CAA+C;QAC/C,gCAAgC;QAChC,SAAS;QACT,oBAAoB;QACpB,KAAK;QACL,EAAE;QACF,qEAAqE;QACrE,gCAAgC;QAChC,EAAE;QACF,oBAAoB;QACpB,aAAa;QACb,aAAa;QACb,0CAA0C;QAC1C,oCAAoC;QACpC,+CAA+C;QAC/C,MAAM;QACN,EAAE;QACF,sFAAsF;QACtF,OAAO;QACP,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"claude-update-worker-render.js","sourceRoot":"","sources":["../src/claude-update-worker-render.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,qBAAqB,CAAC,sBAAsB,EAAE,eAAe,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,cAAuB;IAEvB,wEAAwE;IACxE,0EAA0E;IAC1E,OAAO,qBAAqB,CAAC,mCAAmC,EAAE;QAChE,WAAW,EAAE,MAAM,CAAC,uBAAuB,CAAC;QAC5C,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC;KACzD,CAAC,CAAC;AACL,CAAC"}

package/node_modules/@gdh/adapters/dist/deferred-actions-advisory.d.ts

@@ -0,0 +1,71 @@
+import { type GdhDeferredActionStatus, type GdhEnvelopePendingAdvisory, type GdhHostHarnessIntrospect, type GdhProcessRestartProbe } from "@gdh/core";
+/**
+ * Adapters consumed by {@link computeDeferredActionsAdvisory} (and threaded
+ * through `buildGdhStatusResult`). Both fields default to `null` so unit tests
+ * (which cannot introspect a real host harness) see probe results degrade to
+ * `pending` and the advisory remains correctly gated.
+ */
+export interface GdhStatusBuildAdapters {
+    readonly hostHarnessIntrospect: GdhHostHarnessIntrospect;
+    readonly processProbe: GdhProcessRestartProbe;
+}
+/**
+ * Probed deferred-action entry surfaced through `gdh status`.
+ *
+ * Mirrors the `GdhDeferredAction` shape minus the on-disk-only fields; carries
+ * the live probe result so consumers can rebuild rendering without re-running
+ * the probes.
+ */
+export interface GdhDeferredActionStatusEntry {
+    readonly id: string;
+    readonly description: string;
+    readonly status: GdhDeferredActionStatus;
+    readonly reason?: string;
+}
+/**
+ * Backup-cleanup advisory shape (D-17). Emitted ONLY when:
+ *   1. every probed deferred action returns `clean` (or there are zero), AND
+ *   2. `.gdh-state/backup/` exists (a manifest was readable), AND
+ *   3. `.gdh-state/backup.new/` does NOT exist (no in-progress migration).
+ *
+ * The `command` literal is the verbatim CLI invocation users run.
+ */
+export interface GdhBackupAdvisory {
+    readonly command: "gdh migration clear-backups";
+    readonly reason: "all_deferred_actions_clean";
+    readonly from_pin: string;
+    readonly to_pin: string;
+}
+export interface GdhDeferredActionsAdvisoryResult {
+    readonly deferredActions: readonly GdhDeferredActionStatusEntry[];
+    readonly backupAdvisory: GdhBackupAdvisory | null;
+    /**
+     * Phase 73 D-12: envelope-pending advisory. `null` unless
+     * `migration.json.pending_envelope_resume` is non-null. Mutually exclusive
+     * with {@link GdhBackupAdvisory} — when this is non-null, `backupAdvisory`
+     * is `null` because clearing the durable backup while a chain is paused
+     * destroys the rollback substrate.
+     */
+    readonly envelopeAdvisory: GdhEnvelopePendingAdvisory | null;
+}
+/**
+ * Read `migration.json`, run the probe per deferred action, and decide whether
+ * to emit the backup-cleanup advisory.
+ *
+ * Threat mitigations:
+ * - T-72-05-03 (TOCTOU): re-reads migration.json AND backup state freshly
+ *   inside this function; no cached probe results are consumed across calls.
+ * - T-72-05-04 (malformed migration.json): `readMigrationState` returns null
+ *   on parse/shape failure → `deferredActions` is `[]` and the advisory is
+ *   gated through the standard truth table.
+ * - T-72-05-06 (stale probe → clean): the gate requires `status === "clean"`
+ *   for every probe; `stale` and `pending` both block the advisory.
+ * - T-72-05-07 (interrupted migration): staging-dir check forces the advisory
+ *   to null whenever `.gdh-state/backup.new/` exists.
+ *
+ * Defaults: `adapters.hostHarnessIntrospect = null` and `adapters.processProbe
+ * = null` (every probe degrades to `pending`, so the advisory does not spuriously
+ * fire when a host cannot evaluate the deferred conditions).
+ */
+export declare function computeDeferredActionsAdvisory(targetPath: string, adapters?: GdhStatusBuildAdapters): Promise<GdhDeferredActionsAdvisoryResult>;
+//# sourceMappingURL=deferred-actions-advisory.d.ts.map

package/node_modules/@gdh/adapters/dist/deferred-actions-advisory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred-actions-advisory.d.ts","sourceRoot":"","sources":["../src/deferred-actions-advisory.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC5B,MAAM,WAAW,CAAC;AAOnB;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,qBAAqB,EAAE,wBAAwB,CAAC;IACzD,QAAQ,CAAC,YAAY,EAAE,sBAAsB,CAAC;CAC/C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,eAAe,EAAE,SAAS,4BAA4B,EAAE,CAAC;IAClE,QAAQ,CAAC,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClD;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,0BAA0B,GAAG,IAAI,CAAC;CAC9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,OAAO,CAAC,gCAAgC,CAAC,CA0E3C"}