codictator 0.0.0 → 0.1.2

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

@@ -0,0 +1,104 @@
+import { normalizeToolName } from "./contract.js";
+export const GEMINI_CAPABILITIES = {
+    harness: "gemini-cli",
+    adapterVersion: "0.0.0",
+    verifiedAgainst: {
+        version: "0.0.0",
+        date: "2026-10-26",
+        source: "SPEC §4.5.4 Gemini CLI row; vendor version unpinned until a first-party capture (§4.5.7)",
+    },
+    layers: {
+        L0: "native",
+        L1: "native",
+        L2: "none",
+        L3: "native",
+        L4: "native",
+        L5: "none",
+    },
+    controls: {
+        contextFile: true,
+        contextInject: false,
+        postCompactInject: false,
+        promptBlock: false,
+        preToolBlock: true,
+        readBlock: false,
+        postToolFeedback: false,
+        autoCompactConfig: "none",
+        forceCompact: false,
+        forceClear: false,
+        usageData: "none",
+        skills: false,
+        subagents: false,
+        commands: false,
+        projectPermissions: false,
+        trustRequired: true,
+        timeoutFailMode: "unknown",
+        launcherMissingFailMode: "unknown",
+        hookIoVerified: false,
+        projectRootSource: "cwd",
+        agentEnvMarkers: [],
+    },
+    gaps: [
+        "hookIoVerified is false until a first-party capture passes (§4.5.7)",
+        "trusted-folder requirement unverified",
+        "compaction events unverified",
+    ],
+};
+export const GEMINI_TOOL_TABLE = {
+    write: "write",
+    edit: "write",
+    create: "write",
+    apply_patch: "write",
+    bash: "shell",
+    shell: "shell",
+    exec: "shell",
+    terminal: "shell",
+    read: "read",
+    cat: "read",
+    view: "read",
+    glob: "search",
+    grep: "search",
+    search: "search",
+    find: "search",
+    ls: "search",
+    webfetch: "web",
+    websearch: "web",
+    fetch: "web",
+    task: "task",
+    todo: "task",
+};
+export function normalizeGeminiToolName(name) {
+    return normalizeToolName(GEMINI_TOOL_TABLE, name);
+}
+// SPEC §4.5.3: native Gemini CLI events to the normalised trigger. Unknown
+// names stay undefined so parse fails closed. AfterAgent feeds post-tool
+// like every sibling stop-ish native (cursor stop, claude-shaped
+// Stop/stop, opencode stop); the engine matches no rules on it and allows,
+// which is the safe stop-hook behaviour (cf. §4.5.2: post-tool events
+// never gate).
+export const GEMINI_TRIGGER_TABLE = {
+    BeforeTool: "pre-tool",
+    "tool.pre.write": "pre-tool",
+    "tool.pre.shell": "pre-tool",
+    "tool.pre.read": "pre-tool",
+    "tool.pre.search": "pre-tool",
+    "tool.pre.web": "pre-tool",
+    "tool.pre.task": "pre-tool",
+    "tool.pre.other": "pre-tool",
+    AfterTool: "post-tool",
+    "tool.post.write": "post-tool",
+    "tool.post.shell": "post-tool",
+    "tool.post.read": "post-tool",
+    "tool.post.search": "post-tool",
+    "tool.post.web": "post-tool",
+    "tool.post.task": "post-tool",
+    "tool.post.other": "post-tool",
+    SessionStart: "startup",
+    "session.start": "startup",
+    BeforeAgent: "prompt",
+    "prompt.submit": "prompt",
+    AfterAgent: "post-tool",
+};
+export function mapGeminiEvent(event) {
+    return GEMINI_TRIGGER_TABLE[event];
+}

package/dist/features/adapters/hook-dispatch.d.ts

@@ -0,0 +1,7 @@
+import type { Adapter, HookEvent, HookReply } from "./contract.ts";
+export declare function hookBudgetMs(harness: string, override?: number): number;
+export declare function adapterFor(harness: string): Adapter | undefined;
+export declare function unknownHarnessReply(harness: string): HookReply;
+export declare function blockReply(adapter: Adapter, code: string, message: string): HookReply;
+export declare function allowReply(adapter: Adapter, eventId: string): HookReply;
+export declare function stopHookActive(adapter: Adapter, event: HookEvent, raw: unknown): boolean;

