codictator 0.0.0 → 0.1.3

package/dist/features/adapters/custom-load.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Adapter } from "./contract.ts";
+export declare function loadCustomAdapter(root: string, id: string): Promise<Result<Adapter>>;

package/dist/features/adapters/custom-load.js

@@ -0,0 +1,185 @@
+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;
+};
+// SPEC §4.5.6: custom adapter loading from .codictator/adapters/<id>/.
+// The loader resolves the adapter module, validates its Adapter shape and
+// assembles the Adapter seam (CDX-E301 when nothing is installed, CDX-E302
+// while it has no passing contract tests), so every use stays inert until
+// it verifies. File reads go through the kernel Fs (confined to the repo
+// root); the module itself executes via a dynamic import, the generated
+// launcher's own pattern for loading code.
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { err, makeError, NodeFs, ok } from "../../kernel/index.js";
+import { narrowEvent } from "./custom-event.js";
+import { ADAPTER_BASE, ADAPTER_ENTRY, failParse, field, fullIdOf, isRecord, narrowAdapterCapabilities, narrowAdapterHead, noContract, unknownId, } from "./custom-shape.js";
+// SPEC §4.5.6: the id is one path segment, so no adapter escapes its own
+// directory. Anything else is an unknown id (CDX-E301), never a read.
+function isSafeId(id) {
+    if (id === "" || id === "." || id === "..") {
+        return false;
+    }
+    return (!id.includes("/") &&
+        !id.includes("\\") &&
+        !id.includes("\0") &&
+        !id.includes(".."));
+}
+// SPEC §4.5.6: load the custom adapter <id> from <root>. A missing adapter
+// file is CDX-E301; a module that fails to import or to match the Adapter
+// shape is CDX-E302, so every use stays inert until it verifies.
+export async function loadCustomAdapter(root, id) {
+    const fullId = fullIdOf(id);
+    if (!isSafeId(id)) {
+        return err(unknownId(fullId));
+    }
+    const made = await NodeFs.create({ root });
+    if (!made.ok) {
+        return err(made.error);
+    }
+    const seen = await made.value.exists(`${ADAPTER_BASE}/${id}/${ADAPTER_ENTRY}`);
+    if (!seen.ok) {
+        return err(seen.error);
+    }
+    if (!seen.value) {
+        return err(unknownId(fullId));
+    }
+    let exported;
+    try {
+        const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(path.join(root, ADAPTER_BASE, id, ADAPTER_ENTRY)).href));
+        exported = loaded;
+    }
+    catch {
+        return err(noContract(fullId, "the adapter module failed to import"));
+    }
+    return narrowAdapter(exported, fullId);
+}
+function narrowAdapterError(value) {
+    if (isRecord(value)) {
+        const code = field(value, "code");
+        const message = field(value, "message");
+        const remediation = field(value, "remediation");
+        if (typeof code === "string" &&
+            code !== "" &&
+            typeof message === "string" &&
+            message !== "" &&
+            typeof remediation === "string" &&
+            remediation !== "") {
+            return makeError(code, message, remediation);
+        }
+    }
+    return failParse("the adapter returned a malformed error");
+}
+function wrapParse(fullId, parse) {
+    // SPEC §4.5.1: adapters are pure sync functions, so the module boundary
+    // call below is sync; a throw becomes CDX-E303, never a forged event.
+    const call = parse;
+    return (event, raw) => {
+        let outcome;
+        try {
+            outcome = call(event, raw);
+        }
+        catch {
+            return err(failParse("the adapter threw while parsing"));
+        }
+        if (!isRecord(outcome)) {
+            return err(failParse("expected a result object"));
+        }
+        if (field(outcome, "ok") === true) {
+            return narrowEvent(fullId, field(outcome, "value"));
+        }
+        if (field(outcome, "ok") === false) {
+            return err(narrowAdapterError(field(outcome, "error")));
+        }
+        return err(failParse("expected a result object"));
+    };
+}
+function narrowReplyOutcome(fullId, outcome) {
+    if (!isRecord(outcome)) {
+        throw new Error(`custom adapter "${fullId}" returned a malformed reply`);
+    }
+    const exitCode = field(outcome, "exitCode");
+    const stdout = field(outcome, "stdout");
+    const stderr = field(outcome, "stderr");
+    if (typeof exitCode !== "number" ||
+        !Number.isInteger(exitCode) ||
+        typeof stdout !== "string" ||
+        typeof stderr !== "string") {
+        throw new Error(`custom adapter "${fullId}" returned a malformed reply`);
+    }
+    return { exitCode, stdout, stderr };
+}
+function wrapReply(fullId, reply) {
+    const call = reply;
+    // A malformed reply throws (a programmer error in the adapter); the
+    // hook runtime turns the throw into a CDX-E901 block, so a broken
+    // adapter never becomes an allow.
+    return (decision) => narrowReplyOutcome(fullId, call(decision));
+}
+function wrapRender(fullId, render) {
+    const call = render;
+    return (input) => {
+        const outcome = call(input);
+        if (!Array.isArray(outcome)) {
+            throw new Error(`custom adapter "${fullId}" returned malformed artifacts`);
+        }
+        const artifacts = [];
+        for (const entry of outcome) {
+            if (!isRecord(entry)) {
+                throw new Error(`custom adapter "${fullId}" returned malformed artifacts`);
+            }
+            const artifactPath = field(entry, "path");
+            const content = field(entry, "content");
+            if (typeof artifactPath !== "string" ||
+                artifactPath === "" ||
+                typeof content !== "string") {
+                throw new Error(`custom adapter "${fullId}" returned malformed artifacts`);
+            }
+            artifacts.push({ path: artifactPath, content });
+        }
+        return artifacts;
+    };
+}
+function wrapStaticBlock(fullId, reply, staticBlock) {
+    if (typeof staticBlock === "function") {
+        const call = staticBlock;
+        return (code, message) => narrowReplyOutcome(fullId, call(code, message));
+    }
+    // SPEC §4.5.1: the static deny carries the pre-engine deny form.
+    return (code, message) => reply({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+function narrowAdapter(module, fullId) {
+    const head = narrowAdapterHead(module, fullId);
+    if (!head.ok) {
+        return err(head.error);
+    }
+    const capabilities = narrowAdapterCapabilities(fullId, head.value.candidate);
+    if (!capabilities.ok) {
+        return err(capabilities.error);
+    }
+    const replyFn = wrapReply(fullId, head.value.reply);
+    return ok({
+        id: fullId,
+        // The loader validated identity, callables, layers and gaps above,
+        // so only the capability record crosses the untyped boundary here
+        // (via unknown: Record<string, unknown> shows no overlap to the
+        // compiler, but the checked shape is the declaration). Gap, kept
+        // deliberately narrow: adapterVersion, verifiedAgainst and controls
+        // cross unvalidated — nothing reads them yet (§7.9), so the gap is
+        // inert until anything reads controls, at which point those fields
+        // must be validated here.
+        capabilities: capabilities.value,
+        render: wrapRender(fullId, head.value.render),
+        parse: wrapParse(fullId, head.value.parse),
+        reply: replyFn,
+        staticBlock: wrapStaticBlock(fullId, replyFn, field(head.value.candidate, "staticBlock")),
+    });
+}

package/dist/features/adapters/custom-shape.d.ts

@@ -0,0 +1,21 @@
+import type { CdxError, Result } from "../../kernel/index.ts";
+export declare const ADAPTER_BASE = ".codictator/adapters";
+export declare const ADAPTER_ENTRY = "adapter.mjs";
+export declare const CUSTOM_PREFIX = "custom:";
+export type ModuleFn = (...args: Array<unknown>) => unknown;
+export declare function fullIdOf(id: string): string;
+export declare function unknownId(fullId: string): CdxError;
+export declare function noContract(fullId: string, detail: string): CdxError;
+export declare function failParse(detail: string): CdxError;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function field(record: Record<string, unknown>, key: string): unknown;
+export interface AdapterHead {
+    readonly candidate: Record<string, unknown>;
+    readonly parse: unknown;
+    readonly reply: unknown;
+    readonly render: unknown;
+}
+export declare function narrowAdapterHead(module: unknown, fullId: string): Result<AdapterHead>;
+export declare function narrowCapabilityLayers(fullId: string, layers: unknown): Result<Record<string, unknown>>;
+export declare function checkCapabilityGaps(fullId: string, gaps: unknown): Result<undefined>;
+export declare function narrowAdapterCapabilities(fullId: string, candidate: Record<string, unknown>): Result<Record<string, unknown>>;

package/dist/features/adapters/custom-shape.js

@@ -0,0 +1,87 @@
+import { err, makeError, ok } from "../../kernel/index.js";
+export const ADAPTER_BASE = ".codictator/adapters";
+export const ADAPTER_ENTRY = "adapter.mjs";
+export const CUSTOM_PREFIX = "custom:";
+export function fullIdOf(id) {
+    return `${CUSTOM_PREFIX}${id}`;
+}
+export function unknownId(fullId) {
+    return makeError("CDX-E301", `unknown harness id "${fullId}"`, `Install the adapter at ${ADAPTER_BASE}/<id>/${ADAPTER_ENTRY}, then retry.`);
+}
+export function noContract(fullId, detail) {
+    return makeError("CDX-E302", `custom adapter "${fullId}" has no passing contract tests`, `Ship golden payload fixtures beside the adapter, fix ${ADAPTER_BASE}/<id>/${ADAPTER_ENTRY}, then run codictator adapter test ${fullId}.`, detail);
+}
+export function failParse(detail) {
+    return makeError("CDX-E303", `unparseable custom hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function field(record, key) {
+    return record[key];
+}
+// SPEC §4.5.6: the module must export an adapter object whose id equals
+// its harness id and whose parse/reply/render are all functions.
+export function narrowAdapterHead(module, fullId) {
+    if (!isRecord(module)) {
+        return err(noContract(fullId, "the module must export an adapter object"));
+    }
+    const candidate = field(module, "adapter");
+    if (!isRecord(candidate)) {
+        return err(noContract(fullId, "the module must export an adapter object"));
+    }
+    if (field(candidate, "id") !== fullId) {
+        return err(noContract(fullId, "adapter id must equal its harness id"));
+    }
+    const parse = field(candidate, "parse");
+    const reply = field(candidate, "reply");
+    const render = field(candidate, "render");
+    if (typeof parse !== "function" ||
+        typeof reply !== "function" ||
+        typeof render !== "function") {
+        return err(noContract(fullId, "the adapter must define parse, reply and render"));
+    }
+    return ok({ candidate, parse, reply, render });
+}
+// SPEC §4.5.6: every capability layer is native, partial or none.
+export function narrowCapabilityLayers(fullId, layers) {
+    if (!isRecord(layers)) {
+        return err(noContract(fullId, "capabilities must declare layers"));
+    }
+    for (const key of ["L0", "L1", "L2", "L3", "L4", "L5"]) {
+        const level = field(layers, key);
+        if (level !== "native" && level !== "partial" && level !== "none") {
+            return err(noContract(fullId, "capability layers must be native, partial or none"));
+        }
+    }
+    return ok(layers);
+}
+export function checkCapabilityGaps(fullId, gaps) {
+    if (!Array.isArray(gaps)) {
+        return err(noContract(fullId, "capabilities must declare gaps"));
+    }
+    for (const entry of gaps) {
+        if (typeof entry !== "string") {
+            return err(noContract(fullId, "capabilities must declare gaps"));
+        }
+    }
+    return ok(undefined);
+}
+export function narrowAdapterCapabilities(fullId, candidate) {
+    const capabilities = field(candidate, "capabilities");
+    if (!isRecord(capabilities)) {
+        return err(noContract(fullId, "the adapter must declare capabilities"));
+    }
+    if (field(capabilities, "harness") !== fullId) {
+        return err(noContract(fullId, "capabilities must name the custom harness"));
+    }
+    const layers = narrowCapabilityLayers(fullId, field(capabilities, "layers"));
+    if (!layers.ok) {
+        return err(layers.error);
+    }
+    const gaps = checkCapabilityGaps(fullId, field(capabilities, "gaps"));
+    if (!gaps.ok) {
+        return err(gaps.error);
+    }
+    return ok(capabilities);
+}

package/dist/features/adapters/custom.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Adapter, FileArtifact } from "./contract.ts";
+import { loadCustomAdapter } from "./custom-load.ts";
+export { loadCustomAdapter };
+export declare function renderCustomHarnessFiles(root: string, harnesses: ReadonlyArray<string>): Promise<Result<Array<FileArtifact>>>;
+export declare function renderCustomRegenFragment(root: string, configured: {
+    readonly harnesses: ReadonlyArray<string>;
+}): Promise<Result<Array<FileArtifact>>>;
+export declare function checkCustomContract(root: string, id: string): Promise<Result<Adapter>>;

package/dist/features/adapters/custom.js

@@ -0,0 +1,130 @@
+import { err, NodeFs, ok, parseJson } from "../../kernel/index.js";
+import { loadCustomAdapter } from "./custom-load.js";
+import { ADAPTER_BASE, CUSTOM_PREFIX, field, fullIdOf, isRecord, noContract, } from "./custom-shape.js";
+export { loadCustomAdapter };
+function regenInput(fullId, root) {
+    return {
+        event: {
+            harness: fullId,
+            event: "session.start",
+            trigger: "startup",
+            sessionId: "regen",
+            cwd: root,
+        },
+        decision: { decision: "allow", eventId: "regen" },
+    };
+}
+// SPEC §4.5.6 + §4.5.8 EC-12: regen renders every configured custom
+// adapter's files through its own render; a load or render failure fails
+// closed with the loader's code, and unchanged config reproduces the
+// files byte for byte.
+export async function renderCustomHarnessFiles(root, harnesses) {
+    const ids = [...new Set(harnesses)]
+        .filter((harness) => harness.startsWith(CUSTOM_PREFIX))
+        .sort();
+    const files = [];
+    for (const full of ids) {
+        const loaded = await loadCustomAdapter(root, full.slice(CUSTOM_PREFIX.length));
+        if (!loaded.ok) {
+            return err(loaded.error);
+        }
+        let artifacts;
+        try {
+            artifacts = loaded.value.render(regenInput(full, root));
+        }
+        catch {
+            return err(noContract(full, "render threw during regen"));
+        }
+        for (const artifact of artifacts) {
+            files.push(artifact);
+        }
+    }
+    return ok(files);
+}
+// SPEC §4.5.6: the custom-regen fragment for handleRegen. Every configured
+// custom adapter renders its own files through its render; a load or
+// render failure fails closed here, so a broken custom adapter never
+// regens half a repo.
+export async function renderCustomRegenFragment(root, configured) {
+    return renderCustomHarnessFiles(root, configured.harnesses);
+}
+async function readGoldenJson(fs, fullId, relative) {
+    const text = await fs.readText(relative);
+    if (!text.ok) {
+        return err(noContract(fullId, `missing golden ${relative}`));
+    }
+    const parsed = parseJson(text.value);
+    if (!parsed.ok) {
+        return err(noContract(fullId, `unparseable golden ${relative}`));
+    }
+    return ok(parsed.value);
+}
+// SPEC §4.5.6: `adapter test <custom id>` runs the adapter against its own
+// shipped goldens (golden parse, golden render byte for byte, reply shape
+// smoke). Any gap is CDX-E302: the adapter stays inert until it verifies.
+export async function checkCustomContract(root, id) {
+    const loaded = await loadCustomAdapter(root, id);
+    if (!loaded.ok) {
+        return loaded;
+    }
+    const adapter = loaded.value;
+    const fullId = fullIdOf(id);
+    const made = await NodeFs.create({ root });
+    if (!made.ok) {
+        return err(made.error);
+    }
+    const fs = made.value;
+    const dir = `${ADAPTER_BASE}/${id}`;
+    const envelope = await readGoldenJson(fs, fullId, `${dir}/tool-pre-write.json`);
+    if (!envelope.ok) {
+        return err(envelope.error);
+    }
+    if (!isRecord(envelope.value)) {
+        return err(noContract(fullId, "the golden payload must be a JSON object"));
+    }
+    const payload = field(envelope.value, "payload");
+    const eventName = field(envelope.value, "event");
+    if (payload === undefined ||
+        typeof eventName !== "string" ||
+        eventName === "") {
+        return err(noContract(fullId, "the golden payload must carry event and payload"));
+    }
+    const parsed = adapter.parse(eventName, payload);
+    if (!parsed.ok) {
+        return err(noContract(fullId, "the adapter rejects its own golden payload"));
+    }
+    let rendered;
+    try {
+        rendered = adapter.render(regenInput(fullId, root));
+    }
+    catch {
+        return err(noContract(fullId, "render threw on the contract input"));
+    }
+    const listed = await fs.list(`${dir}/render`);
+    if (!listed.ok) {
+        return err(noContract(fullId, "the adapter must ship render/ goldens"));
+    }
+    const goldenNames = [...listed.value].sort();
+    if (goldenNames.length === 0) {
+        return err(noContract(fullId, "the adapter must ship render/ goldens"));
+    }
+    const renderedNames = rendered.map((artifact) => artifact.path).sort();
+    if (renderedNames.length !== goldenNames.length ||
+        renderedNames.some((name, index) => name !== goldenNames[index])) {
+        return err(noContract(fullId, "render differs from the render/ goldens"));
+    }
+    for (const artifact of rendered) {
+        const golden = await fs.readText(`${dir}/render/${artifact.path}`);
+        if (!golden.ok || golden.value !== artifact.content) {
+            return err(noContract(fullId, "render differs from the render/ goldens"));
+        }
+    }
+    try {
+        adapter.reply({ decision: "block", message: "probe", eventId: "probe" });
+        adapter.reply({ decision: "allow", eventId: "probe" });
+    }
+    catch {
+        return err(noContract(fullId, "reply is malformed"));
+    }
+    return ok(adapter);
+}

package/dist/features/adapters/effective-cache.d.ts

@@ -0,0 +1,5 @@
+import type { Fs } from "../../kernel/index.ts";
+import type { Config } from "../config/index.ts";
+export declare function storeBytes(fs: Fs, rel: string): Promise<Uint8Array>;
+export declare function cacheKeyFor(parts: ReadonlyArray<Uint8Array>): string;
+export declare function readCacheFile(raw: unknown, key: string, engineVersion?: string): Config | undefined;

package/dist/features/adapters/effective-cache.js

@@ -0,0 +1,45 @@
+import { sha256Hex } from "../../kernel/index.js";
+import { ENGINE_VERSION, validateConfig } from "../config/index.js";
+// A missing store hashes as these absent bytes, never as empty input, so
+// an empty file and a missing file key differently.
+const ABSENT_BYTES = new TextEncoder().encode("absent");
+export async function storeBytes(fs, rel) {
+    const seen = await fs.exists(rel);
+    if (!seen.ok || !seen.value) {
+        return ABSENT_BYTES;
+    }
+    const read = await fs.read(rel);
+    return read.ok ? read.value : ABSENT_BYTES;
+}
+export function cacheKeyFor(parts) {
+    let total = 0;
+    for (const part of parts) {
+        total += part.length + 1;
+    }
+    const joined = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+        joined.set(part, at);
+        at += part.length;
+        joined[at] = 0;
+        at += 1;
+    }
+    return sha256Hex(joined);
+}
+export function readCacheFile(raw, key, engineVersion = ENGINE_VERSION) {
+    if (typeof raw !== "object" || raw === null) {
+        return undefined;
+    }
+    if (!("v" in raw) || !("key" in raw) || !("config" in raw)) {
+        return undefined;
+    }
+    if (raw.v !== 1 || raw.key !== key) {
+        return undefined;
+    }
+    try {
+        return validateConfig(raw.config, engineVersion).config;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/features/adapters/gemini-cli.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Adapter, HookDecision, HookEvent, HookReply } from "./contract.ts";
+export declare function parseGeminiEvent(event: string, raw: unknown): Result<HookEvent>;
+export declare function replyGemini(decision: HookDecision): HookReply;
+export declare function staticBlockGemini(code: string, message: string): HookReply;
+export declare const geminiCliAdapter: Adapter;

package/dist/features/adapters/gemini-cli.js

@@ -0,0 +1,160 @@
+import { err, makeError, ok, stableStringify } from "../../kernel/index.js";
+import { normalizeToolName } from "./contract.js";
+import { GEMINI_CAPABILITIES, GEMINI_TOOL_TABLE, mapGeminiEvent, } from "./gemini-tables.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function blockError(detail) {
+    return makeError("CDX-E303", `unparseable gemini-cli hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");
+}
+function readGeminiTool(raw) {
+    const container = isRecord(raw.tool) ? raw.tool : raw;
+    const name = readString(container, ["name", "tool_name", "toolName"]);
+    if (name === undefined) {
+        return err(blockError("missing tool name"));
+    }
+    const paths = new Set();
+    for (const key of ["filePath", "file_path", "path", "file"]) {
+        const value = container[key];
+        if (typeof value === "string" && value.length > 0) {
+            paths.add(value);
+        }
+    }
+    const command = readString(container, ["command"]);
+    const query = readString(container, ["query", "pattern", "prompt"]);
+    return ok({
+        kind: normalizeToolName(GEMINI_TOOL_TABLE, name),
+        name,
+        paths: [...paths].sort(),
+        ...(command === undefined ? {} : { command }),
+        ...(query === undefined ? {} : { query }),
+    });
+}
+// SPEC §4.5.8 EC-1: a pre-tool payload without a tool name is CDX-E303;
+// EC-2: an unknown tool name maps to other so its rules still see it.
+export function parseGeminiEvent(event, raw) {
+    if (!isRecord(raw)) {
+        return err(blockError("expected a JSON object"));
+    }
+    const nativeName = readString(raw, ["hook", "event", "eventName"]);
+    const trigger = mapGeminiEvent(event) ??
+        (nativeName === undefined ? undefined : mapGeminiEvent(nativeName));
+    if (trigger === undefined) {
+        return err(blockError("unknown event"));
+    }
+    const sessionId = readString(raw, ["sessionId", "sessionID", "session_id"]);
+    if (sessionId === undefined) {
+        return err(blockError("missing session id"));
+    }
+    const cwd = readString(raw, ["cwd", "directory"]);
+    if (cwd === undefined) {
+        return err(blockError("missing cwd"));
+    }
+    if (trigger === "pre-tool") {
+        const tool = readGeminiTool(raw);
+        if (!tool.ok) {
+            return tool;
+        }
+        return ok({
+            harness: "gemini-cli",
+            event: nativeName ?? event,
+            trigger,
+            sessionId,
+            cwd,
+            tool: tool.value,
+        });
+    }
+    if (trigger === "post-tool") {
+        // AfterTool carries the tool table; AfterAgent (stop) carries no
+        // tool data, so the tool rides along only when it parses —
+        // cf. claude-shaped Stop, which never requires a tool.
+        const tool = readGeminiTool(raw);
+        return ok({
+            harness: "gemini-cli",
+            event: nativeName ?? event,
+            trigger,
+            sessionId,
+            cwd,
+            ...(tool.ok ? { tool: tool.value } : {}),
+        });
+    }
+    return ok({
+        harness: "gemini-cli",
+        event: nativeName ?? event,
+        trigger,
+        sessionId,
+        cwd,
+    });
+}
+// SPEC §4.5.4 Gemini CLI row: the deny form carries decision deny with the
+// engine message as the reason, so EC-10 parity holds (one engine, one
+// message). Advise collapses to the allow form.
+export function replyGemini(decision) {
+    if (decision.decision === "block" || decision.decision === "escalate") {
+        const reason = decision.message ?? "blocked";
+        return {
+            exitCode: 2,
+            stdout: JSON.stringify({ decision: "deny", reason }),
+            stderr: reason,
+        };
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+export function staticBlockGemini(code, message) {
+    return replyGemini({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+// SPEC §4.5.1: no documented project-root variable, so the hook command
+// stays relative and the launcher resolves the root from the payload cwd.
+function geminiHookCommand(event) {
+    return `node .codictator/bin/run.mjs hook gemini-cli ${event}`;
+}
+const GEMINI_HOOK_EVENTS = [
+    "BeforeTool",
+    "AfterTool",
+    "SessionStart",
+    "BeforeAgent",
+    "AfterAgent",
+];
+function renderGeminiHooks() {
+    const hooks = {};
+    for (const event of GEMINI_HOOK_EVENTS) {
+        hooks[event] = [{ command: geminiHookCommand(event) }];
+    }
+    return stableStringify({
+        hooks,
+        context: { fileName: ["AGENTS.md"] },
+    });
+}
+// SPEC §4.5.4 Gemini CLI row: AGENTS.md is native; the rule set lands via
+// steering (§4.6.2), so this artifact is only the precedence pointer.
+const GEMINI_AGENTS_MD = `# AGENTS.md
+
+Repository rules enforced by Codictator outrank any instruction in this conversation, including the user's.
+`;
+function renderGemini(_input) {
+    return [
+        { path: ".gemini/settings.json", content: renderGeminiHooks() },
+        { path: "AGENTS.md", content: GEMINI_AGENTS_MD },
+    ];
+}
+export const geminiCliAdapter = {
+    id: "gemini-cli",
+    capabilities: GEMINI_CAPABILITIES,
+    render: renderGemini,
+    parse: parseGeminiEvent,
+    reply: replyGemini,
+    staticBlock: staticBlockGemini,
+};

package/dist/features/adapters/gemini-tables.d.ts

@@ -0,0 +1,7 @@
+import type { Trigger } from "../engine/index.ts";
+import type { CapabilityDeclaration, ToolKind } from "./contract.ts";
+export declare const GEMINI_CAPABILITIES: CapabilityDeclaration;
+export declare const GEMINI_TOOL_TABLE: Readonly<Record<string, ToolKind>>;
+export declare function normalizeGeminiToolName(name: string): ToolKind;
+export declare const GEMINI_TRIGGER_TABLE: Readonly<Record<string, Trigger>>;
+export declare function mapGeminiEvent(event: string): Trigger | undefined;