polydeukes 0.5.0 → 0.6.1

package/dist/init-grok.js

@@ -0,0 +1,242 @@
+/**
+ * `initGrok` — the Grok session-surface installer.
+ *
+ * Preflight first, then the shared project-side scaffold, then the generated hook and the
+ * `.grok/hooks` JSON registration. When a Claude delegator is already on disk, the JSON
+ * command names that file instead of planting a second one — two command strings would
+ * spawn two judges per call.
+ *
+ * Nothing existing is overwritten, with one command-field exception: a grok JSON whose
+ * `command` is still the grok-mjs string is rewritten to the Claude-hook command when that
+ * Claude file is on disk — otherwise grok-then-claude leaves two command strings. Any entry
+ * naming the Claude-hook command also takes the matcher of the `.claude/settings.json` entry
+ * carrying that command, because the host collapses the two registrations only when command
+ * and matcher are byte-identical; with no such entry the matcher stays. Timeout stays either
+ * way, and a command that is not the grok-mjs string is left byte-identical.
+ *
+ * Rules and skills are not copied; `.claude/settings.json` is not written.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { findPackageJSON } from 'node:module';
+import { dirname, join } from 'node:path';
+import { isPlainObject } from '@polydeukes/core';
+import { scaffoldProject } from './scaffold-project.js';
+/** The published entry point the generated hook loads the judge through. */
+const HOOK_SPECIFIER = 'polydeukes/claude-code';
+/** The registration artifacts, as `projectRoot`-relative paths (the report vocabulary). */
+const GROK_HOOK_RELATIVE = '.grok/hooks/covenant-pretooluse.mjs';
+const GROK_JSON_RELATIVE = '.grok/hooks/covenant-pretooluse.json';
+/** The Claude delegator this installer reuses when it is already on disk. */
+const CLAUDE_HOOK_RELATIVE = '.claude/hooks/covenant-pretooluse.mjs';
+/** Where that delegator's own registration — and the matcher it was registered under — lives. */
+const CLAUDE_SETTINGS_RELATIVE = '.claude/settings.json';
+const GROK_HOOK_COMMAND = `node "$CLAUDE_PROJECT_DIR"/${GROK_HOOK_RELATIVE}`;
+const CLAUDE_HOOK_COMMAND = `node "$CLAUDE_PROJECT_DIR"/${CLAUDE_HOOK_RELATIVE}`;
+/**
+ * Which calls reach the judge — Grok's mutating+shell roster plus the Claude aliases a
+ * host without Grok's alias table still sends.
+ */
+const HOOK_MATCHER = 'write|search_replace|run_terminal_command|Edit|Write|MultiEdit|NotebookEdit|Bash';
+/**
+ * The generated hook. It carries no assembly at all, so upgrading the package upgrades the
+ * judge without regenerating this file. Same text as the Claude installer besides the
+ * header: the session subpath, `repoRoot` from this file's location, and `process.exitCode`
+ * rather than `process.exit`.
+ */
+const GENERATED_HOOK = `#!/usr/bin/env node
+/**
+ * Polydeukes PreToolUse covenant hook — generated by \`pdks init grok\`.
+ *
+ * A delegator and nothing more: the judgment assembly lives in the \`polydeukes\` package as
+ * \`runClaudeCodeHook\`, reached here through its session subpath. The package barrel would
+ * work too and is the wrong door — its re-exports are eager, so every session call would
+ * load the commit surface and its git adapter alongside the judge it actually needs.
+ *
+ * \`repoRoot\` comes from this file's own location, never from the working directory. A hook
+ * is spawned with whatever directory the agent happened to hold, and what config discovery
+ * and the protection list need is the project that CONTAINS this hook — always \`../..\`
+ * from here.
+ *
+ * fail-closed: \`runClaudeCodeHook\` translates every failure it can reach into exit 2 with
+ * one blocked record. This catch answers only for what it cannot reach — the package failing
+ * to resolve or load at all (never installed, or installed without a build) — where no
+ * telemetry writer exists yet. Recovery is installing the package again.
+ */
+
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+try {
+  const { runClaudeCodeHook } = await import('${HOOK_SPECIFIER}');
+  const { exitCode } = await runClaudeCodeHook({ repoRoot });
+  // Assign and let the process end naturally instead of process.exit(): an explicit exit
+  // can preempt a buffered stderr write on platforms with async pipes, dropping the break
+  // reason the agent needs to read.
+  process.exitCode = exitCode;
+} catch (error) {
+  console.error(\`covenant hook failed closed: \${error?.message ?? error}\`);
+  process.exitCode = 2;
+}
+`;
+/**
+ * The default preflight: is `polydeukes` installed where `projectRoot` can reach it?
+ *
+ * ESM resolution specifically, because that is what the generated hook's `await import(...)`
+ * runs. The generated hook loads `polydeukes/claude-code`, so that is the subpath this
+ * checks — a Grok-named entry point is not added.
+ */
+function resolveFromProjectRoot(projectRoot) {
+    const manifestPath = findPackageJSON('polydeukes', join(projectRoot, 'package.json'));
+    if (manifestPath === undefined) {
+        throw new Error('polydeukes is not installed where this project can reach it');
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    const subpath = isPlainObject(manifest) && isPlainObject(manifest.exports)
+        ? manifest.exports[`./${HOOK_SPECIFIER.split('/')[1]}`]
+        : undefined;
+    const target = isPlainObject(subpath) ? subpath.import : undefined;
+    if (typeof target !== 'string' || !existsSync(join(dirname(manifestPath), target))) {
+        throw new Error(`the installed polydeukes does not expose '${HOOK_SPECIFIER}' — update or rebuild it`);
+    }
+}
+/** Write one generated artifact unless it is already there, recording which happened. */
+function writeIfAbsent(projectRoot, relative, contents, report) {
+    const path = join(projectRoot, relative);
+    if (existsSync(path)) {
+        report.skipped.push(relative);
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents);
+    report.created.push(relative);
+}
+/**
+ * The matcher `.claude/settings.json` registered `command` under, when it has one. Anything
+ * unreadable, unparseable, or shaped otherwise answers `undefined` — the caller then keeps its
+ * own roster rather than narrowing the registration to a shape it could not read.
+ */
+function claudeSettingsMatcherFor(projectRoot, command) {
+    const path = join(projectRoot, CLAUDE_SETTINGS_RELATIVE);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    let root;
+    try {
+        root = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!isPlainObject(root) || !isPlainObject(root.hooks) || !Array.isArray(root.hooks.PreToolUse)) {
+        return undefined;
+    }
+    for (const entry of root.hooks.PreToolUse) {
+        if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+            continue;
+        }
+        if (entry.hooks.some((hook) => isPlainObject(hook) && hook.command === command)) {
+            return typeof entry.matcher === 'string' ? entry.matcher : undefined;
+        }
+    }
+    return undefined;
+}
+function grokHookJson(command, matcher) {
+    return `${JSON.stringify({
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher,
+                    hooks: [{ type: 'command', command, timeout: 60 }],
+                },
+            ],
+        },
+    }, null, 2)}\n`;
+}
+/**
+ * Rewrite the grok JSON `command` from the grok-mjs string to the Claude-hook string.
+ *
+ * The Claude installer calls this after writing its delegator; this installer calls it on
+ * re-run when that file is already on disk. Only the installer-generated grok-mjs command
+ * is rewritten; any other string is the consumer's spawn target and the file is not touched.
+ * Every entry naming the Claude-hook command — rewritten now or by an earlier install — takes
+ * the matcher the Claude settings file registered that command under, so the host sees one
+ * pair rather than two and a re-run converges. Parse failure leaves the file as it was —
+ * existence is presence, not parse success.
+ */
+export function retargetGrokHookCommandToClaude(projectRoot) {
+    const path = join(projectRoot, GROK_JSON_RELATIVE);
+    if (!existsSync(path)) {
+        return;
+    }
+    let root;
+    try {
+        root = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    if (!isPlainObject(root) || !isPlainObject(root.hooks) || !Array.isArray(root.hooks.PreToolUse)) {
+        return;
+    }
+    const settingsMatcher = claudeSettingsMatcherFor(projectRoot, CLAUDE_HOOK_COMMAND);
+    let changed = false;
+    for (const entry of root.hooks.PreToolUse) {
+        if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+            continue;
+        }
+        let namesClaudeHook = false;
+        for (const hook of entry.hooks) {
+            if (!isPlainObject(hook)) {
+                continue;
+            }
+            if (hook.command === GROK_HOOK_COMMAND) {
+                hook.command = CLAUDE_HOOK_COMMAND;
+                changed = true;
+            }
+            namesClaudeHook ||= hook.command === CLAUDE_HOOK_COMMAND;
+        }
+        // Whether this pass rewrote the command or an earlier install already did, an entry
+        // naming the Claude hook pairs with the settings entry only on the same matcher.
+        if (namesClaudeHook && settingsMatcher !== undefined && entry.matcher !== settingsMatcher) {
+            entry.matcher = settingsMatcher;
+            changed = true;
+        }
+    }
+    if (changed) {
+        writeFileSync(path, `${JSON.stringify(root, null, 2)}\n`);
+    }
+}
+/**
+ * Install the Grok session surface into `spec.projectRoot`, skipping whatever is already
+ * there and reporting both halves per artifact.
+ *
+ * Throws before any write when the package cannot be resolved from that root — that leaves
+ * zero files. Translating a throw into exit 2 with the install command is the bin's job.
+ */
+export function initGrok(spec) {
+    const resolvePolydeukes = spec.resolvePolydeukes ?? resolveFromProjectRoot;
+    try {
+        resolvePolydeukes(spec.projectRoot);
+    }
+    catch (error) {
+        throw new Error(`cannot use 'polydeukes' from ${spec.projectRoot} — install or update it there first ` +
+            "(e.g. 'npm install --save-dev polydeukes'), then run this command again: " +
+            `${error instanceof Error ? error.message : String(error)}`);
+    }
+    const report = scaffoldProject(spec.projectRoot);
+    const claudeHookExists = existsSync(join(spec.projectRoot, CLAUDE_HOOK_RELATIVE));
+    if (!claudeHookExists) {
+        writeIfAbsent(spec.projectRoot, GROK_HOOK_RELATIVE, GENERATED_HOOK, report);
+    }
+    const command = claudeHookExists ? CLAUDE_HOOK_COMMAND : GROK_HOOK_COMMAND;
+    const matcher = claudeHookExists
+        ? (claudeSettingsMatcherFor(spec.projectRoot, CLAUDE_HOOK_COMMAND) ?? HOOK_MATCHER)
+        : HOOK_MATCHER;
+    writeIfAbsent(spec.projectRoot, GROK_JSON_RELATIVE, grokHookJson(command, matcher), report);
+    if (claudeHookExists) {
+        retargetGrokHookCommandToClaude(spec.projectRoot);
+    }
+    return report;
+}