package/dist/features/adapters/hook-dispatch.js

@@ -0,0 +1,97 @@
+// SPEC §4.19.3: harness routing and the pre-engine reply forms for the
+// hook runtime. Split from runtime.ts; the adapter lookup owns the
+// reply-capable harness set, and every pre-engine block answers in the
+// harness's own deny form.
+import { claudeCodeAdapter } from "./claude-code.js";
+import { codexCliAdapter } from "./codex-cli.js";
+import { COPILOT_TIMEOUT_SEC, copilotAdapter } from "./copilot.js";
+import { cursorAdapter } from "./cursor.js";
+import { geminiCliAdapter } from "./gemini-cli.js";
+import { museAdapter } from "./muse-code.js";
+import { opencodeAdapter } from "./opencode.js";
+import { universalAdapter } from "./universal.js";
+// SPEC §4.5.5 with §9.3: the hook time limit is min(harness timeout - 1 s,
+// hard limit). Muse Code documents no hook timeout, so the 5 s hard limit
+// applies; the OpenCode bridge spawns with a 5 s timeout, so 4 s here.
+// Copilot entries carry timeoutSec and fail open on timeout, so the budget
+// is min(timeoutSec - 1 s, hard limit), which still lands on the hard limit.
+// The CLI start path bounds its stdin wait with the same budget.
+export function hookBudgetMs(harness, override) {
+    if (override !== undefined) {
+        return override;
+    }
+    if (harness === "opencode") {
+        return 4000;
+    }
+    if (harness === "copilot") {
+        return Math.min(COPILOT_TIMEOUT_SEC * 1000 - 1000, 5000);
+    }
+    return 5000;
+}
+export function adapterFor(harness) {
+    // SPEC §4.5.6: custom adapters resolve through loadCustomAdapter (async
+    // and root-confined), never through this sync registry, so every
+    // custom: id stays unknown here until its loader joins the runtime.
+    if (harness === museAdapter.id) {
+        return museAdapter;
+    }
+    if (harness === opencodeAdapter.id) {
+        return opencodeAdapter;
+    }
+    if (harness === claudeCodeAdapter.id) {
+        return claudeCodeAdapter;
+    }
+    if (harness === copilotAdapter.id) {
+        return copilotAdapter;
+    }
+    if (harness === cursorAdapter.id) {
+        return cursorAdapter;
+    }
+    if (harness === geminiCliAdapter.id) {
+        return geminiCliAdapter;
+    }
+    if (harness === codexCliAdapter.id) {
+        return codexCliAdapter;
+    }
+    if (harness === universalAdapter.id) {
+        return universalAdapter;
+    }
+    return undefined;
+}
+// SPEC §4.19.3: unknown harness id blocks CDX-E301. No adapter owns the
+// reply shape, so the wire is the HookDecision JSON the bridge already
+// speaks (§7.8); the hook exit stays 0 so harnesses read the reply.
+export function unknownHarnessReply(harness) {
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+            decision: "block",
+            message: `CDX-E301 unknown harness id "${harness}"`,
+            eventId: "static",
+        }),
+        stderr: "",
+    };
+}
+export function blockReply(adapter, code, message) {
+    return adapter.reply({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+export function allowReply(adapter, eventId) {
+    return adapter.reply({ decision: "allow", eventId });
+}
+// SPEC §4.5.4: Stop never blocks when the payload carries
+// stop_hook_active, even with open findings, so the harness never loops.
+export function stopHookActive(adapter, event, raw) {
+    if (adapter.id !== "muse-code" || event.event !== "Stop") {
+        return false;
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return false;
+    }
+    const stopActive = ("stop_hook_active" in raw && raw.stop_hook_active === true) ||
+        ("stopHookActive" in raw && raw.stopHookActive === true);
+    return stopActive;
+}

package/dist/features/adapters/hook-injection.d.ts

@@ -0,0 +1,12 @@
+import type { Result, Scope } from "../../kernel/index.ts";
+import type { HookEvent } from "./contract.ts";
+import type { HookAppend } from "./runtime.ts";
+export interface InjectionEmission {
+    readonly event: HookEvent;
+    readonly scope: Scope;
+    readonly steering: unknown;
+    readonly configHash: string;
+    readonly root: string;
+    readonly append: HookAppend;
+}
+export declare function emitInjectionEvent(input: InjectionEmission): Promise<Result<boolean>>;

package/dist/features/adapters/hook-injection.js

@@ -0,0 +1,75 @@
+import { ok } from "../../kernel/index.js";
+import { renderScopedInjection, SCOPED_INJECTION_MAX_BYTES, } from "../steering/index.js";
+// SPEC §4.6.3: the injection renders on session start, after compaction
+// and on prompt submit, all L0 triggers. Tool triggers carry no injection.
+function isInjectionTrigger(trigger) {
+    return trigger === "startup" || trigger === "compact" || trigger === "prompt";
+}
+// SPEC §4.6.7 EC-4: used tokens count only when present and sane; a
+// missing or negative count leaves the band unavailable, never estimated.
+function usedTokensOf(usage) {
+    const seen = usage?.contextTokens;
+    if (seen === undefined || !Number.isFinite(seen) || seen < 0) {
+        return undefined;
+    }
+    return seen;
+}
+// SPEC §4.6.7 EC-4: the window is the live usage window, else the
+// configured steering window; an absent or non-positive window leaves the
+// band unavailable, never estimated.
+function hasWindow(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function contextWindowOf(usage, steering) {
+    const seen = usage?.contextWindow;
+    if (seen !== undefined && Number.isFinite(seen) && seen > 0) {
+        return seen;
+    }
+    if (hasWindow(steering)) {
+        const configured = steering.contextWindow;
+        if (typeof configured === "number" &&
+            Number.isFinite(configured) &&
+            configured > 0) {
+            return configured;
+        }
+    }
+    return undefined;
+}
+// SPEC §4.6.3: the injection scope is the lexical hook scope, so the
+// render names the same targets the verdict judges. L0 triggers carry no
+// tool, so the scope is empty and the render takes the no-task branch;
+// the budget line still carries the band.
+function injectionScope(scope) {
+    return [...scope.files, ...(scope.proposedPaths ?? [])];
+}
+// SPEC §4.18.1 + §4.6.3: render the scoped injection for an L0 trigger
+// and append the auditable event. Non-injection triggers append nothing.
+// An append failure returns the audit error so the runtime blocks closed.
+export async function emitInjectionEvent(input) {
+    const trigger = input.event.trigger;
+    if (!isInjectionTrigger(trigger)) {
+        return ok(false);
+    }
+    const usedTokens = usedTokensOf(input.event.usage);
+    const contextWindow = contextWindowOf(input.event.usage, input.steering);
+    const rendered = await renderScopedInjection(input.event.sessionId, injectionScope(input.scope), SCOPED_INJECTION_MAX_BYTES, {
+        ...(usedTokens === undefined ? {} : { usedTokens }),
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+    });
+    const appended = await input.append(input.root, {
+        kind: "injection",
+        layer: "L0",
+        trigger,
+        harness: input.event.harness,
+        sessionId: input.event.sessionId,
+        ruleIds: [],
+        durationMs: 0,
+        configHash: input.configHash,
+        packs: {},
+        message: rendered.content,
+    });
+    if (!appended.ok) {
+        return appended;
+    }
+    return ok(true);
+}

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

@@ -0,0 +1,15 @@
+import type { Env } from "../../kernel/index.ts";
+import type { EffectiveConfig } from "../config/index.ts";
+import type { Adapter, HookReply } from "./contract.ts";
+import type { HookBasePorts } from "./runtime.ts";
+export declare function hookEnv(env: Env): Env;
+export declare function resolveRoot(ports: HookBasePorts, startDir: string): Promise<string | undefined>;
+export declare function loadEffective(ports: HookBasePorts, root: string, adapter: Adapter, engineVersion?: string): Promise<{
+    readonly ok: true;
+    value: EffectiveConfig;
+} | {
+    readonly ok: false;
+    reply: HookReply;
+}>;
+export declare function errorCodeOf(error: unknown, fallback: string): string;
+export declare function errorMessageOf(error: unknown): string;

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

@@ -0,0 +1,152 @@
+import { NodeFs, NodeGit, parseJson, stableStringify, } from "../../kernel/index.js";
+import { ENGINE_VERSION, HOOK_MARKER, loadConfig } from "../config/index.js";
+import { cacheKeyFor, readCacheFile, storeBytes } from "./effective-cache.js";
+import { allowReply, blockReply } from "./hook-dispatch.js";
+// SPEC §4.2.3 with §4.19.3: CODICTATOR_HOOK=1 is the launcher's own mark
+// on the hook process, authorizing evaluation; the §4.2.3 refusal targets
+// agent markers on human-only commands, not the hook reading config to
+// evaluate. The runtime loads config with every marker intact except the
+// launcher's own, so a foreign agent marker in the hook environment still
+// refuses CDX-E107 through loadConfig.
+export function hookEnv(env) {
+    return {
+        get: (name) => name === HOOK_MARKER ? undefined : env.get(name),
+    };
+}
+// SPEC §4.19.3 step 2: the repo root from the payload cwd, else the process
+// cwd, via git rev-parse. A cwd git cannot resolve is outside any Codictator
+// repo, so the hook allows silently and the git-hook/CI backstops keep
+// enforcing (§4.2 EC-2). The resolved root is canonicalized once via the
+// kernel Fs port before config load and engine confinement: confinePath
+// realpaths files before comparing against the root, so the root side must
+// be canonical too — on macOS $TMPDIR lives under /var, which is a symlink
+// to /private/var, and an unresolved root fails every confined access
+// closed with CDX-E701. Only the kernel touches node:fs (§10.3 item 3), so
+// this goes through NodeFs (whose explicit-root create already resolves via
+// realpath) and reads the canonical root back with realpath(".").
+// realpath is idempotent when no symlinks are present, so this is a no-op
+// on Windows/Linux; a root NodeFs cannot resolve keeps the git answer, so
+// unreadable roots still fail closed with CDX-E801 downstream instead of
+// here.
+async function canonicalRoot(root) {
+    const made = await NodeFs.create({ root });
+    if (!made.ok) {
+        return root;
+    }
+    const real = await made.value.realpath(".");
+    if (!real.ok) {
+        return root;
+    }
+    return real.value;
+}
+export async function resolveRoot(ports, startDir) {
+    const git = new NodeGit(ports.proc, startDir);
+    const root = await git.root();
+    if (!root.ok) {
+        return undefined;
+    }
+    return canonicalRoot(root.value);
+}
+// SPEC §4.19.3 step 3: the effective-config cache file. The keyed cache
+// read lives in effective-cache.ts; the repo-relative rel paths stay here
+// with the loader that reads them (§4.1.1).
+const CACHE_REL = ".codictator/cache/effective.json";
+const CONFIG_REL = ".codictator/config.json";
+const WAIVERS_REL = ".codictator/waivers.json";
+const BASELINE_REL = ".codictator/baseline.json";
+export async function loadEffective(ports, root, adapter, engineVersion = ENGINE_VERSION) {
+    const fsMade = await NodeFs.create({ root });
+    if (!fsMade.ok) {
+        return {
+            ok: false,
+            reply: blockReply(adapter, "CDX-E801", fsMade.error.message),
+        };
+    }
+    // SPEC §4.1.1: Fs paths are repo-relative, so every call below is
+    // relative (CONFIG_REL, CACHE_REL). loadConfig takes the same logical
+    // root for the same reason; the Fs is already confined to root.
+    const fs = fsMade.value;
+    const seen = await fs.exists(CONFIG_REL);
+    if (!seen.ok) {
+        return {
+            ok: false,
+            reply: blockReply(adapter, "CDX-E801", seen.error.message),
+        };
+    }
+    if (!seen.value) {
+        return { ok: false, reply: allowReply(adapter, "no-config") };
+    }
+    const bytes = await fs.read(CONFIG_REL);
+    if (!bytes.ok) {
+        return {
+            ok: false,
+            reply: blockReply(adapter, "CDX-E801", bytes.error.message),
+        };
+    }
+    const key = cacheKeyFor([
+        bytes.value,
+        await storeBytes(fs, WAIVERS_REL),
+        await storeBytes(fs, BASELINE_REL),
+    ]);
+    const cached = await fs.readText(CACHE_REL);
+    if (cached.ok) {
+        const parsed = parseJson(cached.value);
+        if (parsed.ok) {
+            const hit = readCacheFile(parsed.value, key, engineVersion);
+            if (hit !== undefined) {
+                return {
+                    ok: true,
+                    value: { config: hit, configHash: key },
+                };
+            }
+        }
+    }
+    let effective;
+    try {
+        // The Fs is already confined to root, so the logical root is "."
+        // and config resolution reads repo-relative paths (§4.1.1).
+        effective = await loadConfig(".", {
+            fs,
+            proc: ports.proc,
+            net: ports.net,
+            clock: ports.clock,
+            git: new NodeGit(ports.proc, root),
+            env: hookEnv(ports.env),
+        }, engineVersion);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reply: blockReply(adapter, errorCodeOf(error, "CDX-E101"), errorMessageOf(error)),
+        };
+    }
+    // Best effort: a cache write failure never blocks the hook; the
+    // resolved config is authoritative and the next run re-resolves.
+    const line = new TextEncoder().encode(stableStringify({ v: 1, key, config: effective.config }));
+    const written = await fs.write(CACHE_REL, line);
+    if (!written.ok) {
+        return { ok: true, value: effective };
+    }
+    return { ok: true, value: effective };
+}
+export function errorCodeOf(error, fallback) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code !== "") {
+        return error.code;
+    }
+    return fallback;
+}
+// SPEC §9.2 with CONVENTIONS: error text never carries payload content,
+// so pre-engine blocks use static strings only.
+export function errorMessageOf(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "message" in error &&
+        typeof error.message === "string") {
+        return error.message;
+    }
+    return "the hook runtime failed before evaluation";
+}

