polydeukes 0.6.1 → 0.7.1

package/dist/docs/troubleshooting.ko.md

@@ -11,8 +11,8 @@
 
 프로젝트 루트 바로 아래에 `polydeukes.config.yaml`, `polydeukes.config.yml`,
 `polydeukes.config.json` 중 하나도 없으면 설정이 필요한 명령은 종료 코드 2를 반환합니다.
-Git에서 원래 파일을 복원하세요. 새 프로젝트라면 `pdks init claude-code` 또는
-`pdks init grok`로 만들 수 있습니다. 이후 `pdks explain`을 실행합니다. 설정이 없다고
+Git에서 원래 파일을 복원하세요. 새 프로젝트라면 `pdks init`, `pdks-claude-code init`,
+`pdks-grok init`로 만들 수 있습니다. 이후 `pdks explain`을 실행합니다. 설정이 없다고
 기본 정책으로 대신 실행하지는 않습니다.
 
 <a id="multiple-config"></a>
@@ -31,15 +31,15 @@ Git에서 원래 파일을 복원하세요. 새 프로젝트라면 `pdks init cl
 설정은 실행할 코드가 아니라 데이터이기 때문입니다.
 
 `protectedPath:`나 `adaptors:` 같은 오타는 거부합니다. 다만 어댑터 이름에는 확장 가능성을
-남겨 두었습니다. `adapters.gti:`도 설정으로 읽히지만 Git 어댑터는 사용하지 않습니다.
-올바른 키는 `adapters.git`입니다. 수정한 뒤 `pdks explain`에서 실제 등록 내용을 확인하세요.
+남겨 두었습니다. 아무도 구현하지 않은 네임스페이스도 설정으로 읽히지만 읽는 쪽이 없습니다.
+수정한 뒤 `pdks explain`에서 실제 등록 내용을 확인하세요.
 
 <a id="grok-witness"></a>
 ## Grok 증인
 
 훅을 아직 읽지 않은 문제와 증인(witness) 밸브를 사용할 수 없는 문제는 구별해야 합니다.
 
-- `pdks init grok` 실행 뒤 Hooks 탭을 다시 불러오거나 새 세션을 시작하세요. 실제 도구를
+- `pdks-grok init` 실행 뒤 Hooks 탭을 다시 불러오거나 새 세션을 시작하세요. 실제 도구를
   호출하고 텔레메트리를 확인합니다. 설치기가 성공했다고 해서 열린 세션에 훅이 적용됐다는
   뜻은 아닙니다.
 - Grok의 ACP 대화 기록에는 현재 세션 증인 밸브가 요구하는 Claude 형식의 인간 메시지가
@@ -105,19 +105,21 @@ covenant check failed closed: the covenant judges could not be loaded from …
 <a id="blocked-commit"></a>
 ## 커밋이 차단됐을 때
 
-본인의 터미널에서 커밋을 실행하고 TTY 프롬프트에 설정된 토큰 전체를 입력하세요.
-비대화형 스테이징 검사는 이 응답을 받을 수 없습니다. 검사가 작업을 거부하면 종료 코드 2를
-반환합니다. Git은 커밋 실패를 다른 0이 아닌 코드로 알릴 수도 있습니다.
+변경 집합 표면은 사람에게 묻지 않습니다. 기본값에서는 모든 판정에 종료 코드 0을 내고 위반을
+`advised`로 기록합니다. 종료 코드 2는 검사를 `--enforce block`으로 실행했을 때(보호 경로나
+`enforce: block` 항목의 위반) 또는 판정 자체가 불가능할 때만 냅니다. 커밋을 멈출지는 훅
+배선이 정합니다. 종료 코드를 따르는 훅은 커밋을 멈추고, 무시하는 훅은 멈추지 않습니다. Git은
+커밋 실패를 다른 0이 아닌 코드로 알릴 수도 있습니다.
 
-일반 규율 항목은 자체 수준과 어댑터 수준이 모두 차단을 허용해야 작업을 멈춥니다.
-`adapters.git.enforce: block`만 설정해도 기본값 `advise`인 항목이 자동 승격되지는 않습니다.
-수준 변경은 정책을 바꾸는 결정이지 필수 복구 절차가 아닙니다. 커밋 프롬프트와 세션 메시지는
-서로 별개의 증인 입력 경로입니다.
+일반 규율 항목은 자신이 `enforce: block`을 적고 검사가 `--enforce block`으로 실행될 때만
+작업을 멈춥니다. 설정에는 기본값 `advise`인 항목을 승격하는 것이 없습니다. 수준 변경은
+정책을 바꾸는 결정이지 필수 복구 절차가 아닙니다. 판정된 위반을 통과시키려면 설정이 아니라
+훅 명령에서 `--enforce block`을 빼세요. 행은 그대로 남습니다.
 
-<a id="skipped-rows-on-the-commit-surface"></a>
-## 커밋 표면의 미판정 기록
+<a id="skipped-rows-on-the-change-set-surface"></a>
+## 변경 집합 표면의 미판정 기록
 
-대화 기록을 읽는 선언에 `supply: { session: 'pass' }`가 있으면 세션이 없는 커밋 표면에서는
+대화 기록을 읽는 선언에 `supply: { session: 'pass' }`가 있으면 세션이 없는 변경 집합 표면에서는
 `supply-pass`를 기록합니다. 이 약속은 세션 표면에서 확인하세요. 미판정은 과거 작업을
 검증했다는 뜻이 아닙니다. 다른 채널을 공급할 수 없으면 `no-observation`이 나올 수도
 있습니다. 모든 자료 부재를 같은 실패로 취급하지 말고 등록 내용과 사유를 확인하세요.

package/dist/docs/troubleshooting.md

@@ -11,8 +11,9 @@ or the judging packages, provided its own installed documentation bundle is inta
 
 Commands that need configuration exit 2 when none of `polydeukes.config.yaml`,
 `polydeukes.config.yml`, or `polydeukes.config.json` exists directly at the project root.
-Restore the intended file from Git, or use `pdks init claude-code` / `pdks init grok` for a new
-project. Then run `pdks explain`. No configuration means no silent default policy.
+Restore the intended file from Git, or use `pdks init` / `pdks-claude-code init` /
+`pdks-grok init` for a new project. Then run `pdks explain`. No configuration means no silent
+default policy.
 
 <a id="multiple-config"></a>
 ## More than one config file
@@ -28,15 +29,15 @@ field. Repair invalid YAML, custom tags, unknown fields, or an empty `languages`
 Custom YAML tags are rejected even if the parser cannot execute them: configuration is data.
 
 Typos such as `protectedPath:` or `adaptors:` are refused. Adapter namespace names are deliberately
-open, however: `adapters.gti:` can load but is not read by the Git adapter. Its actual key is
-`adapters.git`. After repair, run `pdks explain` and check the assembled registrations.
+open, however: a namespace nobody implements loads without being read by anything. After repair,
+run `pdks explain` and check the assembled registrations.
 
 <a id="grok-witness"></a>
 ## Grok witness
 
 A hook not yet loaded and an unavailable witness valve are different problems:
 
-- After `pdks init grok`, reload the Hooks tab or start a new session. Verify an actual call and
+- After `pdks-grok init`, reload the Hooks tab or start a new session. Verify an actual call and
   its telemetry; a successful installer run does not prove the open host loaded the hook.
 - Grok's ACP history does not supply the Claude-format human message required by the current
   session witness valve. Reloading does not add that capability. Perform a necessary repair
@@ -101,19 +102,22 @@ A witness cannot repair missing modules or other failures that prevent judgment
 <a id="blocked-commit"></a>
 ## A blocked commit
 
-Run the commit from your own terminal and answer its TTY prompt with the complete configured
-token. A non-interactive staged check cannot obtain that answer. The check exits 2 when it refuses;
-Git may report a different nonzero exit code for the failed commit.
+The change-set surface does not prompt. By default it exits 0 on every verdict and records the
+break as `advised`; it exits 2 only when the check runs with `--enforce block` (a protected
+path or an entry set to `enforce: block` broke) or when it could not judge at all. Whether the
+commit stops is your hook wiring — a hook that honours the exit code stops it, one that ignores
+it does not. Git may report a different nonzero exit code for the failed commit.
 
-A normal entry blocks only when its own level and the adapter's level both permit blocking.
-Setting only `adapters.git.enforce: block` does not promote default-`advise` entries. Changing a
-level is a policy decision, not a required repair. The prompt is separate from a session message.
+A normal entry blocks only when it declares `enforce: block` and the check runs with
+`--enforce block`; nothing in the config promotes a default-`advise` entry. Changing a level is
+a policy decision, not a required repair. To let a judged break through, drop `--enforce block`
+from the hook command rather than editing the config — the row is still written.
 
-<a id="skipped-rows-on-the-commit-surface"></a>
-## `skipped` rows on the commit surface
+<a id="skipped-rows-on-the-change-set-surface"></a>
+## `skipped` rows on the change-set surface
 
 A transcript-reading declaration with `supply: { session: 'pass' }` records `supply-pass` when the
-commit surface has no session. Use the session surface for that promise; a skip does not verify
+change-set surface has no session. Use the session surface for that promise; a skip does not verify
 history. Other unavailable channels can produce `no-observation`. Inspect the registration and
 reason instead of treating every missing source as the same failure.
 

package/dist/docs/tutorials/first-judgment.ko.md

@@ -17,8 +17,8 @@ mkdir pdks-example
 cd pdks-example
 git init
 printf '{"name":"pdks-example","private":true}\n' > package.json
-pnpm add -D polydeukes   # 프로젝트 의존성. 일회성 npx 실행이 아님
-pnpm exec pdks init claude-code
+pnpm add -D polydeukes @polydeukes/adapter-claude-code   # 프로젝트 의존성. 일회성 npx 실행이 아님
+pnpm exec pdks-claude-code init
 ```
 
 설치기는 각 파일을 만들었으면 `created`, 이미 있어서 보존했으면 `skipped`로 보고합니다.

