codictator 0.0.0 → 0.1.2

package/dist/features/generator/self-test.js

@@ -0,0 +1,65 @@
+// SPEC §4.16.3: in-memory self-test of a drafted pack. Mirrors the §4.4.4
+// semantics (each violating fixture must flag, each passing fixture must
+// stay clean) without the loader, so draftPack stays pure and deterministic.
+import { err, makeError, ok } from "../../kernel/index.js";
+function compilePattern(spec) {
+    if (spec.pattern === undefined) {
+        return err(makeError("CDX-E205", `rule "${spec.id}" needs a pattern for a pattern enforcer`, "Give the rule a pattern in its template params, then retry the draft."));
+    }
+    try {
+        return ok(new RegExp(spec.pattern));
+    }
+    catch {
+        return err(makeError("CDX-E205", `rule "${spec.id}" carries a pattern the regex engine rejects`, "Fix the pattern so it compiles, then retry the draft."));
+    }
+}
+function testForbid(spec, expression) {
+    if (!expression.test(spec.violatingFixture)) {
+        return err(makeError("CDX-E212", `rule "${spec.id}" violating fixture yielded no finding with this rule id`, "Strengthen the drafted pattern so the violating case blocks, then retry the draft."));
+    }
+    if (expression.test(spec.passingFixture)) {
+        return err(makeError("CDX-E213", `rule "${spec.id}" passing fixture yielded a finding with this rule id`, "Narrow the drafted pattern so the passing case stays clean, then retry the draft."));
+    }
+    return ok(undefined);
+}
+function testRequire(spec, expression) {
+    if (expression.test(spec.violatingFixture)) {
+        return err(makeError("CDX-E212", `rule "${spec.id}" violating fixture should lack the required text`, "Fix the violating fixture so it misses the required pattern, then retry the draft."));
+    }
+    if (!expression.test(spec.passingFixture)) {
+        return err(makeError("CDX-E213", `rule "${spec.id}" passing fixture should carry the required text`, "Fix the passing fixture so it carries the required pattern, then retry the draft."));
+    }
+    return ok(undefined);
+}
+function testSpec(spec) {
+    if (spec.violatingFixture.length === 0) {
+        return err(makeError("CDX-E211", `rule "${spec.id}" has no violating fixture`, "Add a violating fixture, then retry the draft."));
+    }
+    if (spec.remediation.length === 0 || spec.remediation === spec.reason) {
+        return err(makeError("CDX-E214", `rule "${spec.id}" remediation is empty or repeats its reason`, "Write remediation as Do-instead text distinct from Why, then retry the draft."));
+    }
+    if (spec.kind !== "pattern-forbid" && spec.kind !== "pattern-require") {
+        return err(makeError("CDX-E205", `rule "${spec.id}" needs the loader-backed self-test for kind "${spec.kind}"`, "Draft a pattern template offline, or run the pack self-test after materialising."));
+    }
+    const compiled = compilePattern(spec);
+    if (!compiled.ok) {
+        return err(compiled.error);
+    }
+    if (spec.kind === "pattern-require") {
+        return testRequire(spec, compiled.value);
+    }
+    return testForbid(spec, compiled.value);
+}
+// SPEC §4.16.3: self-test every drafted rule; the first failure names its
+// rule so the report says which fixture failed. Rules run in id order so the
+// first failure is deterministic.
+export function selfTestSpecs(specs) {
+    const ordered = [...specs].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    for (const spec of ordered) {
+        const tested = testSpec(spec);
+        if (!tested.ok) {
+            return err(tested.error);
+        }
+    }
+    return ok(undefined);
+}

package/dist/features/generator/templates.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from "../../kernel/index.ts";
+export interface TemplateDecl {
+    readonly id: string;
+    readonly kind: string;
+    readonly description: string;
+}
+export declare function lookupTemplate(id: string): TemplateDecl | undefined;
+export declare function catalogueSummary(): string;
+export type DraftTier = "floor" | "tunable";
+export interface DraftRule {
+    readonly id: string;
+    readonly template: string;
+    readonly params: Readonly<Record<string, unknown>>;
+    readonly statement: string;
+    readonly reason: string;
+    readonly remediation: string;
+    readonly tier: DraftTier;
+    readonly violatingFixture: string;
+    readonly passingFixture: string;
+}
+export interface PackDraft {
+    readonly packId: string;
+    readonly description: string;
+    readonly rules: ReadonlyArray<DraftRule>;
+}
+export declare function narrowPackDraft(value: unknown, expectedPackId: string, floorRuleId?: string): Result<PackDraft>;