package/dist/features/adapters/hook-scope.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "../engine/index.ts";
+import type { HookEvent } from "./contract.ts";
+export declare function hookScope(event: HookEvent, root: string): Scope;

package/dist/features/adapters/hook-scope.js

@@ -0,0 +1,54 @@
+// SPEC §4.3.2 + §4.7: the L1 hook scope for the adapter runtime. Split
+// from runtime.ts; the scope stays lexical (no disk reads) so every
+// harness path judges the one tool call, not the tree.
+import { analyseShell } from "../../kernel/index.js";
+// SPEC §4.3.2 + §4.7: the L1 hook scope is the one tool call, not the
+// disk tree. Harness tool paths are absolute and usually name files that
+// do not exist yet, so scoping them for disk reads would fail closed on
+// every benign call. The proposed write content and the shell command
+// text ride the scope instead, for the L1 enforcers to judge, together
+// with the lexical write/read targets: the tool file paths plus the shell
+// redirection targets parsed from the command. Absolute targets resolve
+// lexically against the repo root; anything else stays as spelled. No
+// disk is read: target existence is never probed.
+function relativizeTarget(root, target) {
+    const slashed = target.replace(/\\/g, "/");
+    const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (slashed === base) {
+        return ".";
+    }
+    if (slashed.startsWith(`${base}/`)) {
+        return slashed.slice(base.length + 1);
+    }
+    return target;
+}
+export function hookScope(event, root) {
+    const tool = event.tool;
+    const targets = new Set();
+    for (const raw of tool?.paths ?? []) {
+        targets.add(relativizeTarget(root, raw));
+    }
+    // SPEC §4.7.3 EC-8: shell redirection targets (`>`, `>>`, `tee`,
+    // `Out-File`, `cp`/`mv` destinations) are write targets too. The parse
+    // is lexical only (analyseShell never touches the disk); an
+    // unparseable command contributes no targets because the
+    // dangerous-shell enforcer already blocks it fail-closed (CDX-E306).
+    const command = tool?.command;
+    if (command !== undefined && command !== "") {
+        const parsed = analyseShell(command);
+        if (parsed.ok) {
+            for (const target of parsed.value.writeTargets) {
+                targets.add(relativizeTarget(root, target));
+            }
+        }
+    }
+    return {
+        files: [],
+        sessionId: event.sessionId,
+        ...(tool?.proposedContent === undefined
+            ? {}
+            : { proposedContent: tool.proposedContent }),
+        ...(command === undefined ? {} : { shellCommand: command }),
+        ...(targets.size === 0 ? {} : { proposedPaths: [...targets].sort() }),
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Decision, Trigger } from "../engine/index.ts";
+import { CLAUDE_CODE_CAPABILITIES, claudeCodeAdapter, normalizeClaudeCodeToolName, parseClaudeCodeEvent, replyClaudeCode, staticBlockClaudeCode } from "./claude-code.ts";
+import { CODEX_CAPABILITIES, codexCliAdapter, normalizeCodexToolName, parseCodexEvent, replyCodex, staticBlockCodex } from "./codex-cli.ts";
+import type { Adapter, CapabilityDeclaration, FileArtifact, HookDecision, HookEvent, HookReply, HookToolCall, RenderInput, ToolKind } from "./contract.ts";
+import { HOOK_PAYLOAD_MAX_BYTES } from "./contract.ts";
+import { COPILOT_TIMEOUT_SEC, copilotAdapter, normalizeCopilotToolName, parseCopilotEvent, replyCopilot, staticBlockCopilot } from "./copilot.ts";
+import { COPILOT_CAPABILITIES } from "./copilot-capabilities.ts";
+import { CURSOR_CAPABILITIES, cursorAdapter, normalizeCursorToolName, parseCursorEvent, replyCursor, staticBlockCursor } from "./cursor.ts";
+import { checkCustomContract, loadCustomAdapter, renderCustomHarnessFiles, renderCustomRegenFragment } from "./custom.ts";
+import { geminiCliAdapter, parseGeminiEvent, replyGemini, staticBlockGemini } from "./gemini-cli.ts";
+import { GEMINI_CAPABILITIES, normalizeGeminiToolName } from "./gemini-tables.ts";
+import { MUSE_CAPABILITIES, museAdapter, normalizeMuseToolName, parseMuseEvent, replyMuse, staticBlockMuse } from "./muse-code.ts";
+import { isOpenCodeVersionSupported, normalizeOpenCodeToolName, OPENCODE_VERSION_MAXIMUM_EXCLUSIVE, OPENCODE_VERSION_MINIMUM, opencodeAdapter, parseOpenCodeEvent, replyOpenCode, staticBlockOpenCode } from "./opencode.ts";
+import { OPENCODE_CAPABILITIES } from "./opencode-capabilities.ts";
+import { parseUniversalEvent, replyUniversal, staticBlockUniversal, UNIVERSAL_CAPABILITIES, universalAdapter } from "./universal.ts";
+export { hookBudgetMs } from "./hook-dispatch.ts";
+export { type HookAppend, type HookBasePorts, type HookEnforcerLoader, type HookRunRequest, runHookEvent, staticBlock, supportedHarness, } from "./runtime.ts";
+export type { Adapter, CapabilityDeclaration, Decision, FileArtifact, HookDecision, HookEvent, HookReply, HookToolCall, RenderInput, ToolKind, Trigger, };
+export { CLAUDE_CODE_CAPABILITIES, CODEX_CAPABILITIES, COPILOT_CAPABILITIES, COPILOT_TIMEOUT_SEC, CURSOR_CAPABILITIES, checkCustomContract, claudeCodeAdapter, codexCliAdapter, copilotAdapter, cursorAdapter, GEMINI_CAPABILITIES, geminiCliAdapter, HOOK_PAYLOAD_MAX_BYTES, isOpenCodeVersionSupported, loadCustomAdapter, MUSE_CAPABILITIES, museAdapter, normalizeClaudeCodeToolName, normalizeCodexToolName, normalizeCopilotToolName, normalizeCursorToolName, normalizeGeminiToolName, normalizeMuseToolName, normalizeOpenCodeToolName, OPENCODE_CAPABILITIES, OPENCODE_VERSION_MAXIMUM_EXCLUSIVE, OPENCODE_VERSION_MINIMUM, opencodeAdapter, parseClaudeCodeEvent, parseCodexEvent, parseCopilotEvent, parseCursorEvent, parseGeminiEvent, parseMuseEvent, parseOpenCodeEvent, parseUniversalEvent, renderCustomHarnessFiles, renderCustomRegenFragment, replyClaudeCode, replyCodex, replyCopilot, replyCursor, replyGemini, replyMuse, replyOpenCode, replyUniversal, staticBlockClaudeCode, staticBlockCodex, staticBlockCopilot, staticBlockCursor, staticBlockGemini, staticBlockMuse, staticBlockOpenCode, staticBlockUniversal, UNIVERSAL_CAPABILITIES, universalAdapter, };
+export declare function parseEvent(harness: string, event: string, raw: unknown): Result<HookEvent>;
+export declare function renderReply(harness: string, decision: HookDecision): HookReply;

package/dist/features/adapters/index.js

@@ -0,0 +1,86 @@
+import { err, makeError } from "../../kernel/index.js";
+import { CLAUDE_CODE_CAPABILITIES, claudeCodeAdapter, normalizeClaudeCodeToolName, parseClaudeCodeEvent, replyClaudeCode, staticBlockClaudeCode, } from "./claude-code.js";
+import { CODEX_CAPABILITIES, codexCliAdapter, normalizeCodexToolName, parseCodexEvent, replyCodex, staticBlockCodex, } from "./codex-cli.js";
+import { HOOK_PAYLOAD_MAX_BYTES } from "./contract.js";
+import { COPILOT_TIMEOUT_SEC, copilotAdapter, normalizeCopilotToolName, parseCopilotEvent, replyCopilot, staticBlockCopilot, } from "./copilot.js";
+import { COPILOT_CAPABILITIES } from "./copilot-capabilities.js";
+import { CURSOR_CAPABILITIES, cursorAdapter, normalizeCursorToolName, parseCursorEvent, replyCursor, staticBlockCursor, } from "./cursor.js";
+import { checkCustomContract, loadCustomAdapter, renderCustomHarnessFiles, renderCustomRegenFragment, } from "./custom.js";
+import { geminiCliAdapter, parseGeminiEvent, replyGemini, staticBlockGemini, } from "./gemini-cli.js";
+import { GEMINI_CAPABILITIES, normalizeGeminiToolName, } from "./gemini-tables.js";
+import { MUSE_CAPABILITIES, museAdapter, normalizeMuseToolName, parseMuseEvent, replyMuse, staticBlockMuse, } from "./muse-code.js";
+import { isOpenCodeVersionSupported, normalizeOpenCodeToolName, OPENCODE_VERSION_MAXIMUM_EXCLUSIVE, OPENCODE_VERSION_MINIMUM, opencodeAdapter, parseOpenCodeEvent, replyOpenCode, staticBlockOpenCode, } from "./opencode.js";
+import { OPENCODE_CAPABILITIES } from "./opencode-capabilities.js";
+import { parseUniversalEvent, replyUniversal, staticBlockUniversal, UNIVERSAL_CAPABILITIES, universalAdapter, } from "./universal.js";
+export { hookBudgetMs } from "./hook-dispatch.js";
+export { runHookEvent, staticBlock, supportedHarness, } from "./runtime.js";
+export { CLAUDE_CODE_CAPABILITIES, CODEX_CAPABILITIES, COPILOT_CAPABILITIES, COPILOT_TIMEOUT_SEC, CURSOR_CAPABILITIES, checkCustomContract, claudeCodeAdapter, codexCliAdapter, copilotAdapter, cursorAdapter, GEMINI_CAPABILITIES, geminiCliAdapter, HOOK_PAYLOAD_MAX_BYTES, isOpenCodeVersionSupported, loadCustomAdapter, MUSE_CAPABILITIES, museAdapter, normalizeClaudeCodeToolName, normalizeCodexToolName, normalizeCopilotToolName, normalizeCursorToolName, normalizeGeminiToolName, normalizeMuseToolName, normalizeOpenCodeToolName, OPENCODE_CAPABILITIES, OPENCODE_VERSION_MAXIMUM_EXCLUSIVE, OPENCODE_VERSION_MINIMUM, opencodeAdapter, parseClaudeCodeEvent, parseCodexEvent, parseCopilotEvent, parseCursorEvent, parseGeminiEvent, parseMuseEvent, parseOpenCodeEvent, parseUniversalEvent, renderCustomHarnessFiles, renderCustomRegenFragment, replyClaudeCode, replyCodex, replyCopilot, replyCursor, replyGemini, replyMuse, replyOpenCode, replyUniversal, staticBlockClaudeCode, staticBlockCodex, staticBlockCopilot, staticBlockCursor, staticBlockGemini, staticBlockMuse, staticBlockOpenCode, staticBlockUniversal, UNIVERSAL_CAPABILITIES, universalAdapter, };
+// SPEC §4.5.3: native harness payload to the normalised event. Payloads
+// over the 8 MiB cap block CDX-E305 here too (§4.5 EC-11), so the parse
+// layer enforces the same limit the runtime stdin read enforces.
+export function parseEvent(harness, event, raw) {
+    const text = JSON.stringify(raw);
+    if (text !== undefined &&
+        new TextEncoder().encode(text).length > HOOK_PAYLOAD_MAX_BYTES) {
+        return err(makeError("CDX-E305", "hook payload over 8 MiB is refused", "Write the file in smaller edits, then retry the tool call."));
+    }
+    if (harness === museAdapter.id) {
+        return museAdapter.parse(event, raw);
+    }
+    if (harness === opencodeAdapter.id) {
+        return opencodeAdapter.parse(event, raw);
+    }
+    if (harness === claudeCodeAdapter.id) {
+        return claudeCodeAdapter.parse(event, raw);
+    }
+    if (harness === copilotAdapter.id) {
+        return copilotAdapter.parse(event, raw);
+    }
+    if (harness === cursorAdapter.id) {
+        return cursorAdapter.parse(event, raw);
+    }
+    if (harness === geminiCliAdapter.id) {
+        return geminiCliAdapter.parse(event, raw);
+    }
+    if (harness === codexCliAdapter.id) {
+        return codexCliAdapter.parse(event, raw);
+    }
+    if (harness === universalAdapter.id) {
+        return universalAdapter.parse(event, raw);
+    }
+    // SPEC §4.5.6: the sync event seam cannot resolve custom adapters (the
+    // loader is async and root-confined), so every custom: id answers
+    // CDX-E301 here; callers with a root use loadCustomAdapter instead.
+    if (harness.startsWith("custom:")) {
+        return err(makeError("CDX-E301", `unknown harness id "${harness}"`, "Install the adapter under .codictator/adapters/<id>/adapter.mjs, then load it with loadCustomAdapter."));
+    }
+    throw new Error(`not implemented: SPEC §4.5.4 adapter for ${harness}`);
+}
+// SPEC §4.5.4: verdict to the harness-native reply.
+export function renderReply(harness, decision) {
+    if (harness === museAdapter.id) {
+        return museAdapter.reply(decision);
+    }
+    if (harness === opencodeAdapter.id) {
+        return opencodeAdapter.reply(decision);
+    }
+    if (harness === claudeCodeAdapter.id) {
+        return claudeCodeAdapter.reply(decision);
+    }
+    if (harness === copilotAdapter.id) {
+        return copilotAdapter.reply(decision);
+    }
+    if (harness === cursorAdapter.id) {
+        return cursorAdapter.reply(decision);
+    }
+    if (harness === geminiCliAdapter.id) {
+        return geminiCliAdapter.reply(decision);
+    }
+    if (harness === codexCliAdapter.id) {
+        return codexCliAdapter.reply(decision);
+    }
+    if (harness === universalAdapter.id) {
+        return universalAdapter.reply(decision);
+    }
+    throw new Error(`not implemented: SPEC §4.5.4 adapter for ${harness}`);
+}

package/dist/features/adapters/muse-code.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Adapter, CapabilityDeclaration, HookDecision, HookEvent, HookReply, ToolKind } from "./contract.ts";
+export declare function normalizeMuseToolName(name: string): ToolKind;
+export declare function parseMuseEvent(event: string, raw: unknown): Result<HookEvent>;
+export declare function replyMuse(decision: HookDecision): HookReply;
+export declare function staticBlockMuse(code: string, message: string): HookReply;
+export declare const MUSE_CAPABILITIES: CapabilityDeclaration;
+export declare const museAdapter: Adapter;