package/dist/docs/tutorials/first-judgment.md

@@ -17,8 +17,8 @@ mkdir pdks-example
 cd pdks-example
 git init
 printf '{"name":"pdks-example","private":true}\n' > package.json
-pnpm add -D polydeukes   # a project dependency, not a one-off npx run
-pnpm exec pdks init claude-code
+pnpm add -D polydeukes @polydeukes/adapter-claude-code   # project dependencies, not a one-off npx run
+pnpm exec pdks-claude-code init
 ```
 
 The installer reports `created` or `skipped` for each artifact. It creates a starter config,

package/dist/explain.d.ts

@@ -17,7 +17,7 @@ export type ExplainSpec = {
  * Read the config at `repoRoot`, assemble both surfaces, and render them.
  *
  * The session assembly is given a transcript path, so its `transcript-mod` registration
- * exists here exactly as it does under a normal hook payload — the path is never read,
+ * exists here exactly as it does under a normal call payload — the path is never read,
  * because the injected transcript is the no-op one.
  */
 export declare function explain(spec: ExplainSpec): Promise<{

package/dist/explain.js

@@ -9,15 +9,18 @@
  * nothing and reads no disk. Every failure throws: an answer that cannot be given is never
  * given halfway.
  */
-import { join } from 'node:path';
-import { resolveGitAdapterSettings } from '@polydeukes/adapter-git';
 import { AXIS_NAMES, deriveShape, noopTranscript, RELATION_NAMES } from '@polydeukes/core';
-import { assembleSessionRegistrations } from './claude-code-hook.js';
-import { assembleCommitRegistrations } from './covenant-check.js';
-import { loadCovenantModule, resolveCovenantDist } from './covenant-module.js';
+import { covenantModule } from './covenant/module.js';
+import { assembleChangeSetRegistrations, assembleCheckRegistrations } from './covenant-check.js';
 import { loadConfig } from './load-config.js';
 /** The three meta-covenant labels: registrations that protect the judging chain itself. */
 const META_LABELS = new Set(['self-mod', 'shell-mod', 'transcript-mod']);
+/**
+ * What the session assembly here is given as its evidence path. The real one is loaded per
+ * call by an adapter, so this renderer names the IR key instead of a file: the assembly
+ * needs a present value to build the conditional registration, and nothing prints it.
+ */
+const SESSION_EVIDENCE_PATH_KEY = 'session.evidencePath';
 /**
  * The description of a declaration entry: its catalogue coordinate (the mechanism, the axes
  * its sources derive, and the relations its entries decide), then what it routes on, how
@@ -58,7 +61,7 @@ function row(kind, label, width, description) {
 /** The description of a meta-covenant registration — how much surface it covers. */
 function metaDescription(registration, surface) {
     if (registration.label === 'transcript-mod') {
-        return 'content predicate · conditional: transcript_path';
+        return 'content predicate · conditional: session.evidencePath';
     }
     return `paths ${registration.protectedPaths.length} (${surface})`;
 }
@@ -105,47 +108,59 @@ function renderSurface(spec) {
  * Read the config at `repoRoot`, assemble both surfaces, and render them.
  *
  * The session assembly is given a transcript path, so its `transcript-mod` registration
- * exists here exactly as it does under a normal hook payload — the path is never read,
+ * exists here exactly as it does under a normal call payload — the path is never read,
  * because the injected transcript is the no-op one.
  */
 export async function explain(spec) {
     const { config, configPath } = loadConfig({ rootDir: spec.repoRoot });
-    // Resolved and imported exactly as the two runners do, so what this renders is the table
-    // that would judge: a dist those runners would refuse cannot be rendered as if it worked.
-    // The load names the missing module and the recovery command.
-    const covenant = await loadCovenantModule(resolveCovenantDist());
-    const disciplines = config.disciplines ?? [];
+    // The judge module the two runners assemble against, so what this renders is the table
+    // that would judge.
+    const covenant = covenantModule;
+    const shared = config.disciplines ?? [];
+    const sessionOnly = config.sessionDisciplines ?? [];
+    const changeSetOnly = config.changeSetDisciplines ?? [];
     const drafts = config.drafts ?? [];
-    const session = assembleSessionRegistrations({
+    const session = assembleCheckRegistrations({
         config,
         rootDir: spec.repoRoot,
         covenant,
-        transcriptPath: join(spec.repoRoot, 'transcript.jsonl'),
+        surface: 'session',
+        // The session key alone, and no roster: a roster is what an adapter loads onto each
+        // call, so a reader of the config would be shown one agent's names chosen by this
+        // renderer. The evidence path is the same kind of per-call value and is named by the
+        // key rather than by a filename: what a config reader is being shown is that the
+        // session surface carries a transcript-mod registration, and the renderer prints the
+        // key, never the path. The empty lists are the session a run supplies.
+        session: { evidencePath: SESSION_EVIDENCE_PATH_KEY, userMessages: [], toolCalls: [] },
         transcript: noopTranscript,
     });
-    const commit = assembleCommitRegistrations({
+    const changeSet = assembleChangeSetRegistrations({
         config,
         rootDir: spec.repoRoot,
         covenant,
+        surface: 'changeSet',
     });
-    const gitSettings = resolveGitAdapterSettings({ namespace: config.adapters?.git });
     const text = [
         `pdks explain — ${configPath}`,
         '',
         renderSurface({
-            header: 'surface: session (claude-code hook) · disciplines: advise unless enforce: block · meta: block',
+            header: 'input: call IR (one call, stdin) · ' +
+                `disciplines ${shared.length} · sessionDisciplines ${sessionOnly.length} · ` +
+                'disciplines: advise unless enforce: block · meta: block',
             registrations: session,
             drafts,
-            disciplines,
+            disciplines: [...shared, ...sessionOnly],
             selfModScope: 'common; includes the config file itself',
         }),
         '',
         renderSurface({
-            header: `surface: commit (git pre-commit) · enforce: ${gitSettings.enforce} · disciplines: advise unless enforce: block`,
-            registrations: commit,
+            header: 'input: --diff (change set, stdin) · ' +
+                `disciplines ${shared.length} · changeSetDisciplines ${changeSetOnly.length} · ` +
+                'disciplines: advise unless enforce: block',
+            registrations: changeSet,
             drafts,
-            disciplines,
-            selfModScope: 'common ∪ adapters.git; deduped, includes the config file itself',
+            disciplines: [...shared, ...changeSetOnly],
+            selfModScope: 'common; includes the config file itself',
         }),
         '',
     ].join('\n');

package/dist/load-config.d.ts

@@ -4,7 +4,7 @@
  *
  * This lives in its own module rather than in the package barrel because ESM re-exports are
  * eager: importing `loadConfig` from the barrel would instantiate both composition roots,
- * putting the session adapter on the commit surface's load path where it is never used. A
+ * putting the session adapter on the change-set surface's load path where it is never used. A
  * workspace missing only that dist would then kill `pdks covenant check` before its
  * fail-closed handler could record a row. Both composition roots import this module directly
  * for the same reason.

package/dist/load-config.js

@@ -4,7 +4,7 @@
  *
  * This lives in its own module rather than in the package barrel because ESM re-exports are
  * eager: importing `loadConfig` from the barrel would instantiate both composition roots,
- * putting the session adapter on the commit surface's load path where it is never used. A
+ * putting the session adapter on the change-set surface's load path where it is never used. A
  * workspace missing only that dist would then kill `pdks covenant check` before its
  * fail-closed handler could record a row. Both composition roots import this module directly
  * for the same reason.

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

@@ -13,7 +13,7 @@
  */
 export declare function sessionPreStateReader(location: string): string | null | undefined;
 /**
- * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * The change-set 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

package/dist/pre-state-reader.js

@@ -21,7 +21,7 @@ export function sessionPreStateReader(location) {
     }
 }
 /**
- * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * The change-set 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

package/dist/scaffold-project.d.ts

@@ -3,8 +3,8 @@
  *
  * The half of an installation every distribution path shares: the data config the judges
  * read, and the telemetry ignore line. What differs between paths is REGISTRATION — how the
- * agent is told to spawn a judge at all — and that lives one layer up (`initClaudeCode` for
- * the `init` path). The split is what lets a second path reuse this function unchanged
+ * agent is told to spawn a judge at all — and that lives in each agent's own adapter
+ * installer. The split is what lets a second path reuse this function unchanged
  * instead of scaffolding a config a second time, so nothing that registers anything belongs
  * here.
  *

package/dist/scaffold-project.js

@@ -3,8 +3,8 @@
  *
  * The half of an installation every distribution path shares: the data config the judges
  * read, and the telemetry ignore line. What differs between paths is REGISTRATION — how the
- * agent is told to spawn a judge at all — and that lives one layer up (`initClaudeCode` for
- * the `init` path). The split is what lets a second path reuse this function unchanged
+ * agent is told to spawn a judge at all — and that lives in each agent's own adapter
+ * installer. The split is what lets a second path reuse this function unchanged
  * instead of scaffolding a config a second time, so nothing that registers anything belongs
  * here.
  *
@@ -32,7 +32,7 @@ const GITIGNORE_ENTRY = `# Polydeukes telemetry — local observation data, neve
  * {@link schemaDirective} prepends the `yaml-language-server` line when the schema is where
  * that line would name it.
  */
