@skillcap/gdh 0.23.0 → 0.24.0

package/node_modules/@gdh/core/dist/migrations/envelopes/types.d.ts

@@ -0,0 +1,121 @@
+import type { GdhMigrationVersionPair } from "../registry.js";
+/**
+ * Phase 73 migration envelope schema (D-01 / D-02 / D-03 / D-04).
+ *
+ * The envelope is the typed escape hatch for genuinely semantic migrations
+ * that mechanical Rule A (deterministic transform) cannot express. Every
+ * field name is `snake_case` to match the on-disk JSON conventions Phase 72
+ * established for `migration.json` (`recorded_at`, `from_pin`, `to_pin`,
+ * `output_contract`, …); per-field `readonly` mirrors the immutability
+ * pattern at `packages/core/src/migrations/registry.ts:31-56`.
+ *
+ * This file is the single shared schema surface consumed by:
+ *   - `applyMigrationChain` (Plan 03) — emits the envelope when an entry
+ *     declares `envelope_ref`.
+ *   - `gdh migration record-envelope-result` (Plan 05) — validates the
+ *     agent-supplied output_contract against `GdhMigrationEnvelopeOutput`
+ *     via `isEnvelopeOutput` (`./envelope-output-validator.ts`).
+ *   - The static slug→envelope manifest (`./index.ts`).
+ *
+ * D-01 explicitly excludes a clarifying-questions mandate field (it would
+ * conflict with batch `gdh self-update` runs). D-03 explicitly excludes a
+ * per-envelope output_contract extension slot in v1.18 (YAGNI; reintroduce
+ * when envelope variance is real). Per D-04, `envelope_ref` is a slug only
+ * — inline-literal envelope objects on `GdhMigrationEntry.envelope_ref` are
+ * unsupported by construction.
+ */
+/**
+ * Structured mandate (D-01).
+ *
+ * `acceptance_criteria` MUST be enumerated at authoring time so the agent
+ * has a verifiable rubric for its `output_contract` and downstream evidence
+ * recording knows what "done" looks like.
+ */
+export interface GdhMigrationEnvelopeMandate {
+    readonly instruction: string;
+    readonly acceptance_criteria: readonly string[];
+    readonly examples?: readonly string[];
+}
+/**
+ * Tool scope (D-02). Glob patterns mirror gitignore semantics the author
+ * already knows. No deny-list carve-outs in v1.18 (YAGNI).
+ */
+export interface GdhMigrationEnvelopeToolScope {
+    /** Glob patterns the agent MAY read from. */
+    readonly read: readonly string[];
+    /** Glob patterns the agent MAY write to. */
+    readonly write: readonly string[];
+}
+/**
+ * Seed shape for `apply.changes` (D-03). Phase 73 stores the array as
+ * evidence; later phases that ship a real envelope-using migration define
+ * concrete consumers. Keep field names primitive and JSON-safe so the
+ * recorded slot in `migration.json` remains round-trippable through
+ * `JSON.parse`/`JSON.stringify` without per-shape codecs.
+ */
+export type GdhFileChange = {
+    readonly kind: "rewrite";
+    readonly relativePath: string;
+    readonly content: string;
+} | {
+    readonly kind: "delete";
+    readonly relativePath: string;
+};
+/**
+ * Typed discriminated union for the agent's output (D-03).
+ *
+ * Three named outcomes:
+ *   - `apply` — agent produced a concrete change set; `migration.json`
+ *     records `changes` as evidence.
+ *   - `abort` — agent declined; `reason` is recorded for audit trail.
+ *   - `needs_clarification` — agent wants questions answered before applying;
+ *     `questions` are recorded so the operator/next session can resolve them.
+ *
+ * D-03 explicitly excludes a per-envelope extension slot — adding one now
+ * would invite untyped expansion ahead of any real envelope-using migration.
+ */
+export type GdhMigrationEnvelopeOutput = {
+    readonly state: "apply";
+    readonly changes: readonly GdhFileChange[];
+} | {
+    readonly state: "abort";
+    readonly reason: string;
+} | {
+    readonly state: "needs_clarification";
+    readonly questions: readonly string[];
+};
+/**
+ * Migration envelope (D-04).
+ *
+ * Each envelope file under `packages/core/src/migrations/envelopes/<slug>.ts`
+ * exports a single typed `GdhMigrationEnvelope`. `envelope_ref` MUST equal
+ * the file basename and pass `isEnvelopeSlug` (`./index.ts`); the
+ * defense-in-depth invariant test in `./index.test.ts` enforces that
+ * registry key === entry's `envelope_ref` for every shipped envelope.
+ *
+ * `from`/`to` drive the D-10 staleness gate: a previously-recorded envelope
+ * result is valid only when `(envelope_ref, from_pin, to_pin)` all match the
+ * current chain step's bump pair. Pin change → stale → re-emit envelope.
+ *
+ * `fallback_note` reminds the inline-running agent (host that cannot spawn
+ * subagents) that the same mandate, tool_scope, and output_contract apply;
+ * tool scope is discipline-bound rather than enforced by a sandboxed
+ * subagent (per MIGRATION-WORKFLOW.md §4.2).
+ */
+export interface GdhMigrationEnvelope {
+    /** Slug == file basename under envelopes/ (D-04). Lower-case + underscore + digit only. */
+    readonly envelope_ref: string;
+    /** From-pair the envelope is valid for. Used by the D-10 staleness gate. */
+    readonly from: GdhMigrationVersionPair;
+    /** To-pair the envelope is valid for. */
+    readonly to: GdhMigrationVersionPair;
+    readonly mandate: GdhMigrationEnvelopeMandate;
+    readonly tool_scope: GdhMigrationEnvelopeToolScope;
+    /**
+     * Identical mandate prompt and output_contract between subagent and inline
+     * paths (MIGRATION-WORKFLOW.md §4.2). The fallback note reminds the
+     * inline-running agent that tool scope is discipline-bound.
+     */
+    readonly fallback_note: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@gdh/core/dist/migrations/envelopes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/migrations/envelopes/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,0BAA0B,GAClC;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,GACvE;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,oBAAoB;IAEnC,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,EAAE,uBAAuB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC"}

package/node_modules/@gdh/core/dist/migrations/envelopes/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/node_modules/@gdh/core/dist/migrations/envelopes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/migrations/envelopes/types.ts"],"names":[],"mappings":""}

package/node_modules/@gdh/core/dist/migrations/golden-harness.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Per-entry golden fixture harness for migration registry entries.
+ *
+ * Provides `runMigrationGolden(entry, fixturePath)` — reads `<fixturePath>/before/`,
+ * runs the entry's mechanical transform (Phase 72) or future subagent envelope
+ * (Phase 73), and asserts byte-equal match against `<fixturePath>/after/`.
+ *
+ * Phase 71 ships the harness scaffold + one stub golden test that proves the
+ * harness works against a noop transform. Phase 72 authors real registry
+ * entries that consume the harness. Per CONTEXT.md D-15 / D-16: the harness
+ * is a pure utility with no registry dependency — Phase 72's registry imports
+ * the harness, not the other way around.
+ *
+ * Consumers:
+ *   - Phase 71: stub test in golden-harness.test.ts proves the harness works.
+ *   - Phase 72: every migration registry entry's per-entry golden test.
+ *
+ * Per-entry fixture layout (CONTEXT.md D-17):
+ *   tests/fixtures/migration-goldens/<entry-id>/
+ *     before/   <- input file tree, paths relative to the per-entry root
+ *     after/    <- expected output file tree, same path scheme
+ *
+ * Comparison semantics:
+ *   - Default: byte-equal on every file declared in `after/`.
+ *   - Class-2 user-data goldens (Phase 72) may opt into structural
+ *     comparison via an entry-level comparator override (extension point;
+ *     not implemented in Phase 71).
+ */
+export interface GdhMigrationGoldenInputs {
+    readonly files: ReadonlyMap<string, string>;
+}
+export interface GdhMigrationGoldenOutputs {
+    readonly files: ReadonlyMap<string, string>;
+}
+export interface GdhMigrationGoldenEntry {
+    readonly id: string;
+    readonly transform: (input: GdhMigrationGoldenInputs) => Promise<GdhMigrationGoldenOutputs>;
+}
+export declare function runMigrationGolden(entry: GdhMigrationGoldenEntry, fixturePath: string): Promise<void>;
+//# sourceMappingURL=golden-harness.d.ts.map

package/node_modules/@gdh/core/dist/migrations/golden-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"golden-harness.d.ts","sourceRoot":"","sources":["../../src/migrations/golden-harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,wBAAwB,KAC5B,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACzC;AA0BD,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,uBAAuB,EAC9B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/node_modules/@gdh/core/dist/migrations/golden-harness.js

@@ -0,0 +1,71 @@
+/**
+ * Per-entry golden fixture harness for migration registry entries.
+ *
+ * Provides `runMigrationGolden(entry, fixturePath)` — reads `<fixturePath>/before/`,
+ * runs the entry's mechanical transform (Phase 72) or future subagent envelope
+ * (Phase 73), and asserts byte-equal match against `<fixturePath>/after/`.
+ *
+ * Phase 71 ships the harness scaffold + one stub golden test that proves the
+ * harness works against a noop transform. Phase 72 authors real registry
+ * entries that consume the harness. Per CONTEXT.md D-15 / D-16: the harness
+ * is a pure utility with no registry dependency — Phase 72's registry imports
+ * the harness, not the other way around.
+ *
+ * Consumers:
+ *   - Phase 71: stub test in golden-harness.test.ts proves the harness works.
+ *   - Phase 72: every migration registry entry's per-entry golden test.
+ *
+ * Per-entry fixture layout (CONTEXT.md D-17):
+ *   tests/fixtures/migration-goldens/<entry-id>/
+ *     before/   <- input file tree, paths relative to the per-entry root
+ *     after/    <- expected output file tree, same path scheme
+ *
+ * Comparison semantics:
+ *   - Default: byte-equal on every file declared in `after/`.
+ *   - Class-2 user-data goldens (Phase 72) may opt into structural
+ *     comparison via an entry-level comparator override (extension point;
+ *     not implemented in Phase 71).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+async function readFixtureTree(rootPath) {
+    const files = new Map();
+    async function walk(currentDir, relativePrefix) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(currentDir, entry.name);
+            const entryRelative = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
+            if (entry.isDirectory()) {
+                await walk(entryPath, entryRelative);
+            }
+            else if (entry.isFile()) {
+                files.set(entryRelative, await fs.readFile(entryPath, "utf8"));
+            }
+        }
+    }
+    await walk(rootPath, "");
+    return files;
+}
+export async function runMigrationGolden(entry, fixturePath) {
+    const beforeFiles = await readFixtureTree(path.join(fixturePath, "before"));
+    const expectedAfterFiles = await readFixtureTree(path.join(fixturePath, "after"));
+    const result = await entry.transform({ files: beforeFiles });
+    const actualAfterFiles = result.files;
+    // 1. Every expected file must be present and byte-equal.
+    for (const [relativePath, expectedContent] of expectedAfterFiles) {
+        if (!actualAfterFiles.has(relativePath)) {
+            throw new Error(`Migration golden mismatch: missing expected output file "${relativePath}" for entry "${entry.id}".`);
+        }
+        const actualContent = actualAfterFiles.get(relativePath);
+        if (actualContent !== expectedContent) {
+            throw new Error(`Migration golden mismatch: content differs at "${relativePath}" for entry "${entry.id}".`);
+        }
+    }
+    // 2. Orphan detection — no unexpected output files.
+    for (const relativePath of actualAfterFiles.keys()) {
+        if (!expectedAfterFiles.has(relativePath)) {
+            throw new Error(`Migration golden mismatch: unexpected output file "${relativePath}" produced by entry "${entry.id}".`);
+        }
+    }
+}
+//# sourceMappingURL=golden-harness.js.map

package/node_modules/@gdh/core/dist/migrations/golden-harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"golden-harness.js","sourceRoot":"","sources":["../../src/migrations/golden-harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAiB7B,KAAK,UAAU,eAAe,CAC5B,QAAgB;IAEhB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,KAAK,UAAU,IAAI,CACjB,UAAkB,EAClB,cAAsB;QAEtB,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QACtE,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACpD,MAAM,aAAa,GACjB,cAAc,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,cAAc,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACzE,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBACxB,MAAM,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACvC,CAAC;iBAAM,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBAC1B,KAAK,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACzB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAA8B,EAC9B,WAAmB;IAEnB,MAAM,WAAW,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC5E,MAAM,kBAAkB,GAAG,MAAM,eAAe,CAC9C,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAChC,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;IAE7D,MAAM,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC;IAEtC,yDAAyD;IACzD,KAAK,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,IAAI,kBAAkB,EAAE,CAAC;QACjE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CACb,4DAA4D,YAAY,gBAAgB,KAAK,CAAC,EAAE,IAAI,CACrG,CAAC;QACJ,CAAC;QACD,MAAM,aAAa,GAAG,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACzD,IAAI,aAAa,KAAK,eAAe,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CACb,kDAAkD,YAAY,gBAAgB,KAAK,CAAC,EAAE,IAAI,CAC3F,CAAC;QACJ,CAAC;IACH,CAAC;IAED,oDAAoD;IACpD,KAAK,MAAM,YAAY,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC;QACnD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,sDAAsD,YAAY,wBAAwB,KAAK,CAAC,EAAE,IAAI,CACvG,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/node_modules/@gdh/core/dist/migrations/managed-surface-classes.d.ts

@@ -0,0 +1,322 @@
+/**
+ * Managed-surface drift classification manifest.
+ *
+ * Single source of truth for assigning every GDH-managed render call site to
+ * one of three drift classes: `"deterministic"`, `"user-data"`, or
+ * `"project-native"`. Required by GOV-03 (.planning/REQUIREMENTS.md) and
+ * locked by Phase 70 decisions D-05, D-06, D-08, D-13..D-24 in
+ * .planning/phases/70-governance-and-managed-surface-drift-classification/70-CONTEXT.md.
+ *
+ * Consumers:
+ *   - Migration registry (Phase 72)
+ *   - Chain matrix (Phase 71)
+ *   - Migration verifier (Phase 74)
+ *   - Renderer-side load-time guards (Plan 70-05) via `assertClassRegistered`
+ *   - `validate:docs` manifest-covers-renderers check (Plan 70-06)
+ *
+ * Out of classification scope per D-23: every path under `.gdh-state/` is
+ * machine-local state owned entirely by GDH; it is intentionally not a
+ * managed surface in the migration sense and is therefore absent from this
+ * manifest. The renderer `renderLocalPathHints` (which writes
+ * `.gdh-state/local-paths.json`) is the canonical example of an excluded
+ * surface.
+ *
+ * Three-class lock (D-24): the union below has exactly three members. No
+ * fourth class. No subclasses. Project-native surfaces declare a narrow op
+ * allowlist instead of a subclass.
+ */
+export type GdhManagedSurfaceClass = "deterministic" | "user-data" | "project-native";
+export interface GdhProjectNativeOpAllowlistEntry {
+    /** Stable op identifier referenced by registry entries (Phase 72). */
+    readonly op: string;
+    /** One-line human-readable description of what the op does. */
+    readonly summary: string;
+}
+export interface GdhManagedSurfaceClassEntry {
+    /**
+     * Stable surface identifier. Audit-time-frozen. No synonyms, no renames
+     * after audit — downstream consumers (registry, matrix, verifier) bind to
+     * these strings.
+     */
+    readonly surfaceId: string;
+    /**
+     * Workspace-relative output path of the surface, or `null` when the path
+     * varies (per-agent skills, per-target paths, multi-file surfaces).
+     */
+    readonly relativePath: string | null;
+    /** One of the three locked drift classes. */
+    readonly class: GdhManagedSurfaceClass;
+    /** Why this class — the audit decision rationale. */
+    readonly notes: string;
+    /**
+     * For project-native surfaces only — the narrow set of ops the
+     * migration registry may invoke against this surface. Anything outside the
+     * allowlist is rejected at audit-time. Adding an op requires both a
+     * manifest update AND a registry entry that declares it explicitly.
+     */
+    readonly projectNativeAllowlist?: readonly GdhProjectNativeOpAllowlistEntry[];
+}
+/**
+ * The classification manifest. Every render call site discovered during the
+ * Phase 70 audit appears here exactly once. The `as const satisfies` form
+ * preserves literal-string typing (downstream narrowing) while shape-checking
+ * each entry against `GdhManagedSurfaceClassEntry`.
+ */
+export declare const GDH_MANAGED_SURFACE_CLASSES: readonly [{
+    readonly surfaceId: "skill.claude.onboard";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'onboard', version). Per-target path: .claude/skills/gdh-onboard/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.status";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'status', version). Per-target path: .claude/skills/gdh-status/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.scan";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'scan', version). Per-target path: .claude/skills/gdh-scan/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.migrate";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'migrate', version). Per-target path: .claude/skills/gdh-migrate/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.update";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'update', version). Per-target path: .claude/skills/gdh-update/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.check";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'check', version). Per-target path: .claude/skills/gdh-check/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.prepare";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'prepare', version). Per-target path: .claude/skills/gdh-prepare/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.claude.run-game";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('claude', 'run-game', version). Per-target path: .claude/skills/gdh-run-game/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.onboard";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'onboard', version). Per-target path: .codex/skills/gdh-onboard/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.status";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'status', version). Per-target path: .codex/skills/gdh-status/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.scan";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'scan', version). Per-target path: .codex/skills/gdh-scan/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.migrate";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'migrate', version). Per-target path: .codex/skills/gdh-migrate/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.update";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'update', version). Per-target path: .codex/skills/gdh-update/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.check";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'check', version). Per-target path: .codex/skills/gdh-check/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.prepare";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'prepare', version). Per-target path: .codex/skills/gdh-prepare/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.codex.run-game";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('codex', 'run-game', version). Per-target path: .codex/skills/gdh-run-game/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.onboard";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'onboard', version). Per-target path: .cursor/skills/gdh-onboard/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.status";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'status', version). Per-target path: .cursor/skills/gdh-status/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.scan";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'scan', version). Per-target path: .cursor/skills/gdh-scan/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.migrate";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'migrate', version). Per-target path: .cursor/skills/gdh-migrate/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.update";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'update', version). Per-target path: .cursor/skills/gdh-update/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.check";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'check', version). Per-target path: .cursor/skills/gdh-check/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.prepare";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'prepare', version). Per-target path: .cursor/skills/gdh-prepare/SKILL.md.";
+}, {
+    readonly surfaceId: "skill.cursor.run-game";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Generated agent skill rendered by renderGdhSkill('cursor', 'run-game', version). Per-target path: .cursor/skills/gdh-run-game/SKILL.md.";
+}, {
+    readonly surfaceId: "cursor_rule";
+    readonly relativePath: ".cursor/rules/gdh-agent.mdc";
+    readonly class: "deterministic";
+    readonly notes: "Cursor rule file rendered by renderCursorRule() in packages/adapters/src/index.ts (line 555). Path constant CURSOR_RULE_RELATIVE_PATH (line 171) defines the workspace-relative location.";
+}, {
+    readonly surfaceId: "claude_onboard_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeOnboardCommand() (packages/adapters/src/index.ts line 573); delegates to renderClaudeOnboardSkill. Per-target path under .claude/commands/gdh/ (legacy command-file location, retained for backwards compatibility).";
+}, {
+    readonly surfaceId: "claude_status_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeStatusCommand() (packages/adapters/src/index.ts line 577); delegates to renderClaudeStatusSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_scan_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeScanCommand() (packages/adapters/src/index.ts line 581); delegates to renderClaudeScanSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_migrate_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeMigrateCommand() (packages/adapters/src/index.ts line 585); delegates to renderClaudeMigrateSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_update_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeUpdateCommand() (packages/adapters/src/index.ts line 589); delegates to renderClaudeUpdateSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_check_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeCheckCommand() (packages/adapters/src/index.ts line 593); delegates to renderClaudeCheckSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_prepare_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudePrepareCommand() (packages/adapters/src/index.ts line 597); delegates to renderClaudePrepareSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "claude_run_game_command";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Legacy Claude command shim rendered by renderClaudeRunGameCommand() (packages/adapters/src/index.ts line 601); delegates to renderClaudeRunGameSkill. Per-target path under .claude/commands/gdh/.";
+}, {
+    readonly surfaceId: "mcp_config_entry";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Managed `gdh` MCP server entry rendered by renderManagedMcpConfig() (packages/adapters/src/index.ts line 3061). Per D-21 the entry GDH owns by marker is deterministic; the surrounding user MCP config (.mcp.json or .cursor/mcp.json) is project-native and not classified — GDH only operates on the entry it owns.";
+}, {
+    readonly surfaceId: "codex_project_mcp_section";
+    readonly relativePath: ".codex/config.toml";
+    readonly class: "deterministic";
+    readonly notes: "Managed `[mcp_servers.gdh]` section in .codex/config.toml rendered by renderManagedCodexProjectSection() (packages/adapters/src/index.ts line 3096) and stitched into the file via renderManagedCodexProjectConfig() (line 3106). Path constant CODEX_PROJECT_CONFIG_RELATIVE_PATH (line 231).";
+}, {
+    readonly surfaceId: "codex_authoring_hook_block";
+    readonly relativePath: ".codex/config.toml";
+    readonly class: "deterministic";
+    readonly notes: "Managed `# BEGIN GDH managed authoring hooks` block in .codex/config.toml rendered by renderManagedCodexAuthoringHookBlock() (packages/adapters/src/index.ts line 3193). Marker-bounded; deterministic per D-22.";
+}, {
+    readonly surfaceId: "authoring_hook";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Authoring validation hook rendered by renderGdhAuthoringHook() in packages/adapters/src/authoring-hook-render.ts (line 10). Per-agent paths: .claude/hooks/gdh-authoring-guard.js (CLAUDE_AUTHORING_HOOK_RELATIVE_PATH) and .codex/hooks/gdh-authoring-guard.js (CODEX_AUTHORING_HOOK_RELATIVE_PATH).";
+}, {
+    readonly surfaceId: "claude_update_hook";
+    readonly relativePath: ".claude/hooks/gdh-check-update.js";
+    readonly class: "deterministic";
+    readonly notes: "Claude SessionStart parent hook rendered by renderClaudeCheckUpdateHook() in packages/adapters/src/claude-update-hook-render.ts. Path constant CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH.";
+}, {
+    readonly surfaceId: "claude_update_worker";
+    readonly relativePath: ".claude/hooks/gdh-check-update-worker.js";
+    readonly class: "deterministic";
+    readonly notes: "Claude background update-check worker rendered by the renderer in packages/adapters/src/claude-update-worker-render.ts. Path constant CLAUDE_CHECK_UPDATE_WORKER_RELATIVE_PATH.";
+}, {
+    readonly surfaceId: "claude_statusline";
+    readonly relativePath: ".claude/hooks/gdh-statusline.js";
+    readonly class: "deterministic";
+    readonly notes: "Optional Claude statusline script rendered by the renderer in packages/adapters/src/claude-statusline-render.ts. Path constant CLAUDE_STATUSLINE_RELATIVE_PATH. GDH bakes the file but does not auto-register it in .claude/settings.json (single-slot conflict); registration is opt-in.";
+}, {
+    readonly surfaceId: "agents_md_managed_block";
+    readonly relativePath: "AGENTS.md";
+    readonly class: "deterministic";
+    readonly notes: "Managed BEGIN/END-marker block in AGENTS.md rendered by renderManagedAgentContractBlock() (packages/docs/src/agent-contract.ts line 24) and stitched in by upsertManagedAgentContract() (line 70). Path constant AGENT_CONTRACT_RELATIVE_PATH (line 12). Per D-18 the managed block specifically is deterministic; surrounding user content in AGENTS.md is project-native and not classified — GDH operates only on the marker-bounded region.";
+}, {
+    readonly surfaceId: "guidance_unit_set";
+    readonly relativePath: null;
+    readonly class: "deterministic";
+    readonly notes: "Managed guidance unit files (multiple) under docs/agent/ rendered by createDefaultGuidanceUnits() in packages/docs/src/guidance.ts (line 27). Each unit is GDH-rendered with metadata + body; relativePath is null because the surface emits multiple files. Class deterministic per D-19 (Session 9 nested-monorepo migration is the canonical drift mode).";
+}, {
+    readonly surfaceId: "guidance_index";
+    readonly relativePath: "docs/agent/README.md";
+    readonly class: "deterministic";
+    readonly notes: "Managed guidance index file rendered by createDefaultGuidanceIndex() in packages/docs/src/guidance.ts (line 391). Path constant GUIDANCE_INDEX_RELATIVE_PATH (line 19). Class deterministic per D-19.";
+}, {
+    readonly surfaceId: "gdh_project_yaml";
+    readonly relativePath: ".gdh/project.yaml";
+    readonly class: "user-data";
+    readonly notes: "Schema is GDH-shape; field values (especially gdh_version pin) are user-installed truth. This file defines the schema being migrated and is the canonical source of 'current schema version' when computing the migration plan. Per D-14.";
+}, {
+    readonly surfaceId: "gdh_rules_yaml";
+    readonly relativePath: ".gdh/rules.yaml";
+    readonly class: "user-data";
+    readonly notes: "Default boilerplate from a prior version is byte-equal-matched against registry-stored prior-version default and auto-migrated; non-byte-equal content is treated as user-customized and routes through the conflict policy. Per D-15.";
+}, {
+    readonly surfaceId: "run_configuration_set";
+    readonly relativePath: null;
+    readonly class: "user-data";
+    readonly notes: "Multiple files under .gdh/run-configurations/ created via `gdh run-config`. User owns content; GDH owns shape; semantic schema changes route through subagent envelope. Per D-16.";
+}, {
+    readonly surfaceId: "verification_scenario_set";
+    readonly relativePath: null;
+    readonly class: "user-data";
+    readonly notes: "Multiple files under .gdh/verification-scenarios/ created via `gdh verification-scenario`. User owns content; GDH owns shape; semantic schema changes route through subagent envelope. Per D-16.";
+}, {
+    readonly surfaceId: "project_godot";
+    readonly relativePath: "project.godot";
+    readonly class: "project-native";
+    readonly notes: "Owned by the Godot project. Anything outside projectNativeAllowlist is rejected at audit-time. Adding an op requires a registry entry that declares it explicitly. Per D-17.";
+    readonly projectNativeAllowlist: readonly [{
+        readonly op: "edit_editor_plugins_array";
+        readonly summary: "Add or remove entries in the [editor_plugins] section.";
+    }, {
+        readonly op: "register_autoload";
+        readonly summary: "Register or unregister an autoload entry.";
+    }];
+}];
+/**
+ * Load-time guard used by renderer modules (Plan 70-05) to assert their
+ * surface is registered in the manifest under the expected class. Throws
+ * loudly on drift — module init aborts before any write can happen.
+ *
+ * Mirrors the throw-on-violation discipline of
+ * packages/core/src/release-span-update-contract.ts (lines 60-83).
+ */
+export declare function assertClassRegistered(surfaceId: string, expectedClass: GdhManagedSurfaceClass): void;
+//# sourceMappingURL=managed-surface-classes.d.ts.map

package/node_modules/@gdh/core/dist/migrations/managed-surface-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-surface-classes.d.ts","sourceRoot":"","sources":["../../src/migrations/managed-surface-classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,MAAM,sBAAsB,GAC9B,eAAe,GACf,WAAW,GACX,gBAAgB,CAAC;AAErB,MAAM,WAAW,gCAAgC;IAC/C,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,SAAS,gCAAgC,EAAE,CAAC;CAC/E;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiYmB,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,sBAAsB,GACpC,IAAI,CAcN"}