polydeukes 0.6.1 → 0.8.0

package/dist/claude-code-hook.js

@@ -1,372 +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 { mkdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { COMMAND_ARGS, MUTATING_TOOLS, runAdapterPath, SHELL_TOOLS, sessionChannelReader, sessionSourceReader, transcriptFromJsonlFile, transcriptPathFromPayload, } from '@polydeukes/adapter-claude-code';
-import { appendRecordFailOpen, DEFAULT_TELEMETRY_LOG_PATH, isPlainObject, normalizeProtectedPaths, readRecords, } from '@polydeukes/core';
-import { ttlWitness } from '@polydeukes/covenant';
-import { findUnattributed, readBaseline, snapshotBaseline, writeBaseline } from './baseline.js';
-import { loadCovenantModule, resolveCovenantDist } from './covenant-module.js';
-import { loadConfig } from './load-config.js';
-import { sessionPreStateReader } from './pre-state-reader.js';
-/** The label every post-hoc state comparison row carries. */
-const BASELINE_LABEL = 'baseline';
-/**
- * Compare the protected entries' on-disk state against the stored baseline and record what
- * moved with no judgment explaining it.
- *
- * Runs at hook call START, before this call's own judgment rows land, so the window it reads
- * is the one the previous comparison left open. Returns the record count as of right now —
- * where the NEXT window opens, which {@link updateBaseline} persists at call end.
- *
- * The comparison records, it never blocks: no row it writes and no failure it hits changes
- * a verdict or an exit code, which is why every caller keeps it outside the judgment path.
- */
-function compareBaseline(spec) {
-    const baselinePath = join(spec.repoRoot, '.polydeukes', 'baseline.json');
-    // Read before any row of this comparison lands, so the rows this call is about to write
-    // cannot fall inside the window they would then explain away.
-    const { records } = readRecords(spec.telemetryPath);
-    const stored = readBaseline(baselinePath);
-    if (stored === null) {
-        // Absence and corruption are the same signal. The baseline file is NOT on the protection
-        // list — protecting it would need a comparison of its own — so its disappearance has to
-        // stay legible in the log instead.
-        appendRecordFailOpen(spec.telemetryPath, {
-            event: 'unattributed',
-            label: BASELINE_LABEL,
-            subject: baselinePath,
-        });
-        return;
-    }
-    const changed = findUnattributed({
-        previous: stored.entries,
-        current: snapshotBaseline({ rootDir: spec.repoRoot, entries: spec.entries }),
-        records,
-        // The cut travels with the hashes it belongs to, from the one read above. Rows older
-        // than it were already spent explaining the state that snapshot recorded.
-        cutAt: stored.cutAt,
-    });
-    // One row per changed entry — an aggregate row could not say WHICH gate definition moved.
-    for (const entry of changed) {
-        appendRecordFailOpen(spec.telemetryPath, {
-            event: 'unattributed',
-            label: BASELINE_LABEL,
-            subject: entry,
-        });
-    }
-}
-/**
- * Re-establish the baseline at hook call END.
- *
- * At call end rather than right after the comparison: refreshing at comparison time would
- * miss whatever this call's own judged writes changed, leaving detection permanently one
- * call behind.
- *
- * The cut is stamped HERE, beside the snapshot, not at the comparison that opened the call.
- * Both describe the same instant — everything this call did is already folded into the
- * hashes — so the rows explaining it belong before the cut. Stamping the earlier instant
- * instead would re-admit this call's own judgment rows into the next window, where they
- * would attribute a change they had nothing to do with: a call that merely MENTIONED a
- * protected entry would then absolve any tamper that followed it.
- */
-function updateBaseline(spec) {
-    const dotDir = join(spec.repoRoot, '.polydeukes');
-    mkdirSync(dotDir, { recursive: true });
-    writeBaseline(join(dotDir, 'baseline.json'), snapshotBaseline({ rootDir: spec.repoRoot, entries: spec.entries }), new Date().toISOString());
-}
-/**
- * Where the comparison writes and what it observes, or `undefined`.
- *
- * The domain is derived from config rather than enumerated here, and the telemetry path is
- * resolved by the same precedence the judgment uses so both land in one log. A config that
- * does not load leaves NO domain, so there is nothing to compare and nothing to re-establish
- * — the judgment path already answers that failure fail-closed, and a comparison row on top
- * of it would report the same absence twice under a label that judges nothing.
- */
-function comparisonSpec(spec) {
-    let config;
-    try {
-        config = loadConfig({ rootDir: spec.repoRoot }).config;
-    }
-    catch {
-        return undefined;
-    }
-    return {
-        repoRoot: spec.repoRoot,
-        telemetryPath: spec.telemetryPath ??
-            process.env.POLYDEUKES_TELEMETRY_PATH ??
-            resolve(spec.repoRoot, config.telemetry.logPath),
-        entries: normalizeProtectedPaths({ protectedPaths: config.protectedPaths }),
-    };
-}
-/**
- * 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 function assembleSessionRegistrations(spec) {
-    const { config, rootDir, covenant, transcriptPath, transcript, witness } = spec;
-    // The live transcript is the session a history declaration reads AND the one the witness
-    // reads, so erasing or forging it disables every history discipline while opening or
-    // shutting the human valve on the same file. It must NOT join this list: it lives deep
-    // under HOME, and a path entry makes every ancestor protected — which measured as an
-    // over-block refusing `cd /home/<user>`, `echo $HOME`, and every edit whose content
-    // carried a bare `~`. The dedicated `transcript-mod` registration below covers that one
-    // file instead: equality-only, never an ancestor. Ancestor destruction outside the
-    // repository is out of observation scope — the agent's own deny policy owns what no
-    // repo-scoped judge can reach.
-    const protectedPaths = normalizeProtectedPaths({
-        protectedPaths: config.protectedPaths ?? [],
-    });
-    const disciplines = config.disciplines ?? [];
-    const registrations = [
-        covenant.selfModRegistration({
-            protectedPaths,
-            mutatingToolNames: MUTATING_TOOLS,
-            witness,
-        }),
-        covenant.shellModRegistration({
-            protectedPaths,
-            shellTools: SHELL_TOOLS,
-            commandArgs: COMMAND_ARGS,
-            witness,
-        }),
-        // Routing is the matches predicate, never path mention, so the home directory cannot
-        // become a protected ancestor. No transcript in the payload means nothing to protect —
-        // the valve and every history declaration already forfeited on the same absence.
-        ...(transcriptPath === undefined
-            ? []
-            : [
-                covenant.transcriptModRegistration({
-                    transcriptPath,
-                    // The env value first, since that is what the judged shell expands `~` and
-                    // `$HOME` from. `homedir()` reads the same passwd entry bash falls back to when
-                    // HOME is unset, so a hook spawned without an environment (a service manager,
-                    // `env -i`) keeps judging the home spellings instead of silently going
-                    // absolute-only — an inert spelling closure looks identical to a passing call.
-                    home: process.env.HOME ?? homedir(),
-                    shellTools: SHELL_TOOLS,
-                    commandArgs: COMMAND_ARGS,
-                    mutatingTools: MUTATING_TOOLS,
-                    witness,
-                }),
-            ]),
-        ...covenant.compileDisciplineRegistrations({
-            disciplines,
-            rootDir,
-            shellTools: SHELL_TOOLS,
-            commandArgs: COMMAND_ARGS,
-            readPreState: sessionPreStateReader,
-            // One PreToolUse call is the whole observation, so the derived change set is a
-            // singleton and a change-set declaration cannot be judged here — it records `skipped`,
-            // the shape the commit surface gives a history declaration.
-            observesChangeSet: false,
-            witness,
-            // The session itself, injected rather than its path: a declaration reading a
-            // `transcript` binding sees it flattened, and passing a path would leak JSONL
-            // knowledge into covenant.
-            transcript,
-        }),
-    ];
-    return registrations;
-}
-/**
- * This runtime's mutating+shell roster, rewritten onto the Claude vocabulary the adapter
- * already judges. Claude names are not keys, so an existing Write/Edit/Bash envelope
- * passes through. A name outside the table is left alone — that is a declared limit,
- * recorded as the adapter's funnel pass, never a parse fault. The map lives here, not in
- * the adapter, so the adapter stays Claude-vocabulary-only.
- */
-const GROK_TOOL_NAME_MAP = {
-    write: 'Write',
-    search_replace: 'Edit',
-    run_terminal_command: 'Bash',
-};
-/**
- * Rewrite Grok tool names in a raw PreToolUse payload. Invalid JSON is left as the original
- * string so the existing fail-closed path still runs — this function must not throw.
- */
-function rewriteGrokToolNames(rawPayload) {
-    let parsed;
-    try {
-        parsed = JSON.parse(rawPayload);
-    }
-    catch {
-        return rawPayload;
-    }
-    if (!isPlainObject(parsed))
-        return rawPayload;
-    for (const key of ['tool_name', 'toolName']) {
-        const value = parsed[key];
-        if (typeof value !== 'string')
-            continue;
-        const mapped = GROK_TOOL_NAME_MAP[value];
-        if (mapped !== undefined)
-            parsed[key] = mapped;
-    }
-    return JSON.stringify(parsed);
-}
-/**
- * Judge one declared tool call before it runs. Async because the dispatcher spawns covenant
- * bodies — a synchronous runner would mean reimplementing the judge, which the
- * single-dispatcher principle forbids.
- */
-async function judgeHookCall(spec) {
-    // Env-first telemetry precedence, settled BEFORE any failure branch: a config that never
-    // loads still has somewhere to write its one blocked row. The config value applies after
-    // the load succeeds.
-    //
-    // Computed INSIDE the try even though it must run first, because `join` throws on a
-    // non-string repoRoot and this function's contract is that nothing escapes it — a rejection
-    // would exit a delegator non-blocking, which is the cheapest bypass there is. A throw here
-    // leaves `telemetryPath` undefined, which the catch tolerates: there is no root to write a
-    // row under anyway.
-    let telemetryPath;
-    try {
-        const envTelemetryPath = process.env.POLYDEUKES_TELEMETRY_PATH;
-        telemetryPath =
-            spec.telemetryPath ?? envTelemetryPath ?? join(spec.repoRoot, DEFAULT_TELEMETRY_LOG_PATH);
-        // Discovery + parse + validation are the loader's job; a throw here (absent, ambiguous,
-        // unparseable, or invalid config) falls into the fail-closed catch.
-        const { config } = loadConfig({ rootDir: spec.repoRoot });
-        telemetryPath =
-            spec.telemetryPath ?? envTelemetryPath ?? resolve(spec.repoRoot, config.telemetry.logPath);
-        // Settled for the rest of the happy path. The `let` above exists so the catch can still
-        // record when a failure lands before this point; a closure cannot narrow it, so the
-        // dispatch seam below takes this const instead.
-        const logPath = telemetryPath;
-        const rawPayload = rewriteGrokToolNames(spec.rawPayload ?? readFileSync(0, 'utf-8'));
-        // The transcript path travels in the raw payload only — up-translation drops it, so the
-        // adapter reads it from the string. Every failure narrows to `undefined`, which leaves
-        // the dispatcher on its `noopTranscript` default: lost evidence closes the valve rather
-        // than opening it.
-        const transcriptPath = transcriptPathFromPayload({ rawPayload });
-        const transcript = transcriptPath === undefined ? undefined : transcriptFromJsonlFile({ path: transcriptPath });
-        // One witness predicate shared by every registration: a witness is a session-wide
-        // permission the human granted, not a per-covenant one. Absent `witness` config leaves
-        // this undefined, and no verdict can be witnessed open at all. The predicate receives
-        // the transcript as its second argument from the dispatcher, which is why the transcript
-        // is injected below rather than captured here.
-        const witness = config.witness === undefined
-            ? undefined
-            : ttlWitness({
-                token: config.witness.token,
-                // Minutes are the human-facing unit in config; the predicate takes milliseconds.
-                // Core passes the value through verbatim, so the conversion belongs to assembly.
-                ttlMs: config.witness.ttlMinutes * 60_000,
-            });
-        // The judges are the covenant package's built barrel — resolved through the real
-        // package (never a test alias), so the session surface runs the same judges the commit
-        // surface does. An injected directory overrides that resolution, which is how a fixture
-        // reaches a dist that real Node resolution would never land on. Awaited HERE, before
-        // any registration is composed: a dist the barrel cannot load throws now, into the
-        // fail-closed catch, instead of leaving a half-judged table behind.
-        const covenantDist = spec.covenantDist ?? resolveCovenantDist();
-        const covenant = await loadCovenantModule(covenantDist);
-        // Assembled HERE, outside the dispatch seam: a judge takes its call set as an argument,
-        // so assembly needs no payload, and an assembly throw belongs to this function's own
-        // fail-closed catch — `hook` label, `covenant hook failed closed:` on stderr. Composed
-        // inside the dispatch closure it would land in `runAdapterPath`'s catch instead, which
-        // records the adapter's label and says nothing about what broke.
-        const registrations = assembleSessionRegistrations({
-            config,
-            rootDir: spec.repoRoot,
-            covenant,
-            transcriptPath,
-            transcript,
-            witness,
-        });
-        // The world axis: files read from disk under the repository root, channels read beside
-        // the session's transcript. The disk is the pre-edit state on this surface; the rule
-        // that the judged change's own `post` overrides it belongs to the judge, so the root
-        // supplies what it read and nothing more. No `changes` list either — one PreToolUse call
-        // is the whole observation, and the judge derives that set from the input.
-        const { files, channels } = covenant.supplySources({
-            plan: covenant.planSources({ registrations }),
-            read: sessionSourceReader({ repoRoot: spec.repoRoot }),
-            readChannel: sessionChannelReader({ transcriptPath }),
-        });
-        return await runAdapterPath({
-            rawPayload,
-            telemetryPath: logPath,
-            dispatch: (stdinPayload) => covenant.dispatchCovenants({
-                stdinPayload,
-                registrations,
-                telemetryPath: logPath,
-                transcript,
-                world: { files, channels },
-            }),
-        });
-    }
-    catch (error) {
-        process.stderr.write(`covenant hook failed closed: ${error instanceof Error ? error.message : String(error)}\n`);
-        // Honor the one-call-one-record invariant with a blocked record under the assembly's own
-        // label — never a judge's, since no judge answered. `undefined` means the failure landed
-        // before a path could even be composed (a non-string repoRoot), where there is nowhere
-        // to write and nothing to attribute the row to.
-        if (telemetryPath !== undefined) {
-            appendRecordFailOpen(telemetryPath, { event: 'blocked', label: 'hook', subject: '-' });
-        }
-        return { exitCode: 2 };
-    }
-}
-/**
- * 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 async function runClaudeCodeHook(spec) {
-    let comparison;
-    try {
-        comparison = comparisonSpec(spec);
-        if (comparison !== undefined) {
-            compareBaseline(comparison);
-        }
-    }
-    catch {
-        // fail-open: a comparison that could not run leaves the judgment exactly as it was.
-    }
-    const result = await judgeHookCall(spec);
-    try {
-        if (comparison !== undefined) {
-            updateBaseline(comparison);
-        }
-    }
-    catch {
-        // fail-open: an unwritable baseline costs the next call's detection, never this verdict.
-    }
-    return result;
-}

package/dist/claude-code.d.ts

@@ -1,6 +0,0 @@
-/**
- * `polydeukes/claude-code` — the session surface's entry point.
- *
- * The delegator a consumer project's PreToolUse hook imports: one verb and its spec type.
- */
-export { type ClaudeCodeHookOutcome, type ClaudeCodeHookSpec, runClaudeCodeHook, } from './claude-code-hook.ts';

package/dist/claude-code.js

@@ -1,6 +0,0 @@
-/**
- * `polydeukes/claude-code` — the session surface's entry point.
- *
- * The delegator a consumer project's PreToolUse hook imports: one verb and its spec type.
- */
-export { runClaudeCodeHook, } from './claude-code-hook.js';

package/dist/covenant-module.d.ts

@@ -1,25 +0,0 @@
-/**
- * The covenant package as a resolved artifact — the existence proof both composition roots
- * share.
- *
- * What the roots prove is the package IMPORT itself. The barrel is eager: a dist missing one
- * of the modules it references throws on import, before any assembly can compose a
- * registration, and the surface's own fail-closed catch records that as one `blocked` row. A
- * partially loaded judge set has no representation here — an ESM import either fully succeeds
- * or throws.
- *
- * The `covenantDist` seam selects WHICH dist is imported, so a fixture can inject a gutted
- * mirror where real Node resolution would always land on the healthy build.
- */
-import type * as covenant from '@polydeukes/covenant';
-/** The covenant surface both roots assemble against — the members they call, and no more. */
-export type CovenantModule = Pick<typeof covenant, 'dispatchCovenants' | 'compileDisciplineRegistrations' | 'selfModRegistration' | 'shellModRegistration' | 'transcriptModRegistration' | 'planSources' | 'supplySources'>;
-/** Where real Node resolution puts the covenant package's built barrel. */
-export declare function resolveCovenantDist(): string;
-/**
- * Import the covenant barrel from `distDir`, naming the recovery command when it will not
- * load. The message carries the loader's own text, which names the module that is missing;
- * a reader locked out by an unbuilt or half-built dist needs both that name and the one
- * command that fixes it.
- */
-export declare function loadCovenantModule(distDir: string): Promise<CovenantModule>;

package/dist/covenant-module.js

@@ -1,42 +0,0 @@
-/**
- * The covenant package as a resolved artifact — the existence proof both composition roots
- * share.
- *
- * What the roots prove is the package IMPORT itself. The barrel is eager: a dist missing one
- * of the modules it references throws on import, before any assembly can compose a
- * registration, and the surface's own fail-closed catch records that as one `blocked` row. A
- * partially loaded judge set has no representation here — an ESM import either fully succeeds
- * or throws.
- *
- * The `covenantDist` seam selects WHICH dist is imported, so a fixture can inject a gutted
- * mirror where real Node resolution would always land on the healthy build.
- */
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { createRequire } from 'node:module';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-/** Where real Node resolution puts the covenant package's built barrel. */
-export function resolveCovenantDist() {
-    return join(createRequire(import.meta.url).resolve('@polydeukes/covenant'), '..');
-}
-/**
- * Import the covenant barrel from `distDir`, naming the recovery command when it will not
- * load. The message carries the loader's own text, which names the module that is missing;
- * a reader locked out by an unbuilt or half-built dist needs both that name and the one
- * command that fixes it.
- */
-export async function loadCovenantModule(distDir) {
-    try {
-        return (await import(__rewriteRelativeImportExtension(pathToFileURL(join(distDir, 'index.js')).href)));
-    }
-    catch (error) {
-        throw new Error(`the covenant judges could not be loaded from ${distDir} — run 'pnpm build' to rebuild them: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/docs/reference/packages/adapter-git.ko.md

@@ -1,101 +0,0 @@
-# `@polydeukes/adapter-git`
-
-[English](adapter-git.md) · **한국어**
-
-> **커밋 표면의 번역기**입니다. 스테이징된 diff가 약속(covenant) 입력 IR이 되고,
-> `adapters.git` 설정 네임스페이스가 여기서 정의됩니다.
->
-> 알파입니다. 통합 패키지의 의존성으로 설치되므로 일반 사용자가 따로 설치하거나 불러올 필요는 없습니다. 커밋 표면은
-> [`pdks covenant check`](polydeukes.ko.md#polydeukes-bin)를 통해 닿습니다.
-
-<a id="ownership"></a>
-## 담당하는 기능
-
-Git의 변경 정보를 세션 표면과 같은 공통 입력 형식으로 번역합니다. 작성자가 AI인지 사람인지에 따라 판정 방식을 달리하지 않습니다.
-
-| 단위 | 하는 일 |
-|---|---|
-| 스테이징 변경 수집 | 스테이징 영역을 내용 기준선을 갖춘 변경 목록으로 읽습니다 |
-| 순수 번역 | 변경 목록을 하나의 `CovenantInput`으로 바꿉니다 |
-| 설정 어휘 | 이 어댑터 자신의 설정 네임스페이스를 검증합니다 |
-
-순수 라이브러리입니다. 스테이징된 diff의 형태를 알 뿐 설치나 훅 러너, 밸브는 알지
-못합니다. pre-commit 훅에 배선하는 것은 우산이 맡는 배포 행위입니다.
-`@polydeukes/core`는 `peerDependency`로 부릅니다. 판정기와 같은 어휘를 공유하며 별도 사본을 설치하지 않습니다.
-
-<a id="collection"></a>
-## 수집과 `adapters.git` 네임스페이스
-
-**세 수집기가 같은 형식으로 결과를 반환합니다.** `collectStagedChanges` · `collectWorktreeChanges` ·
-`collectRangeChanges({ repoRoot, range: '<base>..<head>' | '<base>...<head>' })`는 모두 같은
-`StagedChange[]`를 반환하므로 이후에는 같은 번역기와 판정 경로를 사용합니다.
-
-| 수집기 | `pre` | `post` | 그 밖에 |
-|---|---|---|---|
-| staged | HEAD blob | **스테이징된** blob. 워크트리는 쓰지 않습니다. `git add` 뒤에 갈라졌을 수 있습니다 | |
-| worktree | HEAD blob | 디스크의 바이트 | 추적하지 않는 파일도 무시 대상이 아니면 `added`로 포함하며, 디스크에서 사라진 파일은 HEAD에 있었든 인덱스에만 있었든 `deleted`입니다. 읽을 수 없는 경로(깨진 심볼릭 링크)는 내용 null로 경로만 판정합니다 |
-| range | base blob | head blob | `...`는 base를 `git merge-base`로 해소합니다. git이 해소하지 못하는 ref나 merge-base 없는 두 ref는 예외를 던집니다 |
-
-**수집기는 증거로 사용할 수 있는 내용을 제한합니다.**
-
-| 결정 | 이유 |
-|---|---|
-| 모든 수집기에서 `--no-renames` 강제 | 이름 변경을 삭제 더하기 추가로 판정합니다. 보호 파일의 `git mv`가 불투명한 이름 변경 항목 하나로 빠져나가면 안 됩니다 |
-| 바이너리 blob이나 파일은 내용을 null로 | 손실 있게 디코딩된 바이트를 싣지 않습니다 |
-| 첫 커밋 이전 상태는 전부 추가로 좁힘 | 예외를 던지지 않습니다. staged와 worktree가 같습니다 |
-| 타입 변경(`T`)은 `pre`를 유지 | 심볼릭 링크가 파일로 바뀐 것은 수정이라, delta 판정이 사라진 내용을 봅니다 |
-| 모든 목록 명령은 `--`로 끝남 | 파일과 이름이 같은 브랜치도 ref이지 모호한 인자가 아닙니다 |
-
-번역은 변경 하나마다 도구 호출 하나를 만듭니다. 이름은 어댑터가 소유한 `staged-write`와
-`staged-delete`입니다. 삭제는 언제나 증거를 답니다. 쓰기는 스테이징된 blob이 바이너리인
-경우를 빼고 증거를 답니다. 그때는 견줄 텍스트가 없으므로 `fileChange` 없이 도착하고,
-증명되지 않은 다른 호출과 똑같이 경로만으로 판정됩니다. **세션 컬렉션은 정직하게
-비어 있습니다.** 커밋 표면에는 세션이 없고, 있는 것처럼 보이게 키를 지어내지 않습니다.
-`actor`도 없습니다. 훅은 사람의 `git commit`과 에이전트의 것을 구별할 수 없으므로 아무것도
-증명하지 않습니다.
-
-**네임스페이스는 이 어댑터 자신의 어휘입니다.** 코어는 컨테이너 형태만 검증합니다.
-어댑터마다 설정 객체 하나라는 것까지이고 내용은 그대로 통과시킵니다. 그래서 어휘와 그
-검증기와 기본값이 전부 여기 있습니다.
-
-| 키 | 값 | 기본값 | 뜻 |
-|---|---|---|---|
-| `adapters.git.enforce` | `block` \| `advise` | `block` | 커밋 표면의 판정이 무엇을 **하는지** |
-| `adapters.git.protectedPaths` | string[] | `[]` | 커밋 표면의 **가산** 보호 범위입니다. 공통 목록 위에 얹혀 판정됩니다 |
-
-알 수 없는 키, 허용된 두 값 이외의 `enforce`, 문자열 배열이 아닌 `protectedPaths`는
-즉시 거부하며 오류에 전체 필드 경로를 표시합니다. 작성 레퍼런스는
-[설정 레퍼런스의 `adapters` 절](../configuration/index.ko.md#adapters)입니다.
-
-**추가 보호 범위는 관측자가 정합니다.** 강제 수준과 마찬가지로 해당 표면의 설정입니다. 여기 적힌 항목은 작업이 역사가 되는 시점에 판정되고 세션 표면은 그것을 읽지
-않습니다. 저장소가 판정기 **소스**를 세션에서 편집할 수 있게 두면서도 그것을 올리는
-커밋은 멈출 수 있는 이유가 이것입니다.
-
-`enforce: advise`에서는 밸브를 구성하지 않습니다. 위반은 `advised`로 기록하고 권고를
-stderr에 출력한 뒤 커밋을 계속합니다. 달라지는 것은 위반 뒤의 처리이지 판정 기준이 아닙니다.
-판정할 수 없는 실행은 어느 강제 수준에서도 종료 코드 `2`로 차단합니다(fail-closed).
-
-<a id="consumer-contract"></a>
-## 사용자와의 접점
-
-- **설정의 `adapters.git` 블록.**
-- **`pdks covenant check`를 실행하는 pre-commit 훅.** 손으로 배선하며, 훅 관리자 셋의
-  수동 절차는
-  [설치](../../how-to/connect-surfaces.ko.md#commit-surface)에 있습니다.
-
-일반 사용자가 직접 불러올 필요는 없습니다.
-
-<a id="limits"></a>
-## 선언된 한계
-
-- **세션을 읽는 선언은 여기서 판정할 수 없습니다.** `precedent`는 세션 이력이 필요한데 커밋에는
-  없습니다. 항목이 `skipped`와 `supply-pass`를 남기는 것은 그 선언의 `supply`가 `pass`일
-  때뿐입니다. 정책이 없으면 없는 세션은 판정 불가(exit 2)입니다. 항목의 결함이 아니라 이
-  표면이 제공하는 증거의 한계입니다.
-- **추적하지 않는 파일이 무시 대상이면 이 표면에서 관측하지 않습니다. 이미 추적 중인 파일은
-  `.gitignore`와 무관하게 관측합니다.** 무시 대상이며 한 번도 추가하지 않은 `dist`는 보이지
-  않지만, 추적 중인 파일은 나중에 무시 패턴에 해당하더라도 `git diff`에 남습니다. 세션 표면이 생성 경로를 공통 목록에
-  싣는 이유입니다.
-- **밸브에는 터미널 앞의 사람이 필요합니다.** TTY가 없으면 프롬프트를 표시하지 못하므로
-  증언으로 차단을 해제할 수 없습니다. CI 실행과 에이전트가 시작한 `git commit`에도 같은 조건을 적용합니다. 무엇도
-  저장되지 않으므로 한 번의 답이 나중 커밋을 덮지 않습니다.