-const GENERATED_CONFIG = `# Polydeukes protection policy — generated by \`pdks init claude-code\`.
+const GENERATED_CONFIG = `# Polydeukes protection policy — generated by \`pdks init\`.
 #
 # This file is data, never code. The judges read it, every verdict traces back to an entry
 # below, and editing it is how you change what is judged.
@@ -79,6 +79,12 @@ witness:
 # The disciplines you judge by, and the three rungs one climbs — shown as three entries so
 # each rung is a line you can copy. Uncomment to start; ids must stay distinct.
 #
+# Three lists, chosen by what a declaration reads. \`disciplines:\` is judged on both
+# surfaces (the changed file's own pre/post and file sources). \`sessionDisciplines:\` is
+# judged only where a live call is observed before it runs (command line, transcript,
+# actor). \`changeSetDisciplines:\` is judged only over a finished change set
+# (\`--diff\`). The loader refuses an entry written in a list its channels do not fit.
+#
 # disciplines:
 #   # A draft: prose only, no predicate. Registered and read, never judged.
 #   - id: 'no-todo-in-shipped-code-draft'

package/dist/schema/polydeukes.schema.json

@@ -33,6 +33,18 @@
       "uniqueItems": true,
       "items": { "$ref": "#/$defs/discipline" }
     },