package/dist/load-config.d.ts

@@ -16,6 +16,10 @@ import type { ResolvedConfig } from '@polydeukes/core';
  * create a second spelling and make every later load ambiguous.
  */
 export declare const CONFIG_FILENAMES: readonly ['polydeukes.config.yaml', 'polydeukes.config.yml', 'polydeukes.config.json'];
+/** {@link loadConfig} input — the directory the config is discovered in. */
+export type LoadConfigSpec = {
+    rootDir: string;
+};
 /** `LoadedConfig` — the loader's return value. */
 export type LoadedConfig = {
     /** defineConfig() resolution — protectedPaths already includes configPath */
@@ -38,4 +42,4 @@ export type LoadedConfig = {
  * `config.protectedPaths` unless already present — the config file itself joins the
  * protection surface, guaranteed here so no assembler has to remember.
  */
-export declare function loadConfig(rootDir: string): LoadedConfig;
+export declare function loadConfig(spec: LoadConfigSpec): LoadedConfig;

package/dist/load-config.js

@@ -38,7 +38,8 @@ export const CONFIG_FILENAMES = [
  * `config.protectedPaths` unless already present — the config file itself joins the
  * protection surface, guaranteed here so no assembler has to remember.
  */
-export function loadConfig(rootDir) {
+export function loadConfig(spec) {
+    const { rootDir } = spec;
     const found = CONFIG_FILENAMES.filter((name) => existsSync(join(rootDir, name)));
     if (found.length === 0) {
         throw new Error(`no Polydeukes config found in ${rootDir} — expected one of: ${CONFIG_FILENAMES.join(', ')}`);

package/dist/pre-state-reader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The pre-state readers the two surfaces inject into the discipline compiler — the disk
+ * access that the judge package must not carry.
+ */
+/**
+ * The session surface's reader: the hook runs before the tool does, so the working tree at
+ * an absolute location IS the pre-state.
+ *
+ * Three answers, three consequences. Text is a modify; `null` — the file is not there — is a
+ * create, so nothing is forgiven as pre-existing debt; `undefined` is a location that cannot
+ * be read at all, which the judge escalates to the fail-closed exit. A permission error or a
+ * race collapsed into either of the first two would record the run as `passed`.
+ */
+export declare function sessionPreStateReader(location: string): string | null | undefined;
+/**
+ * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * pre their own observation saw, and it registers no shell axis — so no derivation ever asks
+ * for a pre-state here. Should one arrive, the working tree is not what this surface judges,
+ * and answering from it would compare the diff against the wrong baseline; `undefined` says
+ * so and fails that call closed.
+ */
+export declare function unobservedPreStateReader(): undefined;

package/dist/pre-state-reader.js

@@ -0,0 +1,32 @@
+/**
+ * The pre-state readers the two surfaces inject into the discipline compiler — the disk
+ * access that the judge package must not carry.
+ */
+import { readFileSync } from 'node:fs';
+/**
+ * The session surface's reader: the hook runs before the tool does, so the working tree at
+ * an absolute location IS the pre-state.
+ *
+ * Three answers, three consequences. Text is a modify; `null` — the file is not there — is a
+ * create, so nothing is forgiven as pre-existing debt; `undefined` is a location that cannot
+ * be read at all, which the judge escalates to the fail-closed exit. A permission error or a
+ * race collapsed into either of the first two would record the run as `passed`.
+ */
+export function sessionPreStateReader(location) {
+    try {
+        return readFileSync(location, 'utf-8');
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? null : undefined;
+    }
+}
+/**
+ * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * pre their own observation saw, and it registers no shell axis — so no derivation ever asks
+ * for a pre-state here. Should one arrive, the working tree is not what this surface judges,
+ * and answering from it would compare the diff against the wrong baseline; `undefined` says
+ * so and fails that call closed.
+ */
+export function unobservedPreStateReader() {
+    return undefined;
+}

package/dist/scaffold-project.js

@@ -50,9 +50,9 @@ languages:
 # The protection list. A tool call whose proven target is one of these paths is blocked, and
 # so is a shell command that mentions one without a read-only head.
 #
-#   .claude/hooks, .claude/settings.json — the gate definitions themselves. Editing them
-#     does not evade a judgment, it removes the judgment; the session surface is the only
-#     layer that can watch it happen.
+#   .claude/hooks, .claude/settings.json, .grok/hooks — the gate definitions themselves.
+#     Editing them does not evade a judgment, it removes the judgment; the session surface
+#     is the only layer that can watch it happen.
 #
 # A minimum. Add entries as you find you want them.
 #
@@ -61,6 +61,7 @@ languages:
 protectedPaths:
   - '.claude/hooks'
   - '.claude/settings.json'
+  - '.grok/hooks'
 
 # The time-boxed witness — the human valve on a blocked verdict. A human types this token so
 # it stands alone on a message's FIRST line, the window holds for ttlMinutes, then blocking
@@ -68,9 +69,9 @@ protectedPaths:
 # window is always recorded as \`witnessed\` and never silent, and no agent can open one for
 # itself. The token is not a secret: the defence is provenance, not confidentiality.
 #
-# Keep this block. Without it no block can be opened by anyone, and .claude/hooks is on the
-# list above — so the first block would freeze the project until a human edits these files
-# from their own terminal.
+# Keep this block. Without it no block can be opened by anyone, and the hook directories
+# are on the list above — so the first block would freeze the project until a human edits
+# these files from their own terminal.
 witness:
   token: 'pdks witness'
   ttlMinutes: 10
@@ -86,15 +87,54 @@ witness:
 #
 #   # Promoted to a judgment. Advise is the default — recorded as \`advised\`, never stops
 #   # the call — so this line is optional; it is written here to show the rung.
+#   #
+#   # The declaration keys each side's matched lines by the matched text and breaks on what
+#   # the edit ADDED, so occurrences already in the tree are forgiven.
 #   - id: 'no-todo-in-shipped-code'
 #     why: 'a TODO nobody owns is a decision deferred out of sight'
-#     forbid: 'TODO'
+#     declare:
+#       mechanism: 'added-only'
+#       scope: { source: 'target.path', include: ['^src/'] }
+#       supply: { pre: 'empty', post: 'empty' }
+#       extract:
+#         before:
+#           - { op: 'source', of: 'pre' }
+#           - { op: 'lines' }
+#           - { op: 'keyByPattern', re: '(TODO)' }
+#         after:
+#           - { op: 'source', of: 'post' }
+#           - { op: 'lines' }
+#           - { op: 'keyByPattern', re: '(TODO)' }
+#         added:
+#           - { op: 'onlyIn', of: 'after', notIn: 'before' }
+#       relate:
+#         - id: 'nothing-added'
+#           relation: { op: 'empty', of: 'added' }
+#           message: 'adds {key}: {value}'
 #     enforce: advise
 #
 #   # The promotion — block is your choice, never the default.
 #   - id: 'no-todo-in-shipped-code-blocking'
 #     why: 'a TODO nobody owns is a decision deferred out of sight'
-#     forbid: 'TODO'
+#     declare:
+#       mechanism: 'added-only'
+#       scope: { source: 'target.path', include: ['^src/'] }
+#       supply: { pre: 'empty', post: 'empty' }
+#       extract:
+#         before:
+#           - { op: 'source', of: 'pre' }
+#           - { op: 'lines' }
+#           - { op: 'keyByPattern', re: '(TODO)' }
+#         after:
+#           - { op: 'source', of: 'post' }
+#           - { op: 'lines' }
+#           - { op: 'keyByPattern', re: '(TODO)' }
+#         added:
+#           - { op: 'onlyIn', of: 'after', notIn: 'before' }
+#       relate:
+#         - id: 'nothing-added'
+#           relation: { op: 'empty', of: 'added' }
+#           message: 'adds {key}: {value}'
 #     enforce: block
 `;
 /** The schema's path from a config sitting in `projectRoot`, as the directive spells it. */

package/dist/schema/polydeukes.schema.json

@@ -104,32 +104,8 @@
       "description": "The entry's own level. 'advise' records a break without stopping it; 'block' pins the entry at block. Composes with the surface's level, the lenient side winning; absent means advise; 'block' is the promotion rung.",
       "enum": ["block", "advise"]
     },
-    "globOrGlobs": {
-      "anyOf": [
-        { "type": "string", "minLength": 1 },
-        {
-          "type": "array",
-          "minItems": 1,
-          "items": { "type": "string", "minLength": 1 }
-        }
-      ]
-    },
-    "requirePrecedent": {
-      "description": "Context family — the session evidence one edit requires beforehand. Exactly one evidence key. The core owns and fully validates 'command'; every other key is adapter vocabulary whose value passes through verbatim (unconstrained here, judged by that adapter).",
-      "type": "object",
-      "minProperties": 1,
-      "maxProperties": 1,
-      "properties": {
-        "command": {
-          "description": "Core evidence vocabulary — regex over the shell command strings observed in the session.",
-          "type": "string",
-          "minLength": 1,
-          "format": "regex"
-        }
-      }
-    },
     "discipline": {
-      "description": "One discipline entry — exactly one predicate family (forbid | immutable | forbidCommand | requirePrecedent), or a draft (id + why + draft: true, no predicate); in/except scope the forbid and requirePrecedent families, and when scopes requirePrecedent only.",
+      "description": "One discipline entry — a judged entry (id + declare, optionally why and enforce), or a draft (id + why + draft: true, no declaration).",
       "oneOf": [
         {
           "type": "object",
@@ -151,79 +127,50 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": ["id", "forbid"],
-          "properties": {
-            "id": { "$ref": "#/$defs/disciplineId" },
-            "why": { "$ref": "#/$defs/disciplineWhy" },
-            "enforce": { "$ref": "#/$defs/enforceLevel" },
-            "in": { "$ref": "#/$defs/globOrGlobs" },
-            "except": { "$ref": "#/$defs/globOrGlobs" },
-            "forbid": {
-              "description": "Delta family — string shorthand is equivalent to { added }.",
-              "anyOf": [
-                { "type": "string", "minLength": 1, "format": "regex" },
-                {
-                  "type": "object",
-                  "additionalProperties": false,
-                  "required": ["added"],
-                  "properties": {
-                    "added": { "type": "string", "minLength": 1, "format": "regex" }
-                  }
-                }
-              ]
-            }
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "required": ["id", "immutable"],
-          "properties": {
-            "id": { "$ref": "#/$defs/disciplineId" },
-            "why": { "$ref": "#/$defs/disciplineWhy" },
-            "enforce": { "$ref": "#/$defs/enforceLevel" },
-            "immutable": {
-              "description": "Path family — its own glob is the scope.",
-              "$ref": "#/$defs/globOrGlobs"
-            }
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "required": ["id", "forbidCommand"],
-          "properties": {
-            "id": { "$ref": "#/$defs/disciplineId" },
-            "why": { "$ref": "#/$defs/disciplineWhy" },
-            "enforce": { "$ref": "#/$defs/enforceLevel" },
-            "forbidCommand": {
-              "description": "Command family — regex over shell command strings.",
-              "type": "string",
-              "minLength": 1,
-              "format": "regex"
-            }
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "required": ["id", "requirePrecedent"],
+          "required": ["id", "declare"],
           "properties": {
             "id": { "$ref": "#/$defs/disciplineId" },
             "why": { "$ref": "#/$defs/disciplineWhy" },
             "enforce": { "$ref": "#/$defs/enforceLevel" },
-            "in": { "$ref": "#/$defs/globOrGlobs" },
-            "except": { "$ref": "#/$defs/globOrGlobs" },
-            "when": {
-              "description": "Context-family trigger — added-direction delta regex. Absent means every in-scope change triggers.",
-              "type": "string",
-              "minLength": 1,
-              "format": "regex"
-            },
-            "requirePrecedent": { "$ref": "#/$defs/requirePrecedent" }
+            "declare": { "$ref": "#/$defs/declarationBody" }
           }
         }
       ]
+    },
+    "declarationBody": {
+      "description": "Declaration family — one judgment written as data, in the grammar of the algebra declaration schema published beside this one, minus its 'discipline' key: the entry id is the declaration's name. The blocks' interiors are validated against that schema by the runtime validator.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["mechanism", "extract", "relate"],
+      "properties": {
+        "mechanism": {
+          "enum": [
+            "pairing",
+            "companion",
+            "monotonic-order",
+            "fingerprint-sync",
+            "producer-owned",
+            "self-absolution-ban",
+            "actor-scope",
+            "precedent",
+            "phase-order",
+            "turn-locality",
+            "stated-ground",
+            "controlled-vocabulary",
+            "naming",
+            "added-only",
+            "one-way-marker",
+            "scoped-valve",
+            "forbidden-command"
+          ]
+        },
+        "scope": { "type": "object" },
+        "sources": { "type": "object" },
+        "supply": { "type": "object" },
+        "extract": { "type": "object", "minProperties": 1 },
+        "relate": { "type": "array", "minItems": 1 },
+        "witness": { "type": "object" }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydeukes",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "A development discipline framework for building alongside an AI coding partner — deterministic covenants, a verifiable work ledger, local memory, and adversarial verification. Alpha.",
   "keywords": [
     "harness",
@@ -37,8 +37,8 @@
       "import": "./dist/index.js"
     },
     "./claude-code": {
-      "types": "./dist/claude-code-hook.d.ts",
-      "import": "./dist/claude-code-hook.js"
+      "types": "./dist/claude-code.d.ts",
+      "import": "./dist/claude-code.js"
     },
     "./schema.json": "./dist/schema/polydeukes.schema.json"
   },
@@ -54,10 +54,10 @@
   },
   "dependencies": {
     "yaml": "2.9.0",
-    "@polydeukes/adapter-claude-code": "^0.5.0",
-    "@polydeukes/adapter-git": "^0.5.0",
-    "@polydeukes/covenant": "^0.5.0",
-    "@polydeukes/core": "^0.5.0"
+    "@polydeukes/adapter-claude-code": "^0.6.1",
+    "@polydeukes/core": "^0.6.1",
+    "@polydeukes/covenant": "^0.6.1",
+    "@polydeukes/adapter-git": "^0.6.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",