package/dist/features/generator/templates.js

@@ -0,0 +1,177 @@
+// SPEC §4.16.2: the template catalogue and the pack-draft shape (§4.16.3).
+// Validation here mirrors schema/pack-draft.schema.json so the LLM draft,
+// the prompt and the offline checks agree on one definition.
+import { checkPattern, err, makeError, ok, } from "../../kernel/index.js";
+// SPEC §4.16.2: every template id the generator accepts, with the enforcer
+// kind it materialises into. Only parametric data is ever produced (§11 S23:
+// an LLM never authors executable enforcement code).
+const TEMPLATE_CATALOGUE = [
+    {
+        id: "forbid-pattern",
+        kind: "pattern-forbid",
+        description: "forbid text matching a regex",
+    },
+    {
+        id: "require-pattern",
+        kind: "pattern-require",
+        description: "require text matching a regex",
+    },
+    {
+        id: "forbid-import",
+        kind: "import-forbid",
+        description: "forbid imports matching a module glob",
+    },
+    {
+        id: "placement",
+        kind: "path-placement",
+        description: "confine files to allowed directories",
+    },
+    {
+        id: "max-size",
+        kind: "file-size",
+        description: "cap file lines or bytes",
+    },
+    {
+        id: "forbid-command",
+        kind: "command-forbid",
+        description: "forbid shell commands matching a pattern",
+    },
+    {
+        id: "require-file",
+        kind: "file-required",
+        description: "require a file with matching content",
+    },
+    {
+        id: "config-key",
+        kind: "json-key",
+        description: "require a config key and value",
+    },
+    {
+        id: "external",
+        kind: "external",
+        description: "delegate to a configured external tool",
+    },
+];
+export function lookupTemplate(id) {
+    return TEMPLATE_CATALOGUE.find((entry) => entry.id === id);
+}
+// SPEC §4.16.3: the catalogue line the LLM prompt carries.
+export function catalogueSummary() {
+    return TEMPLATE_CATALOGUE.map((entry) => `${entry.id} -> ${entry.kind}`).join(", ");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Bracket access through a variable keeps noPropertyAccessFromIndexSignature
+// satisfied (kernel narrows the same way).
+function field(record, name) {
+    return record[name];
+}
+function draftError(detail) {
+    return err(makeError("CDX-E853", `LLM draft is invalid: ${detail}`, "Draft offline with --template, or fix the generator prompt, then retry."));
+}
+function templateError(template) {
+    return err(makeError("CDX-E205", `draft references unknown template "${template}"`, "Use a template id from the §4.16.2 catalogue, then retry the draft."));
+}
+function ownerError(ruleId, packId) {
+    return err(makeError("CDX-E204", `draft rule "${ruleId}" is outside pack "${packId}"`, "Generated packs own only their own rule ids; rename the rule under the pack id, then retry."));
+}
+function nonEmptyText(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function narrowRule(value, packId, floorRuleId) {
+    if (!isRecord(value)) {
+        return draftError("every rule must be a JSON object");
+    }
+    const id = field(value, "id");
+    const template = field(value, "template");
+    const params = field(value, "params");
+    const statement = field(value, "statement");
+    const reason = field(value, "reason");
+    const remediation = field(value, "remediation");
+    const tier = field(value, "tier");
+    const violatingFixture = field(value, "violatingFixture");
+    const passingFixture = field(value, "passingFixture");
+    if (!nonEmptyText(id)) {
+        return draftError("every rule needs a non-empty string id");
+    }
+    if (!id.startsWith(`${packId}/`)) {
+        return ownerError(id, packId);
+    }
+    if (typeof template !== "string" || lookupTemplate(template) === undefined) {
+        return templateError(typeof template === "string" ? template : "unknown");
+    }
+    if (!isRecord(params)) {
+        return draftError(`rule "${id}" needs a params object`);
+    }
+    if (!nonEmptyText(statement)) {
+        return draftError(`rule "${id}" needs a non-empty statement`);
+    }
+    if (!nonEmptyText(reason)) {
+        return draftError(`rule "${id}" needs a non-empty reason`);
+    }
+    if (!nonEmptyText(remediation) || remediation === reason) {
+        return draftError(`rule "${id}" needs remediation distinct from its reason`);
+    }
+    if (tier !== "floor" && tier !== "tunable") {
+        return draftError(`rule "${id}" tier must be floor or tunable`);
+    }
+    if (tier === "floor" && id !== floorRuleId) {
+        return draftError(`rule "${id}" is floor without --floor; strictness is a human choice`);
+    }
+    if (!nonEmptyText(violatingFixture)) {
+        return draftError(`rule "${id}" needs a violating fixture`);
+    }
+    if (!nonEmptyText(passingFixture)) {
+        return draftError(`rule "${id}" needs a passing fixture`);
+    }
+    // SPEC §4.16 EC-5 + §9.2: every drafted regex passes the kernel safety
+    // check before use; a catastrophic pattern fails the draft here.
+    const rawPattern = field(params, "pattern");
+    if (typeof rawPattern === "string") {
+        const safe = checkPattern(rawPattern);
+        if (!safe.ok) {
+            return err(safe.error);
+        }
+    }
+    return ok({
+        id,
+        template,
+        params,
+        statement,
+        reason,
+        remediation,
+        tier,
+        violatingFixture,
+        passingFixture,
+    });
+}
+// SPEC §4.16.3: schema-check the draft. Pattern-safety failures keep their
+// CDX-E902 so the caller can fail closed without a repair round; every other
+// failure is repairable and returns CDX-E205, CDX-E204 or CDX-E853.
+export function narrowPackDraft(value, expectedPackId, floorRuleId) {
+    if (!isRecord(value)) {
+        return draftError("the draft must be a JSON object");
+    }
+    const packId = field(value, "packId");
+    const description = field(value, "description");
+    const rules = field(value, "rules");
+    if (packId !== expectedPackId) {
+        return draftError("the draft packId must equal the requested pack id");
+    }
+    if (!nonEmptyText(description)) {
+        return draftError("the draft needs a non-empty description");
+    }
+    if (!Array.isArray(rules) || rules.length === 0) {
+        return draftError("the draft needs at least one rule");
+    }
+    const narrowed = [];
+    for (const entry of rules) {
+        const rule = narrowRule(entry, expectedPackId, floorRuleId);
+        if (!rule.ok) {
+            return err(rule.error);
+        }
+        narrowed.push(rule.value);
+    }
+    return ok({ packId: expectedPackId, description, rules: narrowed });
+}

package/dist/features/integrity/drift.d.ts

@@ -0,0 +1,19 @@
+import type { CheckContext, Finding } from "../engine/index.ts";
+import { type GuardrailManifest } from "./manifest.ts";
+export interface FileContent {
+    readonly path: string;
+    readonly content: string;
+}
+export interface InstalledHook {
+    readonly name: string;
+    readonly executable: boolean;
+}
+export interface DriftSnapshot {
+    readonly files: ReadonlyArray<FileContent>;
+    readonly hooksPath?: string;
+    readonly hooksExecutable?: boolean;
+    readonly installedHooks?: ReadonlyArray<InstalledHook>;
+    readonly engineVersion?: string;
+    readonly expectedHooksPath?: string;
+}
+export declare function checkDrift(_ctx: CheckContext, manifest: GuardrailManifest, snapshot?: DriftSnapshot): Array<Finding>;

package/dist/features/integrity/drift.js

@@ -0,0 +1,168 @@
+// SPEC §4.14.1–§4.14.2: drift (working tree vs manifest) and tamper checks.
+// The caller supplies a snapshot of the working tree, so this module stays
+// pure and port-free; the CLI builds the snapshot through kernel ports.
+import { sha256Text } from "../../kernel/index.js";
+import { EXPECTED_HOOKS_PATH } from "./hooks.js";
+import { verifyManifest } from "./manifest.js";
+// SPEC §4.6.2 managed-block markers, cited here for block-mode hashing.
+const BLOCK_BEGIN = "<!-- codictator:begin -->";
+const BLOCK_END = "<!-- codictator:end -->";
+function manifestFinding(message, remediation) {
+    return {
+        ruleId: "core/guardrail-manifest",
+        code: "CDX-E501",
+        message,
+        remediation,
+    };
+}
+// SPEC §4.14.6 EC-5: hashes normalize first, so autocrlf cannot fake drift.
+function hashForMode(mode, content) {
+    if (mode === "file") {
+        return sha256Text(content);
+    }
+    if (mode === "entries") {
+        // SPEC §4.14.1: entries mode hashes the canonical projection of owned
+        // entries; the caller projects before snapshotting, so user additions
+        // outside the projection (EC-6) never reach this comparison.
+        return sha256Text(content);
+    }
+    const first = content.indexOf(BLOCK_BEGIN);
+    const last = content.indexOf(BLOCK_END);
+    if (first < 0 || last < 0 || first >= last) {
+        return undefined;
+    }
+    const repeats = content.indexOf(BLOCK_BEGIN, first + BLOCK_BEGIN.length) >= 0;
+    if (repeats) {
+        return undefined;
+    }
+    return sha256Text(content.slice(first, last + BLOCK_END.length));
+}
+function checkArtifact(path, mode, expected, actual) {
+    const content = actual.get(path);
+    if (content === undefined) {
+        return [
+            {
+                ...manifestFinding(`generated artifact ${path} is missing from the working tree`, "Restore it with `codictator regen`; delete it only by dropping its owner from config first (§4.14 EC-10)."),
+                path,
+            },
+        ];
+    }
+    const hash = hashForMode(mode, content);
+    if (hash === undefined) {
+        return [
+            {
+                ...manifestFinding(`managed block markers in ${path} are malformed or duplicated`, "Restore the single managed block with `codictator regen` (§4.14 EC-6 keeps user text outside the block)."),
+                path,
+                code: "CDX-E501",
+            },
+        ];
+    }
+    if (hash !== expected) {
+        return [
+            {
+                ...manifestFinding(`generated artifact ${path} differs from its manifest hash`, "Never hand-edit generated artifacts; change config and run `codictator regen` (§4.14.5)."),
+                path,
+            },
+        ];
+    }
+    return [];
+}
+const REQUIRED_HOOKS = ["pre-commit", "commit-msg", "pre-push"];
+function hooksFinding(message, remediation) {
+    return { ruleId: "core/hooks-active", message, remediation };
+}
+function checkInstalledHooks(installed) {
+    const present = new Set(installed.map((hook) => hook.name));
+    for (const required of REQUIRED_HOOKS) {
+        if (!present.has(required)) {
+            // SPEC §4.14.6 EC-2: L0 and L4 report the deleted hook; L3 cannot.
+            return [
+                hooksFinding(`hook ${required} is missing from the installed hooks dir`, "Run `codictator install-hooks` to reinstall it (EC-2)."),
+            ];
+        }
+    }
+    for (const hook of installed) {
+        if (!hook.executable) {
+            return [
+                hooksFinding(`hook ${hook.name} lost its executable bit (for example after a Windows commit)`, "Run `git update-index --chmod=+x` on the hook and keep the .gitattributes entry from install-hooks (§4.14 EC-12)."),
+            ];
+        }
+    }
+    return [];
+}
+function checkHooks(snapshot) {
+    const expected = snapshot.expectedHooksPath ?? EXPECTED_HOOKS_PATH;
+    if (snapshot.installedHooks !== undefined) {
+        const findings = checkInstalledHooks(snapshot.installedHooks);
+        if (findings.length > 0) {
+            return findings;
+        }
+    }
+    if (snapshot.hooksPath === undefined) {
+        return [
+            {
+                ruleId: "core/hooks-active",
+                message: "hook state is unavailable: cannot confirm hooks are installed",
+                remediation: `Run \`codictator install-hooks\` to reinstall the hooks and point core.hooksPath at ${expected} (§4.14 EC-9).`,
+            },
+        ];
+    }
+    if (snapshot.hooksPath !== expected) {
+        return [
+            {
+                ruleId: "core/hooks-active",
+                message: `core.hooksPath points at ${snapshot.hooksPath}, not the installed hooks dir ${expected}`,
+                remediation: `Run \`codictator install-hooks\` to reinstall the hooks (§4.14 EC-9).`,
+            },
+        ];
+    }
+    if (snapshot.hooksExecutable === false) {
+        return [
+            {
+                ruleId: "core/hooks-active",
+                message: "a hook file lost its executable bit (for example after a Windows commit)",
+                remediation: "Run `git update-index --chmod=+x` on the hook and keep the .gitattributes entry from install-hooks (§4.14 EC-12).",
+            },
+        ];
+    }
+    return [];
+}
+// SPEC §4.14.2: L0 detection blocks all tool calls except regen, status and
+// reads, so an agent repairs guardrails before working. Every finding here
+// is floor and is listed first in the CI summary.
+export function checkDrift(_ctx, manifest, snapshot) {
+    const findings = [];
+    if (!verifyManifest(manifest)) {
+        findings.push(manifestFinding("the manifest itself was edited outside regen (self hash mismatch)", "Regenerate with `codictator regen`; guardrails change only through config (§4.14.5)."));
+    }
+    if (snapshot === undefined) {
+        // SPEC §10.3 fail-closed: with no working-tree evidence the hooks
+        // cannot be confirmed active, so report rather than allow.
+        findings.push(...checkHooks({ files: [] }));
+        return findings;
+    }
+    const actual = new Map();
+    for (const file of snapshot.files) {
+        actual.set(file.path.replaceAll("\\", "/"), file.content);
+    }
+    for (const artifact of manifest.artifacts) {
+        findings.push(...checkArtifact(artifact.path, artifact.mode, artifact.hash, actual));
+    }
+    findings.push(...checkHooks(snapshot));
+    if (snapshot.engineVersion !== undefined &&
+        snapshot.engineVersion !== manifest.codictator) {
+        findings.push({
+            ruleId: "core/engine-version-match",
+            message: `installed engine ${snapshot.engineVersion} does not match config ${manifest.codictator}`,
+            remediation: "Install the pinned engine version, then rerun `codictator regen` (§4.14.2).",
+        });
+    }
+    if (snapshot.engineVersion === undefined) {
+        findings.push({
+            ruleId: "core/engine-version-match",
+            message: "the launcher is missing: no installed engine found",
+            remediation: "Run `npm ci --ignore-scripts` (or install the tool dir) so the launcher resolves (§4.14.2).",
+        });
+    }
+    return findings;
+}

package/dist/features/integrity/hooks.d.ts

@@ -0,0 +1,19 @@
+export declare const EXPECTED_HOOKS_PATH = ".githooks";
+export declare const HOOK_NAMES: readonly ["pre-commit", "commit-msg", "pre-push"];
+export type HookName = (typeof HOOK_NAMES)[number];
+export declare function renderHookScript(hook: HookName, minMajor?: number): string;
+export declare const HUSKY_BEGIN = "# codictator:begin";
+export declare const HUSKY_END = "# codictator:end";
+export declare function renderHuskyBlock(hook: HookName): string;
+export interface HookInstallPlan {
+    readonly files: ReadonlyArray<string>;
+    readonly mode: number;
+    readonly hooksPath: string;
+    readonly prepareScript: string;
+    readonly gitattributes: string;
+    readonly huskyBlocks: ReadonlyArray<string>;
+}
+export declare function hookInstallPlan(options?: {
+    readonly huskyPresent?: boolean;
+    readonly existingHooksPath?: string;
+}): HookInstallPlan;

package/dist/features/integrity/hooks.js

@@ -0,0 +1,54 @@
+// SPEC §4.14.4: git-hook installation. Content generation is pure so unit
+// tests assert the scripts without touching .git/; the CLI wires ports.
+export const EXPECTED_HOOKS_PATH = ".githooks";
+export const HOOK_NAMES = ["pre-commit", "commit-msg", "pre-push"];
+// SPEC §4.14.4: each hook verifies node is on PATH and meets the minimum,
+// else prints CDX-E001/CDX-E002 and exits 1; then execs the launcher.
+export function renderHookScript(hook, minMajor = 24) {
+    const lines = [
+        "#!/bin/sh",
+        "# codictator:begin — managed by codictator; do not edit by hand.",
+        "# SPEC §4.14.4: generated hook; repair with `codictator install-hooks`.",
+        "if ! command -v node >/dev/null 2>&1; then",
+        '  echo "CDX-E001: node is not on PATH; install Node.js to run Codictator hooks." >&2',
+        "  exit 1",
+        "fi",
+        `if ! node -e "process.exit(Number(process.versions.node.split('.')[0]) >= ${minMajor} ? 0 : 1)" >/dev/null 2>&1; then`,
+        `  echo "CDX-E002: node is older than the required v${minMajor}; upgrade Node.js." >&2`,
+        "  exit 1",
+        "fi",
+        'ROOT="$(git rev-parse --show-toplevel 2>/dev/null)"',
+        `exec node "$ROOT/.codictator/bin/run.mjs" git ${hook} "$@"`,
+        "# codictator:end",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export const HUSKY_BEGIN = "# codictator:begin";
+export const HUSKY_END = "# codictator:end";
+// SPEC §4.14.4: when .husky/ exists, Codictator inserts a managed block into
+// Husky's hook files instead of taking over core.hooksPath.
+export function renderHuskyBlock(hook) {
+    return (`${HUSKY_BEGIN} — managed by codictator; do not edit by hand.\n` +
+        `.codictator/bin/run.mjs git ${hook} "$@"\n` +
+        `${HUSKY_END}\n`);
+}
+// SPEC §4.14.4 + EC-9/EC-12: install-hooks writes the hooks (mode 755),
+// points core.hooksPath at them, adds the npm prepare script, and records
+// the gitattributes remediation for Windows commits without the exec bit.
+export function hookInstallPlan(options) {
+    const husky = options?.huskyPresent === true;
+    const hooksPath = husky
+        ? (options?.existingHooksPath ?? ".husky")
+        : EXPECTED_HOOKS_PATH;
+    const files = husky
+        ? []
+        : HOOK_NAMES.map((hook) => `${EXPECTED_HOOKS_PATH}/${hook}`);
+    return {
+        files,
+        mode: 0o755,
+        hooksPath,
+        prepareScript: "codictator install-hooks",
+        gitattributes: `${EXPECTED_HOOKS_PATH}/* linguist-generated=false\n${EXPECTED_HOOKS_PATH}/* eol=lf\n`,
+        huskyBlocks: husky ? [...HOOK_NAMES] : [],
+    };
+}

package/dist/features/integrity/index.d.ts

@@ -0,0 +1,10 @@
+import type { CheckContext, Finding } from "../engine/index.ts";
+import { type DriftSnapshot, type FileContent, type InstalledHook } from "./drift.ts";
+import { EXPECTED_HOOKS_PATH, HOOK_NAMES, type HookInstallPlan, type HookName, hookInstallPlan, renderHookScript, renderHuskyBlock } from "./hooks.ts";
+import type { GuardrailManifest, ManifestArtifact } from "./manifest.ts";
+import { buildManifest, manifestHash, verifyManifest } from "./manifest.ts";
+import { type CommitInRange, checkCommitTrailers, checkPackageManifestEdit, isProtectedPath } from "./self-protection.ts";
+export type { CommitInRange, DriftSnapshot, FileContent, GuardrailManifest, HookInstallPlan, HookName, InstalledHook, ManifestArtifact, };
+export { buildManifest, checkCommitTrailers, checkPackageManifestEdit, EXPECTED_HOOKS_PATH, HOOK_NAMES, hookInstallPlan, isProtectedPath, manifestHash, renderHookScript, renderHuskyBlock, verifyManifest, };
+export declare function checkDrift(ctx: CheckContext, manifest: GuardrailManifest, snapshot?: DriftSnapshot): Array<Finding>;
+export declare function checkSelfProtection(ctx: CheckContext, command: ReadonlyArray<string>): Array<Finding>;

package/dist/features/integrity/index.js

@@ -0,0 +1,14 @@
+import { checkDrift as checkDriftImpl, } from "./drift.js";
+import { EXPECTED_HOOKS_PATH, HOOK_NAMES, hookInstallPlan, renderHookScript, renderHuskyBlock, } from "./hooks.js";
+import { buildManifest, manifestHash, verifyManifest } from "./manifest.js";
+import { checkCommitTrailers, checkPackageManifestEdit, checkSelfProtection as checkProtection, isProtectedPath, } from "./self-protection.js";
+export { buildManifest, checkCommitTrailers, checkPackageManifestEdit, EXPECTED_HOOKS_PATH, HOOK_NAMES, hookInstallPlan, isProtectedPath, manifestHash, renderHookScript, renderHuskyBlock, verifyManifest, };
+// SPEC §4.14.1: manifest comparison for drift; without a snapshot only the
+// manifest self hash and hook availability fail closed (§10.3).
+export function checkDrift(ctx, manifest, snapshot) {
+    return checkDriftImpl(ctx, manifest, snapshot);
+}
+// SPEC §4.14.3: self-protection (no bypass of hooks or required checks).
+export function checkSelfProtection(ctx, command) {
+    return checkProtection(ctx, command);
+}

package/dist/features/integrity/manifest.d.ts

@@ -0,0 +1,15 @@
+export interface ManifestArtifact {
+    readonly path: string;
+    readonly owner: string;
+    readonly mode: "file" | "block" | "entries";
+    readonly hash: string;
+}
+export interface GuardrailManifest {
+    readonly version: 1;
+    readonly codictator: string;
+    readonly artifacts: ReadonlyArray<ManifestArtifact>;
+    readonly hash: string;
+}
+export declare function manifestHash(artifacts: ReadonlyArray<ManifestArtifact>): string;
+export declare function buildManifest(codictator: string, artifacts: ReadonlyArray<ManifestArtifact>): GuardrailManifest;
+export declare function verifyManifest(manifest: GuardrailManifest): boolean;

package/dist/features/integrity/manifest.js

@@ -0,0 +1,26 @@
+// SPEC §4.14.1 + §7.14: the guardrail lockfile. Generation is deterministic
+// (artifacts sorted by path, stableStringify, no timestamps), so regen on
+// unchanged config reproduces the manifest byte for byte (§4.14 EC-11).
+import { sha256Text, stableStringify } from "../../kernel/index.js";
+// SPEC §7.14: the manifest hash covers the sorted artifacts array, so any
+// edit of the manifest itself outside regen is detectable (§4.14.2).
+export function manifestHash(artifacts) {
+    const sorted = [...artifacts].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return sha256Text(stableStringify(sorted));
+}
+// SPEC §4.14.5: regen rebuilds the manifest from config; sorting here keeps
+// the output independent of enumeration order and OS (EC-11).
+export function buildManifest(codictator, artifacts) {
+    const sorted = [...artifacts].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return {
+        version: 1,
+        codictator,
+        artifacts: sorted,
+        hash: manifestHash(artifacts),
+    };
+}
+// SPEC §4.14.2: recompute the self hash; a mismatch means the manifest was
+// edited outside regen and every integrity finding that follows is floor.
+export function verifyManifest(manifest) {
+    return manifest.hash === manifestHash(manifest.artifacts);
+}

package/dist/features/integrity/self-protection.d.ts

@@ -0,0 +1,12 @@
+import { isProtectedPath } from "../../kernel/index.ts";
+import type { CheckContext, Finding } from "../engine/index.ts";
+export { isProtectedPath };
+export declare function checkPackageManifestEdit(beforeText: string, afterText: string): Array<Finding>;
+export interface CommitInRange {
+    readonly sha: string;
+    readonly message: string;
+    readonly author: string;
+    readonly isMerge: boolean;
+}
+export declare function checkCommitTrailers(commits: ReadonlyArray<CommitInRange>, trailerExempt: ReadonlyArray<string>): Array<Finding>;
+export declare function checkSelfProtection(_ctx: CheckContext, command: ReadonlyArray<string>): Array<Finding>;