+    "sessionDisciplines": {
+      "description": "Disciplines only the session surface observes — every entry whose declaration binds a transcript, channel, command, or actor evidence channel. Fully identical entries are copy-paste duplicates (by-id uniqueness and the placement rule are enforced by the runtime validator).",
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/discipline" }
+    },
+    "changeSetDisciplines": {
+      "description": "Disciplines only the change-set surface observes — every entry whose declaration binds the changes source. Fully identical entries are copy-paste duplicates (by-id uniqueness and the placement rule are enforced by the runtime validator).",
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/discipline" }
+    },
     "witness": { "$ref": "#/$defs/witness" }
   },
   "$defs": {

package/dist/worktree-reader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The change-set surface's supply body for named file sources — one repo-relative path read from
+ * the working tree.
+ */
+import type { SourceReader } from '@polydeukes/core';
+/** {@link worktreeReader} input — the repository the paths are relative to. */
+export type WorktreeReaderSpec = {
+    repoRoot: string;
+};
+/**
+ * A reader over the working tree under `repoRoot`, with the same absence table the session
+ * surface's disk reader pins in its own package.
+ *
+ * Symlinks are followed: on disk the observable fact IS the target's text, and the session
+ * surface reads the same way. A path the tree holds but cannot give as judgeable text —
+ * a directory, or bytes carrying a NUL — answers `undefined`, which the declaration's
+ * `supply` policy disposes of.
+ */
+export declare function worktreeReader(spec: WorktreeReaderSpec): SourceReader;

package/dist/worktree-reader.js

@@ -0,0 +1,30 @@
+/**
+ * The change-set surface's supply body for named file sources — one repo-relative path read from
+ * the working tree.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * A reader over the working tree under `repoRoot`, with the same absence table the session
+ * surface's disk reader pins in its own package.
+ *
+ * Symlinks are followed: on disk the observable fact IS the target's text, and the session
+ * surface reads the same way. A path the tree holds but cannot give as judgeable text —
+ * a directory, or bytes carrying a NUL — answers `undefined`, which the declaration's
+ * `supply` policy disposes of.
+ */
+export function worktreeReader(spec) {
+    return (path) => {
+        let bytes;
+        try {
+            bytes = readFileSync(join(spec.repoRoot, path));
+        }
+        catch (error) {
+            const { code } = error;
+            if (code === 'ENOENT' || code === 'EISDIR' || code === 'ENOTDIR')
+                return undefined;
+            throw error;
+        }
+        return bytes.includes(0) ? undefined : bytes.toString('utf-8');
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydeukes",
-  "version": "0.6.1",
+  "version": "0.7.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",
@@ -28,18 +28,7 @@
     "pdks": "./dist/bin.js",
     "polydeukes": "./dist/bin.js"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./claude-code": {
-      "types": "./dist/claude-code.d.ts",
-      "import": "./dist/claude-code.js"
-    },
     "./schema.json": "./dist/schema/polydeukes.schema.json"
   },
   "files": [
@@ -54,15 +43,12 @@
   },
   "dependencies": {
     "yaml": "2.9.0",
-    "@polydeukes/adapter-claude-code": "^0.6.1",
-    "@polydeukes/core": "^0.6.1",
-    "@polydeukes/covenant": "^0.6.1",
-    "@polydeukes/adapter-git": "^0.6.1"
+    "@polydeukes/core": "^0.7.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
     "typescript": "7.0.2",
-    "vitest": "^4.1.0"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/copy-docs.mjs && node scripts/copy-schema.mjs",

package/dist/claude-code-hook.d.ts

@@ -1,79 +0,0 @@
-/**
- * `runClaudeCodeHook` — the assembled session-surface judgment runner.
- *
- * The session counterpart of {@link runCovenantCheck}, and the one place where the Claude
- * Code adapter (tool vocabulary, up-translation) and the covenant package (dispatcher +
- * judge bodies) meet. Packages stay one-way — each depends only on core — so their
- * composition lives here, in the umbrella, and the repository's PreToolUse hook shrinks to
- * a delegator that calls this function. That is what makes the session surface installable:
- * a consumer registers a hook that resolves this package instead of copying assembly.
- *
- * The protection-policy data (protectedPaths / disciplines / witness) is read from the root
- * data config through {@link loadConfig}, which also attaches the config file to its own
- * surface.
- *
- * The valve is the TTL witness, judged over the JSONL transcript provider. The judge body
- * always spawns, and only an outcome that translated to blocked consults the witness —
- * `witnessed` rows are would-block only. Its defence is provenance rather than secrecy: only
- * a real human utterance carries the transcript marking `findUserMessages()` admits.
- *
- * fail-closed: ANY failure — an unbuilt judge body, an unreadable stdin, a missing or
- * invalid config file — resolves to `{ exitCode: 2 }` with one `blocked` record under the
- * `hook` label. Nothing throws: an uncaught rejection would exit the delegator non-blocking,
- * the cheapest bypass vector there is. Recovery from an unbuilt clone is `pnpm build` (it
- * mentions no protected path, so it is never blocked).
- */
-import { type CanonicalTranscript } from '@polydeukes/core';
-import { type CovenantRegistration } from '@polydeukes/covenant';
-import { type CovenantModule } from './covenant-module.ts';
-import { loadConfig } from './load-config.ts';
-/** {@link runClaudeCodeHook} result — the exit code the hook process leaves with. */
-export type ClaudeCodeHookOutcome = {
-    exitCode: 0 | 2;
-};
-/** `runClaudeCodeHook` input — the `CovenantCheckSpec` shape, session side. */
-export type ClaudeCodeHookSpec = {
-    /** Repository root — config discovery and discipline glob scoping both anchor here. */
-    repoRoot: string;
-    /** One raw PreToolUse payload. ABSENT means read fd 0 (the hook's real stdin). */
-    rawPayload?: string;
-    /** Overrides the config's telemetry log path (tests and assembly injection). */
-    telemetryPath?: string;
-    /** Overrides the resolved covenant dist directory (tests and assembly injection). */
-    covenantDist?: string;
-};
-/** {@link assembleSessionRegistrations} input — what the session surface's assembly needs. */
-export type SessionAssemblySpec = {
-    config: ReturnType<typeof loadConfig>['config'];
-    rootDir: string;
-    /**
-     * The covenant surface the registrations are built from — the module the caller loaded
-     * from the resolved dist, so what judges a call is what that dist carries, and what
-     * `explain` renders is what would judge it.
-     */
-    covenant: CovenantModule;
-    /** The payload's transcript path. ABSENT leaves the transcript-mod registration out. */
-    transcriptPath?: string;
-    transcript?: CanonicalTranscript;
-    witness?: CovenantRegistration['witness'];
-};
-/**
- * The session surface's registration set. One assembly, two consumers: the runner below
- * dispatches it, `explain` renders it — so what a reader is shown is the table the judgment
- * actually uses, never a second opinion about it.
- */
-export declare function assembleSessionRegistrations(spec: SessionAssemblySpec): CovenantRegistration[];
-/**
- * The session-surface entry point: the post-hoc state comparison wrapped around the judgment.
- *
- * The comparison sits OUTSIDE {@link judgeHookCall}'s fail-closed try on both ends. Inside
- * it, a comparison failure would become a blocked call — the opposite of a mechanism whose
- * whole purpose is to record rather than stop — so each side carries its own catch and
- * neither can reach the verdict. Observation is fail-open, the direction
- * `appendRecordFailOpen` already established: the worst outcome is a missing datum.
- *
- * Order is the contract. The comparison runs first, so it reads the window the previous call
- * left and its rows land ahead of this call's judgment; the re-establishment runs last, so
- * this call's own judged writes are folded in rather than alarmed on next time.
- */
-export declare function runClaudeCodeHook(spec: ClaudeCodeHookSpec): Promise<ClaudeCodeHookOutcome>;