polydeukes 0.6.1 → 0.7.1

package/dist/diff-ir.js

@@ -0,0 +1,310 @@
+/**
+ * unified diff → `CovenantInput`. One pure translation, no judgment and no disk.
+ *
+ * The accepted grammar is finite: `diff --git` blocks and header-less `---`/`+++` blocks,
+ * covering creation, deletion, modification, mode-only changes, renames, and binary blobs.
+ * Anything else throws, so an unrecognised shape fails the run closed instead of translating
+ * to a partial observation.
+ *
+ * A modification's `pre`/`post` are the hunk's `-` and `+` lines, never the whole file: a
+ * unified diff carries the changed lines and the context around them, and reconstructing the
+ * file from them is not a translation. A creation and a deletion carry the whole text because
+ * every line of the file is in the hunk.
+ */
+/** The tool name a staged write is dispatched under — telemetry and configs read it. */
+export const STAGED_WRITE = 'staged-write';
+/** The tool name a staged deletion is dispatched under. */
+export const STAGED_DELETE = 'staged-delete';
+function emptyBlock() {
+    return { binary: false, deletedFile: false, newFile: false, removed: [], added: [] };
+}
+/** A path as git prints it after `rename from` / `rename to`: quoted only when it has to be. */
+function readBarePath(raw) {
+    return raw.startsWith('"') ? unquotePath(raw) : raw;
+}
+/**
+ * Decode git's C-quoted path form: the octal escapes are BYTES of the path, so they are
+ * collected and decoded as UTF-8 together — decoding each one on its own would turn every
+ * non-ASCII character into replacement characters.
+ */
+function unquotePath(quoted) {
+    const body = quoted.slice(1, -1);
+    const bytes = [];
+    for (let at = 0; at < body.length; at += 1) {
+        const char = body[at];
+        if (char !== '\\') {
+            bytes.push(...Buffer.from(char, 'utf-8'));
+            continue;
+        }
+        const next = body[at + 1];
+        const octal = body.slice(at + 1, at + 4);
+        if (/^[0-7]{3}$/.test(octal)) {
+            bytes.push(Number.parseInt(octal, 8));
+            at += 3;
+            continue;
+        }
+        const simple = {
+            t: 0x09,
+            n: 0x0a,
+            r: 0x0d,
+            '"': 0x22,
+            '\\': 0x5c,
+        };
+        bytes.push(simple[next] ?? Buffer.from(next, 'utf-8')[0] ?? 0);
+        at += 1;
+    }
+    return Buffer.from(bytes).toString('utf-8');
+}
+/**
+ * The path a `---`/`+++` line names, or null for `/dev/null`. A quoted path is unquoted
+ * before anything is cut, because a quoted path may itself contain a tab; an unquoted one is
+ * cut at the tab `diff -u` puts its timestamp behind. Exactly one `a/` or `b/` level is
+ * stripped, so a repository directory literally named `a/` survives.
+ */
+function readPath(rest, prefix) {
+    let path;
+    if (rest.startsWith('"')) {
+        const end = rest.lastIndexOf('"');
+        path = unquotePath(rest.slice(0, end + 1));
+    }
+    else {
+        const tab = rest.indexOf('\t');
+        path = tab === -1 ? rest : rest.slice(0, tab);
+    }
+    if (path === '/dev/null')
+        return null;
+    return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+/** The two paths of a `diff --git a/X b/Y` header, or undefined when they cannot be read. */
+function readHeaderPaths(rest) {
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('" "');
+        if (end === -1)
+            return undefined;
+        const old = unquotePath(rest.slice(0, end + 1));
+        const next = unquotePath(rest.slice(end + 2));
+        return { old: stripOnce(old, 'a/'), new: stripOnce(next, 'b/') };
+    }
+    // Unquoted paths may contain spaces, and git writes no separator between the two. The
+    // halves are equal in length whenever the prefixes are, which is git's own output; the
+    // midpoint split is what recovers them.
+    const middle = rest.length % 2 === 1 ? (rest.length - 1) / 2 : -1;
+    if (middle > 0 && rest[middle] === ' ') {
+        return {
+            old: stripOnce(rest.slice(0, middle), 'a/'),
+            new: stripOnce(rest.slice(middle + 1), 'b/'),
+        };
+    }
+    const at = rest.indexOf(' ');
+    if (at === -1)
+        return undefined;
+    return { old: stripOnce(rest.slice(0, at), 'a/'), new: stripOnce(rest.slice(at + 1), 'b/') };
+}
+function stripOnce(path, prefix) {
+    return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+/** The old and new line counts a hunk header declares, or undefined when it is not one. */
+function readHunkCounts(line) {
+    const match = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+    if (match === null)
+        return undefined;
+    return {
+        old: match[1] === undefined ? 1 : Number.parseInt(match[1], 10),
+        new: match[2] === undefined ? 1 : Number.parseInt(match[2], 10),
+    };
+}
+/**
+ * Split the text into file blocks, reading hunk bodies by the line counts their headers
+ * declare. The counts are what keeps a removed `-- note` line (which reads as `--- note`)
+ * from being taken for a new file header: header lines are only recognised outside a hunk.
+ */
+function parseBlocks(text) {
+    const lines = text.split('\n');
+    const blocks = [];
+    let block;
+    const open = () => {
+        if (block === undefined) {
+            block = emptyBlock();
+            blocks.push(block);
+        }
+        return block;
+    };
+    for (let at = 0; at < lines.length; at += 1) {
+        const line = lines[at];
+        if (line === '' && at === lines.length - 1)
+            continue;
+        if (line.startsWith('diff --cc ') || line.startsWith('diff --combined ')) {
+            throw new Error(`unified diff: combined diffs are not translatable: ${line}`);
+        }
+        if (line.startsWith('diff --git ')) {
+            block = emptyBlock();
+            blocks.push(block);
+            block.headerPaths = readHeaderPaths(line.slice('diff --git '.length));
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            // A second `---` outside a hunk starts a new header-less block.
+            if (block !== undefined && block.oldPath !== undefined)
+                block = undefined;
+            open().oldPath = readPath(line.slice(4), 'a/');
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            const current = open();
+            if (current.oldPath === undefined) {
+                throw new Error(`unified diff: '+++' line with no '---' partner: ${line}`);
+            }
+            current.newPath = readPath(line.slice(4), 'b/');
+            continue;
+        }
+        const counts = readHunkCounts(line);
+        if (counts !== undefined) {
+            const current = open();
+            if (current.oldPath === undefined || current.newPath === undefined) {
+                if (current.headerPaths === undefined) {
+                    throw new Error(`unified diff: hunk with no file header: ${line}`);
+                }
+            }
+            let oldLeft = counts.old;
+            let newLeft = counts.new;
+            while ((oldLeft > 0 || newLeft > 0) && at + 1 < lines.length) {
+                const body = lines[at + 1];
+                at += 1;
+                if (body.startsWith('\\'))
+                    continue;
+                // A line the declared counts have no room for is a malformed hunk: judging the
+                // lines that fit and dropping the rest would be an observation smaller than the
+                // input, so the whole run fails closed instead.
+                if (body.startsWith('+') && newLeft > 0) {
+                    current.added.push(body.slice(1));
+                    newLeft -= 1;
+                    continue;
+                }
+                if (body.startsWith('-') && oldLeft > 0) {
+                    current.removed.push(body.slice(1));
+                    oldLeft -= 1;
+                    continue;
+                }
+                if ((body.startsWith(' ') || body === '') && oldLeft > 0 && newLeft > 0) {
+                    oldLeft -= 1;
+                    newLeft -= 1;
+                    continue;
+                }
+                throw new Error(`unified diff: unknown hunk line: ${body}`);
+            }
+            continue;
+        }
+        if (line.startsWith('rename from ')) {
+            open().renameFrom = readBarePath(line.slice('rename from '.length));
+            continue;
+        }
+        if (line.startsWith('rename to ')) {
+            open().renameTo = readBarePath(line.slice('rename to '.length));
+            continue;
+        }
+        if (line.startsWith('deleted file mode ')) {
+            open().deletedFile = true;
+            continue;
+        }
+        if (line.startsWith('new file mode ')) {
+            open().newFile = true;
+            continue;
+        }
+        if (line.startsWith('Binary files ') || line === 'GIT binary patch') {
+            const current = open();
+            current.binary = true;
+            if (line.endsWith('and /dev/null differ'))
+                current.deletedFile = true;
+        }
+        // Everything else outside a hunk is an extended header line (`index`, `old mode`,
+        // `similarity index`, a binary patch's base85 payload) that names nothing this
+        // translation reads.
+    }
+    return blocks;
+}
+/** The toolCalls one block translates to, in the order the judgment sees them. */
+function blockToolCalls(block) {
+    const { renameFrom, renameTo } = block;
+    if (renameFrom !== undefined && renameTo !== undefined) {
+        return [
+            {
+                name: STAGED_DELETE,
+                args: { file_path: renameFrom },
+                fileChange: { kind: 'delete', path: renameFrom },
+            },
+            {
+                name: STAGED_WRITE,
+                args: { file_path: renameTo },
+                fileChange: {
+                    kind: 'modify',
+                    path: renameTo,
+                    pre: block.removed.join('\n'),
+                    post: block.added.join('\n'),
+                },
+            },
+        ];
+    }
+    // An empty file's deletion or creation carries no `---`/`+++` pair and no hunk, so the
+    // mode line is the only evidence of which one it is.
+    const deletion = block.newPath === null || block.deletedFile;
+    const path = deletion
+        ? (block.oldPath ?? block.headerPaths?.old)
+        : (block.newPath ?? block.headerPaths?.new);
+    if (path === undefined || path === null) {
+        throw new Error('unified diff: a file block names no path');
+    }
+    if (block.binary) {
+        return [{ name: deletion ? STAGED_DELETE : STAGED_WRITE, args: { file_path: path } }];
+    }
+    if (deletion) {
+        return [
+            {
+                name: STAGED_DELETE,
+                args: { file_path: path },
+                fileChange: { kind: 'delete', path, pre: block.removed.join('\n') },
+            },
+        ];
+    }
+    if (block.oldPath === null || block.newFile) {
+        return [
+            {
+                name: STAGED_WRITE,
+                args: { file_path: path },
+                fileChange: { kind: 'create', path, post: block.added.join('\n') },
+            },
+        ];
+    }
+    return [
+        {
+            name: STAGED_WRITE,
+            args: { file_path: path },
+            fileChange: {
+                kind: 'modify',
+                path,
+                pre: block.removed.join('\n'),
+                post: block.added.join('\n'),
+            },
+        },
+    ];
+}
+/**
+ * Translate a unified diff into the covenant input IR: one toolCall per file block in input
+ * order (a rename is two, the deletion first), and no `actor` key — a diff proves no author.
+ */
+export function covenantInputFromUnifiedDiff(spec) {
+    const blocks = parseBlocks(spec.text);
+    // Text that is not blank yet contains no block the grammar recognizes — a colored diff,
+    // a pager banner, anything else — must not translate to "nothing staged": an empty
+    // observation is a pass, and this input may describe a whole commit.
+    if (blocks.length === 0 && spec.text.trim() !== '') {
+        throw new Error('unified diff: no file block recognized in the input');
+    }
+    const toolCalls = [];
+    for (const block of blocks) {
+        if (block.oldPath !== undefined && block.newPath === undefined) {
+            throw new Error(`unified diff: '---' line with no '+++' partner: ${block.oldPath}`);
+        }
+        toolCalls.push(...blockToolCalls(block));
+    }
+    return { toolCalls, subagentSpawns: [], userMessages: [] };
+}

package/dist/docs/README.ko.md

@@ -25,11 +25,10 @@
 | 문서 | 답하는 것 |
 |---|---|
 | [설정 레퍼런스](./reference/configuration/index.ko.md) | `polydeukes.config.yaml`에 무엇을 넣을 수 있고 각 키가 무엇을 하는지 |
-| [`polydeukes` (`pdks` CLI)](./reference/packages/polydeukes.ko.md) | 패키지 계약. 서브커맨드는 [`reference/cli/`](./reference/cli/covenant-check.ko.md) |
+| [`polydeukes` (`pdks` CLI)](./reference/packages/polydeukes.ko.md) | 패키지 계약과 그 안에 있는 판정기. 서브커맨드는 [`reference/cli/`](./reference/cli/covenant-check.ko.md) |
 | [`@polydeukes/core`](./reference/packages/core.ko.md) | 프로토콜, 입력 IR, 설정 스키마, 텔레메트리 |
-| [`@polydeukes/covenant`](./reference/packages/covenant.ko.md) | 판정기입니다. 디스패처와 규율 라이브러리, 메타 약속, 밸브 |
-| [`@polydeukes/adapter-claude-code`](./reference/packages/adapter-claude-code.ko.md) | 세션 표면입니다. 훅 페이로드에서 입력 IR로 |
-| [`@polydeukes/adapter-git`](./reference/packages/adapter-git.ko.md) | 커밋 표면입니다. 스테이징·작업 트리·범위 diff에서 입력 IR로 |
+| [`@polydeukes/adapter-claude-code`](./reference/packages/adapter-claude-code.ko.md) | Claude Code 세션 표면입니다. 훅 페이로드에서 입력 IR로 |
+| [`@polydeukes/adapter-grok`](./reference/packages/adapter-grok.ko.md) | Grok 세션 표면입니다. 훅 페이로드에서 입력 IR로 |
 
 <a id="shape-of-the-thing"></a>
 ## 한 페이지로 보는 구조
@@ -53,8 +52,9 @@
 
 | 표면 | 판정 대상 | 배선 방법 | 대상 |
 |---|---|---|---|
-| **세션** | 도구 호출, 실행되기 전에 | `pdks init claude-code` 또는 `pdks init grok` | AI 파트너와 함께 개발하는 프로젝트 |
-| **커밋** | diff — 스테이징 영역, 작업 트리, ref 범위 | pre-commit 훅, 또는 필요할 때 직접 실행 | 혼자 개발하는 사람, 그리고 CI |
+| **세션** | 도구 호출, 실행되기 전에 | `pdks-claude-code init` 또는 `pdks-grok init` | AI 파트너와 함께 개발하는 프로젝트 |
+| **커밋** | stdin의 unified diff — 스테이징 영역, 작업 트리, ref 범위 | `git diff --cached`를 파이프로 넘기는 pre-commit 훅, 또는 필요할 때 직접 실행 | 혼자 개발하는 사람, 그리고 CI |
 
-커밋 판정기는 필요할 때 직접 실행할 수도 있습니다. 작업 후에는 `pdks covenant check --worktree`,
-PR 전에는 `--range`를 사용합니다. 같은 판정 기준으로 결과를 보고하며 증인 입력은 요청하지 않습니다.
+커밋 판정기는 필요할 때 직접 실행할 수도 있습니다. 작업 후에는 `git diff HEAD | pdks covenant check --diff`,
+PR 전에는 `git diff main...HEAD | …`를 사용합니다. 같은 판정 기준을 종료 코드로 답하며 묻지
+않습니다. 관문은 그 코드를 소비하는 쪽입니다.

package/dist/docs/README.md

@@ -27,11 +27,10 @@ is aspirational.
 | Document | Answers |
 |---|---|
 | [Configuration reference](./reference/configuration/index.md) | What may go in `polydeukes.config.yaml`, and what each key does |
-| [`polydeukes` (the `pdks` CLI)](./reference/packages/polydeukes.md) | Package contract; subcommands live under [`reference/cli/`](./reference/cli/covenant-check.md) |
+| [`polydeukes` (the `pdks` CLI)](./reference/packages/polydeukes.md) | Package contract, and the judge that lives inside it; subcommands live under [`reference/cli/`](./reference/cli/covenant-check.md) |
 | [`@polydeukes/core`](./reference/packages/core.md) | The protocol, the input IR, the config schema, telemetry |
-| [`@polydeukes/covenant`](./reference/packages/covenant.md) | The judge — dispatcher, discipline library, meta-covenants, the valve |
-| [`@polydeukes/adapter-claude-code`](./reference/packages/adapter-claude-code.md) | Session surface — hook payloads become the input IR |
-| [`@polydeukes/adapter-git`](./reference/packages/adapter-git.md) | Commit surface — staged, worktree, and range diffs become the input IR |
+| [`@polydeukes/adapter-claude-code`](./reference/packages/adapter-claude-code.md) | Claude Code session surface — hook payloads become the input IR |
+| [`@polydeukes/adapter-grok`](./reference/packages/adapter-grok.md) | Grok session surface — hook payloads become the input IR |
 
 <a id="shape-of-the-thing"></a>
 ## The shape of the thing, in one page
@@ -57,8 +56,9 @@ in the whitepaper, which were all found by counting rows rather than by reading
 
 | Surface | Judges | Wired by | For |
 |---|---|---|---|
-| **Session** | A tool call, before it runs | `pdks init claude-code` or `pdks init grok` | A project developed with an AI partner |
-| **Commit** | A diff — staged, the working tree, or a ref range | A pre-commit hook, or run on demand | A human developing alone, and CI |
+| **Session** | A tool call, before it runs | `pdks-claude-code init` or `pdks-grok init` | A project developed with an AI partner |
+| **Commit** | A unified diff on stdin — staged, the working tree, or a ref range | A pre-commit hook piping `git diff --cached`, or run on demand | A human developing alone, and CI |
 
-The commit judge also answers on demand: `pdks covenant check --worktree` after a task, `--range`
-before a PR. Same verdict a commit would receive, delivered as a report with no prompt and no gate.
+The commit judge also answers on demand: `git diff HEAD | pdks covenant check --diff` after a task,
+`git diff main...HEAD | …` before a PR. Same verdict a commit would receive, delivered as an exit
+code with no prompt — the gate is whatever consumes that code.

package/dist/docs/catalog.json

@@ -130,12 +130,12 @@
       "en": {
         "path": "reference/cli/covenant-check.md",
         "title": "`pdks covenant check`",
-        "summary": "Inspect staged changes, --worktree, or a revision range."
+        "summary": "Judge a unified diff or an input IR from stdin, and read the exit codes."
       },
       "ko": {
         "path": "reference/cli/covenant-check.ko.md",
         "title": "`pdks covenant check`",
-        "summary": "스테이징한 변경, 작업 트리 검사, 리비전 범위 검사를 설명합니다."
+        "summary": "stdin의 unified diff나 입력 IR을 판정하고 종료 코드를 읽는 방법을 설명합니다."
       }
     },
     {
@@ -146,12 +146,12 @@
       "en": {
         "path": "reference/cli/init.md",
         "title": "`pdks init`",
-        "summary": "Install the Claude Code or Grok integration."
+        "summary": "Create the project scaffold, and find the Claude Code and Grok installers."
       },
       "ko": {
         "path": "reference/cli/init.ko.md",
         "title": "`pdks init`",
-        "summary": "Claude Code 또는 Grok 연동을 설치합니다."
+        "summary": "프로젝트 초기 파일을 만들고, Claude Code와 Grok 설치기를 찾습니다."
       }
     },
     {
@@ -235,51 +235,51 @@
       }
     },
     {
-      "id": "package-covenant",
+      "id": "package-adapter-claude-code",
       "category": "reference",
-      "order": 14,
+      "order": 15,
       "bundled": true,
       "en": {
-        "path": "reference/packages/covenant.md",
-        "title": "`@polydeukes/covenant`",
-        "summary": "Consult the covenant package contract and its limits."
+        "path": "reference/packages/adapter-claude-code.md",
+        "title": "`@polydeukes/adapter-claude-code`",
+        "summary": "Install the Claude Code session surface, and consult the adapter package contract and its limits."
       },
       "ko": {
-        "path": "reference/packages/covenant.ko.md",
-        "title": "`@polydeukes/covenant`",
-        "summary": "covenant 패키지의 계약과 한계를 확인합니다."
+        "path": "reference/packages/adapter-claude-code.ko.md",
+        "title": "`@polydeukes/adapter-claude-code`",
+        "summary": "Claude Code 세션 표면을 설치하고, 어댑터 패키지의 계약과 한계를 확인합니다."
       }
     },
     {
-      "id": "package-adapter-claude-code",
+      "id": "package-adapter-grok",
       "category": "reference",
-      "order": 15,
+      "order": 16,
       "bundled": true,
       "en": {
-        "path": "reference/packages/adapter-claude-code.md",
-        "title": "`@polydeukes/adapter-claude-code`",
-        "summary": "Consult the adapter-claude-code package contract and its limits."
+        "path": "reference/packages/adapter-grok.md",
+        "title": "`@polydeukes/adapter-grok`",
+        "summary": "Install the Grok session surface, and consult the adapter package contract and its limits."
       },
       "ko": {
-        "path": "reference/packages/adapter-claude-code.ko.md",
-        "title": "`@polydeukes/adapter-claude-code`",
-        "summary": "adapter-claude-code 패키지의 계약과 한계를 확인합니다."
+        "path": "reference/packages/adapter-grok.ko.md",
+        "title": "`@polydeukes/adapter-grok`",
+        "summary": "Grok 세션 표면을 설치하고, 어댑터 패키지의 계약과 한계를 확인합니다."
       }
     },
     {
-      "id": "package-adapter-git",
+      "id": "package-sdk-ts",
       "category": "reference",
-      "order": 16,
+      "order": 25,
       "bundled": true,
       "en": {
-        "path": "reference/packages/adapter-git.md",
-        "title": "`@polydeukes/adapter-git`",
-        "summary": "Consult the adapter-git package contract and its limits."
+        "path": "reference/packages/sdk-ts.md",
+        "title": "`@polydeukes/sdk-ts`",
+        "summary": "Call the judge from TypeScript with one verb, and read the three verdicts it returns."
       },
       "ko": {
-        "path": "reference/packages/adapter-git.ko.md",
-        "title": "`@polydeukes/adapter-git`",
-        "summary": "adapter-git 패키지의 계약과 한계를 확인합니다."
+        "path": "reference/packages/sdk-ts.ko.md",
+        "title": "`@polydeukes/sdk-ts`",
+        "summary": "TypeScript에서 동사 하나로 판정기를 부르고, 돌아오는 판정 결과 셋을 읽습니다."
       }
     },
     {
@@ -409,6 +409,22 @@
         "title": "<!--",
         "summary": "당시의 개발 기록이며 현재 사용법을 설명하는 참조 문서는 아닙니다."
       }
+    },
+    {
+      "id": "post-7",
+      "category": "history",
+      "order": 24,
+      "bundled": false,
+      "en": {
+        "path": "build-in-public/2026-09-v0.6.1-docs-and-search.md",
+        "title": "<!--",
+        "summary": "Historical development account; not a current usage reference."
+      },
+      "ko": {
+        "path": "build-in-public/2026-09-v0.6.1-docs-and-search.ko.md",
+        "title": "<!--",
+        "summary": "당시의 개발 기록이며 현재 사용법을 설명하는 참조 문서는 아닙니다."
+      }
     }
   ],
   "topics": {

package/dist/docs/concepts/judgment.ko.md

@@ -16,7 +16,7 @@ Polydeukes는 연결된 표면이 공급하는 증거를 바탕으로 선언된
 **표면(surface)**은 언제 증거를 수집하는지 결정합니다.
 
 - 세션 표면은 지원하는 호스트의 도구 호출을 실행 전에 관측합니다.
-- 커밋 표면은 스테이징한 변경, 작업 트리의 변경 또는 두 리비전 사이의 변경을 관측합니다.
+- 변경 집합 표면은 스테이징한 변경, 작업 트리의 변경 또는 두 리비전 사이의 변경을 관측합니다.
 
 패키지를 설치하는 것과 표면을 연결하는 것은 다릅니다. 에이전트가 지침을 읽었다고 해서
 도구 호출에 자동으로 판정이 적용되지는 않습니다. 지원하는 연동을 설정하고 실제 호출로
@@ -103,7 +103,7 @@ Polydeukes는 연결된 표면이 공급하는 증거를 바탕으로 선언된
 ## 강제 수준과 증인
 
 규율 항목의 기본 강제 수준은 `advise`입니다. 위반과 정상 사례를 모두 확인한 뒤
-`enforce: block`으로 승격하세요. 커밋 표면의 수준과 항목의 수준을 함께 적용할 때는
+`enforce: block`으로 승격하세요. 변경 집합 표면의 수준과 항목의 수준을 함께 적용할 때는
 **더 관대한 쪽을 따릅니다**. 표면만 `block`으로 설정해도 모든 항목이 차단 수준으로
 바뀌지는 않습니다. 판정 체계 자체의 보호는 일반 규율 항목과 별개입니다.
 

package/dist/docs/concepts/judgment.md

@@ -15,7 +15,7 @@ in the project's configuration. The **judge** evaluates evidence; a **verdict**
 A **surface** determines when evidence is gathered:
 
 - The session surface observes a supported host's tool call before it runs.
-- The commit surface observes staged changes, working-tree changes, or a revision range.
+- The change-set surface observes staged changes, working-tree changes, or a revision range.
 
 Installing the package is not the same as connecting a surface. Instructions an agent reads are
 not automatic interception of its tools. Use a supported integration and verify an actual call.
@@ -102,7 +102,7 @@ that the practice was followed. An empty observation set establishes nothing abo
 ## Enforcement and witness
 
 Discipline entries default to `advise`. Promote an entry with `enforce: block` only after checking
-both its violating and valid cases. The commit surface's level and an entry's level compose:
+both its violating and valid cases. The change-set surface's level and an entry's level compose:
 **the lenient side wins**. Setting only the surface to `block` does not promote every entry.
 Protection of the judging chain is separate from ordinary discipline entries.
 

package/dist/docs/how-to/configure-project.ko.md

@@ -36,8 +36,8 @@ YAML 파일에는 다음 줄을 넣어 설치된 스키마를 편집기에서
 # yaml-language-server: $schema=../../node_modules/polydeukes/dist/schema/polydeukes.schema.json
 ```
 
-`pdks init claude-code`는 생성한 설정 파일을 기준으로 기본 경로의 스키마를 찾을 수 있을 때만
-스키마 줄을 넣습니다. 이 줄이 없다면 스키마 위치에 맞춰 상대 경로를 직접 추가하세요.
+`pdks init`은 생성한 설정 파일을 기준으로 기본 경로의 스키마를 찾을 수 있을 때만 스키마 줄을
+넣습니다. `pdks-claude-code init`이 이 명령을 대신 실행합니다. 이 줄이 없다면 스키마 위치에 맞춰 상대 경로를 직접 추가하세요.
 `$schema` 경로를 찾지 못하면 편집기에 오류가 표시되지 않은 채 스키마 검증이 중단될 수 있습니다.
 
 우산이 아니라 `@polydeukes/core`를 직접 설치했다면 그 사본을 가리킵니다.
@@ -72,27 +72,27 @@ languages:
 
 | 설정 | 위반 시 동작 |
 |---|---|
-| `adapters.git.enforce: advise` | 권고를 기록하고 커밋을 계속합니다. 증인 입력은 요청하지 않습니다. |
-| `adapters.git.enforce: block` | 차단 판정을 받은 작업을 거부합니다. 스테이징 검사에서는 TTY로 증인 입력을 받을 수 있습니다. |
+| 항목의 `enforce: advise`(또는 적지 않음) | 권고를 기록하고 호출을 진행합니다. 종료 코드 0입니다. |
+| 항목의 `enforce: block` | 판정한 호출을 거부합니다. 종료 코드 2입니다. |
 
-일반 규율(discipline) 항목에도 자체 강제 수준이 있으며 기본값은 `advise`입니다.
-**두 수준 중 더 관대한 쪽을 따릅니다.** 어댑터만 `block`으로 설정해도 일반 항목이 자동으로
-차단 수준으로 바뀌지는 않습니다. 설정된 경로의 보호는 이 항목별 기본값과 별개입니다.
-조립 단계에서 오류가 나면 어느 수준에서든 종료 코드 2를 반환합니다.
+**적지 않으면 `advise`입니다.** 설정에는 표면 단위의 강제 수준 키가 없습니다. 강제 수준은
+각 항목이 가지며 적지 않은 항목을 승격하는 설정도 없습니다. 설정된 경로의 보호는 이 항목별
+기본값과 별개입니다. 세션 표면에서는 차단하고, 변경 집합 표면에서는 명령을 `--enforce block`으로
+실행하지 않는 한 `advised`로 기록합니다. 조립 단계에서 오류가 나면 종료 코드 2를
+반환합니다.
 
-최상위 `protectedPaths`는 두 표면에 모두 적용합니다. `adapters.git.protectedPaths`에는
-커밋할 때만 보호할 경로를 추가합니다. 세션 중에는 편집을 허용하되 커밋할 때 보호하려는
-파일에 사용하세요. [표면 연결과 증인](./connect-surfaces.ko.md#witness-and-recovery)에서
-자세히 설명합니다.
+`protectedPaths`는 두 표면에 모두 적용하는 최상위 목록 하나입니다. 변경 집합 표면에서 판정기는
+종료 코드만 내므로, 커밋을 멈출지는 훅 배선이 정합니다.
+[표면 연결과 증인](./connect-surfaces.ko.md#witness-and-recovery)에서 자세히 설명합니다.
 
 <a id="confirm-the-project"></a>
 ## 설정 확인하기
 
 - `pdks explain`은 설정을 읽고 등록된 항목을 보여 줍니다. 변경을 판정하지는 않습니다.
-- `pdks covenant check --worktree`는 HEAD와 디스크를 비교합니다. 아직 Git에 등록하지 않은
-  파일도 무시 대상이 아니면 포함합니다.
-- `pdks covenant check`는 스테이징한 변경을 관측합니다. 차단 결과가 나고 TTY를 사용할 수
-  있을 때 증인 입력을 요청할 수 있습니다. 어댑터가 `block`이라는 이유만으로 묻지는 않습니다.
+- `git diff HEAD | pdks covenant check --diff`는 아직 커밋하지 않은 변경 전부를 판정합니다.
+- `git diff --cached | pdks covenant check --diff`는 스테이징한 변경을 관측합니다. pre-commit
+  훅이 쓰는 형태입니다. 이 명령은 사람에게 묻지 않고 종료 코드 0 또는 2만 내며, 커밋을
+  멈출지는 훅 배선이 정합니다.
 
 종료 코드와 함께 stderr와 텔레메트리도 확인하세요. 권고나 일부 미판정도 종료 코드 0을
 반환합니다. 조립에 실패했다면 규율을 시험하기 전에 오류가 지목한 설정이나 빠진 패키지부터

package/dist/docs/how-to/configure-project.md

@@ -36,8 +36,9 @@ monorepo sub-package whose dependencies installed at the workspace root, count t
 # yaml-language-server: $schema=../../node_modules/polydeukes/dist/schema/polydeukes.schema.json
 ```
 
-`pdks init claude-code` adds the schema line only when the default path resolves relative to the
-generated config. If the line is absent, add a relative path to the installed schema yourself.
+`pdks init` — which `pdks-claude-code init` runs for you — adds the schema line only when the
+default path resolves relative to the generated config. If the line is absent, add a relative path
+to the installed schema yourself.
 An unresolvable `$schema` can disable editor validation without displaying an error.
 
 If you installed `@polydeukes/core` directly rather than the umbrella, name its copy:
@@ -72,24 +73,26 @@ Loading this setting does not itself run the command.
 
 | Setting | Effect on a violation |
 |---|---|
-| `adapters.git.enforce: advise` | Record advice and let the commit continue, without a witness prompt. |
-| `adapters.git.enforce: block` | Refuse a blocking judgment; the staged path can offer a TTY witness prompt. |
+| `enforce: advise` on an entry (or absent) | Record advice and let the call proceed, exit 0. |
+| `enforce: block` on an entry | Refuse the judged call, exit 2. |
 
-An ordinary discipline also has its own level, defaulting to `advise`. **The lenient level wins.**
-Setting only the adapter to `block` does not promote an ordinary entry. Protection of configured
-paths is separate from that per-entry default. Assembly errors still exit 2 at either level.
+**Absent means `advise`.** There is no surface-level enforcement key in the config: each entry
+carries its own level and nothing promotes an absent one. Protection of configured paths is
+separate from that per-entry default — it blocks on the session surface, and on the change-set
+surface it lands `advised` unless the command is run with `--enforce block`. Assembly errors
+still exit 2.
 
-Top-level `protectedPaths` applies to both surfaces. `adapters.git.protectedPaths` adds commit-only
-paths. Use the latter for files that may be edited in a session but need protection when committed.
+`protectedPaths` is a single top-level list that applies to both surfaces. On the change-set
+surface the judge only emits the exit code; whether the commit stops is your hook wiring.
 See [surface connection and witnesses](./connect-surfaces.md#witness-and-recovery).
 
 <a id="confirm-the-project"></a>
 ## Confirm the project
 
 - `pdks explain` loads the configuration and shows registrations without judging a change.
-- `pdks covenant check --worktree` compares HEAD with disk, including untracked, non-ignored files.
-- `pdks covenant check` observes staged changes. A blocking result can prompt only when a TTY is
-  available; the command does not prompt merely because the adapter is set to `block`.
+- `git diff HEAD | pdks covenant check --diff` judges everything not yet committed.
+- `git diff --cached | pdks covenant check --diff` observes staged changes — the pre-commit shape.
+  The command never prompts; it exits 0 or 2 and your hook wiring decides the commit's fate.
 
 Check stderr and telemetry as well as the exit code. Advice and some skipped observations exit 0.
 If assembly fails, diagnose the named configuration or missing package before testing a discipline.