codictator 0.0.0 → 0.1.3

package/dist/cli/task-phases.js

@@ -0,0 +1,77 @@
+// SPEC §4.12.2: task phase advancement. The next-phase gate check and the
+// phase entry write live here; dispatch stays in task-advance.ts.
+import { parseArgs } from "node:util";
+import { checkPhaseGate, MANDATORY_PHASES, } from "../features/workflow/index.js";
+import { ok } from "../kernel/index.js";
+import { fail, portsFor, printHuman, printJson, usageError } from "./shared.js";
+import { readTask, writeTask } from "./tasks.js";
+async function gateForNextPhase(task, next) {
+    const gate = await checkPhaseGate(task, next, {});
+    return gate.map((finding) => ({
+        ruleId: finding.ruleId,
+        message: finding.message,
+        remediation: finding.remediation,
+    }));
+}
+async function applyPhaseEntry(root, task, next, now) {
+    const moved = {
+        ...task,
+        phase: next,
+        phases: [
+            ...task.phases,
+            { name: next, enteredAt: now, evidence: "codictator task phase next" },
+        ],
+    };
+    return writeTask(root, moved);
+}
+export async function taskPhaseNext(req, root) {
+    let id = "";
+    try {
+        const parsed = parseArgs({
+            args: [...req.args.slice(2)],
+            options: { id: { type: "string" } },
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length > 0) {
+            return usageError("usage: codictator task phase next --id <T-####>");
+        }
+        id = parsed.values.id ?? "";
+    }
+    catch {
+        return usageError("usage: codictator task phase next --id <T-####>");
+    }
+    const task = await readTask(root, id);
+    if (task === undefined) {
+        return fail("CDX-E903", `no task record for "${id}"`, "List tasks with codictator task show, then retry.", req.json);
+    }
+    const at = MANDATORY_PHASES.indexOf(task.phase);
+    const next = at >= 0 ? MANDATORY_PHASES[at + 1] : undefined;
+    if (next === undefined) {
+        return fail("CDX-E604", `task ${id} is past its last phase`, "Close the task instead.", req.json);
+    }
+    const blocked = await gateForNextPhase(task, next);
+    if (blocked.length > 0) {
+        if (req.json) {
+            printJson({ id, phase: task.phase, blocked });
+        }
+        else {
+            for (const finding of blocked) {
+                printHuman(`${finding.ruleId}  ${finding.message}`, req.quiet);
+                printHuman(`Do instead: ${finding.remediation}`, req.quiet);
+            }
+        }
+        return ok(1);
+    }
+    const ports = await portsFor(root);
+    const saved = await applyPhaseEntry(root, task, next, ports.ok ? ports.value.clock.now() : "");
+    if (!saved.ok) {
+        return saved;
+    }
+    if (req.json) {
+        printJson({ id, phase: next });
+    }
+    else {
+        printHuman(`task ${id} entered ${next}`, req.quiet);
+    }
+    return ok(0);
+}

package/dist/cli/tasks.d.ts

@@ -0,0 +1,12 @@
+import { type TaskRecord } from "../features/workflow/index.ts";
+import type { Result } from "../kernel/index.ts";
+import type { CommandRequest } from "./shared.ts";
+export declare const TASKS_DIR = ".codictator/tasks";
+export declare function listTaskIds(root: string): Promise<Array<string>>;
+export declare function readTask(root: string, id: string): Promise<TaskRecord | undefined>;
+export declare function writeTask(root: string, task: TaskRecord): Promise<Result<number>>;
+export declare function taskLine(task: TaskRecord): string;
+export declare function branchOf(root: string): Promise<string | undefined>;
+export declare function taskNew(req: CommandRequest, root: string): Promise<Result<number>>;
+export declare function taskCheckpoint(req: CommandRequest, root: string): Promise<Result<number>>;
+export declare function taskClose(req: CommandRequest, root: string, id: string): Promise<Result<number>>;

package/dist/cli/tasks.js

@@ -0,0 +1,176 @@
+// SPEC §4.12: task records. State lives in repo-relative JSON the workflow
+// module validates; creation binds the branch, and listing surfaces every
+// record through the same terse line.
+import { parseArgs } from "node:util";
+import { isTaskId, taskIdFor, validateTaskRecord, } from "../features/workflow/index.js";
+import { ok, parseJson, stableStringify } from "../kernel/index.js";
+import { fail, portsFor, printHuman, printJson, usageError, writeStateText, } from "./shared.js";
+export const TASKS_DIR = ".codictator/tasks";
+export async function listTaskIds(root) {
+    const ports = await portsFor(root);
+    if (!ports.ok) {
+        return [];
+    }
+    const listed = await ports.value.fs.list(TASKS_DIR);
+    if (!listed.ok) {
+        return [];
+    }
+    return listed.value
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => name.slice(0, -".json".length))
+        .filter((id) => isTaskId(id))
+        .sort();
+}
+export async function readTask(root, id) {
+    const ports = await portsFor(root);
+    if (!ports.ok) {
+        return undefined;
+    }
+    const seen = await ports.value.fs.exists(`${TASKS_DIR}/${id}.json`);
+    if (!seen.ok || !seen.value) {
+        return undefined;
+    }
+    const text = await ports.value.fs.readText(`${TASKS_DIR}/${id}.json`);
+    if (!text.ok) {
+        return undefined;
+    }
+    const parsed = parseJson(text.value);
+    if (!parsed.ok || typeof parsed.value !== "object" || parsed.value === null) {
+        return undefined;
+    }
+    return parsed.value;
+}
+export async function writeTask(root, task) {
+    const problems = validateTaskRecord(task);
+    if (problems.length > 0) {
+        return fail("CDX-E604", `task record invalid: ${problems.join("; ")}`, "Fix the record fields, then retry.", false);
+    }
+    const saved = await writeStateText(root, `${TASKS_DIR}/${task.id}.json`, `${stableStringify(task)}\n`);
+    if (!saved.ok) {
+        return fail("CDX-E903", saved.error.message, saved.error.remediation, false);
+    }
+    return ok(0);
+}
+export function taskLine(task) {
+    return `${task.id} [${task.type}] ${task.phase}: ${task.title}`;
+}
+export async function branchOf(root) {
+    const ports = await portsFor(root);
+    if (!ports.ok) {
+        return undefined;
+    }
+    const result = await ports.value.proc.run(["git", "branch", "--show-current"], {
+        cwd: root,
+        env: {},
+        timeoutMs: 15000,
+        maxOutputBytes: 4096,
+    });
+    const branch = result.stdout.trim();
+    return result.code === 0 && branch !== "" ? branch : undefined;
+}
+export async function taskNew(req, root) {
+    let type = "";
+    let title = "";
+    try {
+        const parsed = parseArgs({
+            args: [...req.args.slice(1)],
+            options: { type: { type: "string" }, title: { type: "string" } },
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length > 0) {
+            return usageError("usage: codictator task new --type <t> --title <t>");
+        }
+        type = parsed.values.type ?? "";
+        title = parsed.values.title ?? "";
+    }
+    catch {
+        return usageError("usage: codictator task new --type <t> --title <t>");
+    }
+    if (type === "" || title === "") {
+        return usageError("usage: codictator task new --type <t> --title <t>");
+    }
+    const branch = await branchOf(root);
+    if (branch === undefined) {
+        return fail("CDX-E903", "cannot read the current branch", "Run on a git branch, then retry.", req.json);
+    }
+    const ids = await listTaskIds(root);
+    const task = {
+        version: 1,
+        id: taskIdFor(ids.length + 1),
+        type,
+        title,
+        branch,
+        phase: "discovery",
+        phases: [],
+        spec: [],
+        acceptanceCriteria: [],
+        files: { allow: [] },
+    };
+    const saved = await writeTask(root, task);
+    if (!saved.ok) {
+        return saved;
+    }
+    if (req.json) {
+        printJson({ id: task.id, phase: task.phase, branch });
+    }
+    else {
+        printHuman(`created ${taskLine(task)}`, req.quiet);
+    }
+    return ok(0);
+}
+export async function taskCheckpoint(req, root) {
+    let id = "";
+    let note = "";
+    try {
+        const parsed = parseArgs({
+            args: [...req.args.slice(1)],
+            options: {
+                id: { type: "string" },
+                note: { type: "string", default: "" },
+            },
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length > 0) {
+            return usageError("usage: codictator task checkpoint --id <T-####> [--note <t>]");
+        }
+        id = parsed.values.id ?? "";
+        note = parsed.values.note ?? "";
+    }
+    catch {
+        return usageError("usage: codictator task checkpoint --id <T-####> [--note <t>]");
+    }
+    const task = await readTask(root, id);
+    if (task === undefined) {
+        return fail("CDX-E903", `no task record for "${id}"`, "List tasks with codictator task show, then retry.", req.json);
+    }
+    const ports = await portsFor(root);
+    const now = ports.ok ? ports.value.clock.now() : "";
+    const saved = await writeStateText(root, `.codictator/state/task-${id}.checkpoint.json`, `${stableStringify({ version: 1, id, at: now, phase: task.phase, branch: task.branch, note })}\n`);
+    if (!saved.ok) {
+        return fail("CDX-E903", saved.error.message, saved.error.remediation, req.json);
+    }
+    if (req.json) {
+        printJson({ id, checkpoint: true });
+    }
+    else {
+        printHuman(`checkpoint recorded for ${id}`, req.quiet);
+    }
+    return ok(0);
+}
+export async function taskClose(req, root, id) {
+    const ports = await portsFor(root);
+    if (!ports.ok) {
+        return fail("CDX-E903", ports.error.message, ports.error.remediation, req.json);
+    }
+    const bytes = await ports.value.fs.read(`${TASKS_DIR}/${id}.json`);
+    if (!bytes.ok) {
+        return fail("CDX-E903", bytes.error.message, bytes.error.remediation, req.json);
+    }
+    const moved = await ports.value.fs.write(`.codictator/state/closed-tasks/${id}.json`, bytes.value);
+    if (!moved.ok) {
+        return fail("CDX-E903", moved.error.message, moved.error.remediation, req.json);
+    }
+    await ports.value.fs.remove(`${TASKS_DIR}/${id}.json`);
+    printHuman(`closed ${id}`, req.quiet);
+    return ok(0);
+}

package/dist/cli/transparency.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from "../kernel/index.ts";
+import type { CommandRequest } from "./shared.ts";
+export declare function handleExplain(req: CommandRequest): Promise<Result<number>>;
+export declare function handleReplay(req: CommandRequest): Promise<Result<number>>;

package/dist/cli/transparency.js

@@ -0,0 +1,197 @@
+// SPEC §4.18.2 + §4.19.2: explain and replay. Rules print their pack row,
+// events their verdict plus replay, error codes their §8 row; unknown ids
+// print CDX-E010 and exit 2.
+import { parseArgs } from "node:util";
+import { errorRowFor, explain, explainCodeText, isKnownExplainId, replaySummary, } from "../features/audit/index.js";
+import { ENGINE_VERSION } from "../features/config/index.js";
+import { loadBuiltinPack } from "../features/packs/index.js";
+import { err, makeError, ok } from "../kernel/index.js";
+import { handleVerify, readLogEvents } from "./inspect.js";
+import { fail, needRoot, printHuman, printJson, usageError } from "./shared.js";
+// SPEC §4.18.2: a rule prints its pack row. Packs load through the real
+// loader; ids no loaded pack owns fall through to the unknown-id path.
+async function ruleText(ruleId) {
+    for (const id of ["core", "typescript", "dotnet", "python"]) {
+        const loaded = await loadBuiltinPack(id);
+        if (!loaded.ok) {
+            continue;
+        }
+        for (const rule of loaded.value.manifest.rules) {
+            if (rule.id !== ruleId) {
+                continue;
+            }
+            const params = Object.entries(rule.params)
+                .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+                .map(([name, param]) => `${name}: default ${String(param.default)}, bound ${String(param.bound)}`);
+            return [
+                `rule ${rule.id} (${loaded.value.manifest.id}@${loaded.value.manifest.version})`,
+                `statement: ${rule.statement}`,
+                `reason: ${rule.reason}`,
+                `tier: ${rule.tier}, family: ${rule.family}, enforcer: ${rule.enforcer}`,
+                `params: ${params.length === 0 ? "none" : params.join("; ")}`,
+                `remediation: ${rule.remediation}`,
+                "coverage: per-harness capability declarations; see codictator status",
+            ].join("\n");
+        }
+    }
+    return undefined;
+}
+async function explainEvent(root, target, req) {
+    const log = await readLogEvents(root);
+    if (log === undefined) {
+        return undefined;
+    }
+    for (const event of log.events) {
+        if (event.id !== target) {
+            continue;
+        }
+        const summary = replaySummary(event);
+        if (req.json) {
+            printJson({ event: target, text: summary });
+        }
+        else {
+            printHuman(summary, req.quiet);
+        }
+        return ok(0);
+    }
+    return undefined;
+}
+function explainUnknown(req, target, text) {
+    return text.then((resolved) => {
+        const unknown = makeError("CDX-E010", `unknown rule, event or error id "${target}"`, "Check the spelling; the nearest known ids were listed.", resolved);
+        if (req.json) {
+            printJson({ code: unknown.code, id: target, text: resolved });
+        }
+        else {
+            process.stderr.write(`${resolved}\n`);
+        }
+        return err(unknown);
+    });
+}
+function explainKnownCode(req, target) {
+    const found = errorRowFor(target);
+    if (found === undefined) {
+        return undefined;
+    }
+    if (req.json) {
+        printJson({
+            code: found.code,
+            exit: found.exit,
+            meaning: found.meaning,
+            remediation: found.remediation,
+            text: explainCodeText(found),
+        });
+    }
+    else {
+        printHuman(explainCodeText(found), req.quiet);
+    }
+    return ok(0);
+}
+// SPEC §4.18.2: Rule prints its row, Event its verdict plus replay, Error
+// code its §8 row; unknown ids print CDX-E010 and exit 2.
+export async function handleExplain(req) {
+    let id;
+    try {
+        const parsed = parseArgs({
+            args: [...req.args],
+            options: {},
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length !== 1) {
+            return usageError("usage: codictator explain <ruleId | eventId | CDX-Ennn>");
+        }
+        id = parsed.positionals[0];
+    }
+    catch {
+        return usageError("usage: codictator explain <ruleId | eventId | CDX-Ennn>");
+    }
+    const target = id ?? "";
+    if (isKnownExplainId(target)) {
+        const known = explainKnownCode(req, target);
+        if (known !== undefined) {
+            return known;
+        }
+    }
+    if (target.includes("/")) {
+        const text = await ruleText(target);
+        if (text !== undefined) {
+            if (req.json) {
+                printJson({ rule: target, text });
+            }
+            else {
+                printHuman(text, req.quiet);
+            }
+            return ok(0);
+        }
+    }
+    const root = await needRoot(req);
+    if (typeof root === "string") {
+        const answered = await explainEvent(root, target, req);
+        if (answered !== undefined) {
+            return answered;
+        }
+    }
+    return explainUnknown(req, target, explain(target));
+}
+async function findReplayEvent(root, target) {
+    const log = await readLogEvents(root);
+    if (log === undefined) {
+        return undefined;
+    }
+    return log.events.find((event) => event.id === target);
+}
+// SPEC §4.18.2 + EC-5 + §10.4: re-run the inputs an event records; a pack
+// version that is no longer installed fails as CDX-E011 naming the version
+// needed. Bare `replay` re-runs the verify evaluation, so its verdict JSON
+// shape matches `verify` by construction and the §10.4 replay rows compare
+// equal in memory; single ids still render through replaySummary.
+export async function handleReplay(req) {
+    let id;
+    try {
+        const parsed = parseArgs({
+            args: [...req.args],
+            options: {},
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length > 1) {
+            return usageError("usage: codictator replay [<eventId>]");
+        }
+        if (parsed.positionals.length === 0) {
+            return handleVerify(req);
+        }
+        id = parsed.positionals[0];
+    }
+    catch {
+        return usageError("usage: codictator replay [<eventId>]");
+    }
+    const target = id ?? "";
+    const root = await needRoot(req);
+    if (typeof root !== "string") {
+        return root;
+    }
+    const event = await findReplayEvent(root, target);
+    if (event === undefined) {
+        const log = await readLogEvents(root);
+        if (log === undefined) {
+            return fail("CDX-E903", "event log unreadable", "Fix permissions on .codictator/state/, then retry.", req.json);
+        }
+        if (!req.json) {
+            process.stderr.write(`${await explain(target)}\n`);
+        }
+        return fail("CDX-E010", `unknown event id "${target}"`, "List recent events with codictator report, then retry.", req.json);
+    }
+    const engineKey = "codictator";
+    const recorded = event.packs[engineKey];
+    const engineVersion = req.engineVersion ?? ENGINE_VERSION;
+    if (recorded !== undefined && recorded !== engineVersion) {
+        return fail("CDX-E011", `replay needs pack codictator@${recorded}, installed is ${engineVersion}`, `Install codictator@${recorded}, then rerun codictator replay ${target}.`, req.json);
+    }
+    const summary = replaySummary(event);
+    if (req.json) {
+        printJson({ event: target, text: summary });
+    }
+    else {
+        printHuman(summary, req.quiet);
+    }
+    return ok(0);
+}

package/dist/cli/waivers.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from "../kernel/index.ts";
+import type { CommandRequest } from "./shared.ts";
+export declare function handleWaive(req: CommandRequest): Promise<Result<number>>;

package/dist/cli/waivers.js

@@ -0,0 +1,195 @@
+// SPEC §4.19.2 + §4.3.4: waive a tunable with reason, expiry and optional
+// scope. Floor rules refuse as CDX-E103; values beyond the pack bound as
+// CDX-E109; rules no loaded pack owns fail closed as CDX-E903.
+import { parseArgs } from "node:util";
+import { MAX_WAIVER_DAYS } from "../features/engine/index.js";
+import { loadBuiltinPack } from "../features/packs/index.js";
+import { ok, parseJson, stableStringify } from "../kernel/index.js";
+import { checkHuman, commandEnv, fail, needRoot, portsFor, printHuman, printJson, readStateText, usageError, writeStateText, } from "./shared.js";
+const WAIVE_USAGE = "usage: codictator waive <rule> --set k=v ... --reason <t> --expires <yyyy-mm-dd> [--paths ...] [--renews <id>]";
+function dateOnly(now) {
+    return now.slice(0, "2026-01-02".length);
+}
+function parseWaiveFlags(args) {
+    try {
+        const parsed = parseArgs({
+            args: [...args],
+            options: {
+                set: { type: "string", multiple: true, default: [] },
+                reason: { type: "string" },
+                expires: { type: "string" },
+                paths: { type: "string", multiple: true, default: [] },
+                renews: { type: "string" },
+            },
+            allowPositionals: true,
+        });
+        if (parsed.positionals.length !== 1) {
+            return undefined;
+        }
+        return {
+            rule: parsed.positionals[0] ?? "",
+            sets: [...(parsed.values.set ?? [])],
+            reason: parsed.values.reason ?? "",
+            expires: parsed.values.expires ?? "",
+            paths: [...(parsed.values.paths ?? [])],
+            renews: parsed.values.renews,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+// SPEC §4.3.4: the floor and bound gates over loaded pack data. A rule no
+// loaded pack owns fails closed as CDX-E903: its tier cannot be verified.
+async function checkWaiveBounds(rule, params, req) {
+    let knownRule = false;
+    for (const id of ["core", "typescript", "dotnet", "python"]) {
+        const loaded = await loadBuiltinPack(id);
+        if (!loaded.ok) {
+            continue;
+        }
+        for (const candidate of loaded.value.manifest.rules) {
+            if (candidate.id !== rule) {
+                continue;
+            }
+            knownRule = true;
+            if (candidate.tier === "floor") {
+                return fail("CDX-E103", `waiver of floor rule ${rule} refused`, "Floor rules cannot be loosened; fix the violation instead.", req.json);
+            }
+            for (const [name, value] of Object.entries(params)) {
+                const spec = candidate.params[name];
+                if (spec === undefined) {
+                    continue;
+                }
+                const bound = Number(spec.bound);
+                const seen = Number(value);
+                const outside = typeof value === "number" &&
+                    Number.isFinite(bound) &&
+                    Number.isFinite(seen) &&
+                    ((spec.stricter === "lower" && seen > bound) ||
+                        (spec.stricter === "higher" && seen < bound));
+                if (outside) {
+                    return fail("CDX-E109", `waiver value ${name}=${seen} is beyond the pack bound ${bound}`, "Bring the value inside the pack bound, then retry.", req.json);
+                }
+            }
+        }
+    }
+    if (!knownRule) {
+        return fail("CDX-E903", `rule "${rule}" is not in a loaded pack; its tier cannot be verified`, "Use a rule id from a loaded pack, then retry.", req.json);
+    }
+    return ok(0);
+}
+async function readKnownWaivers(root) {
+    const existing = await readStateText(root, ".codictator/waivers.json");
+    const known = [];
+    if (existing === undefined) {
+        return known;
+    }
+    const parsed = parseJson(existing);
+    const value = parsed.ok ? parsed.value : undefined;
+    const list = Array.isArray(value)
+        ? value
+        : typeof value === "object" &&
+            value !== null &&
+            Array.isArray(value.waivers)
+            ? value.waivers
+            : [];
+    for (const entry of list) {
+        known.push(entry);
+    }
+    return known;
+}
+function buildWaiverParams(sets) {
+    const params = {};
+    for (const entry of sets) {
+        const at = entry.indexOf("=");
+        if (at < 1) {
+            return undefined;
+        }
+        const raw = entry.slice(at + 1);
+        const numeric = Number(raw);
+        params[entry.slice(0, at)] =
+            raw !== "" && Number.isFinite(numeric) ? numeric : raw;
+    }
+    return params;
+}
+async function writeWaiverFile(root, fields, req) {
+    const known = await readKnownWaivers(root);
+    if (fields.renews !== undefined &&
+        !known.some((entry) => entry.id === fields.renews)) {
+        return fail("CDX-E110", `renewal target ${fields.renews} is not a known waiver`, "Renew an existing waiver id, then retry.", req.json);
+    }
+    const waiver = {
+        id: `W-${String(known.length + 1).padStart(4, "0")}`,
+        rule: fields.rule,
+        params: fields.params,
+        paths: [...fields.paths],
+        reason: fields.reason,
+        created: dateOnly(fields.now),
+        expires: fields.expires,
+        createdBy: "human",
+    };
+    const saved = await writeStateText(root, ".codictator/waivers.json", `${stableStringify({ version: 1, maxWaiverDays: MAX_WAIVER_DAYS, waivers: [...known, waiver] })}\n`);
+    if (!saved.ok) {
+        return fail("CDX-E903", saved.error.message, saved.error.remediation, req.json);
+    }
+    return ok(waiver);
+}
+// SPEC §4.3.4: waive a tunable with reason, expiry and optional scope.
+// Human-only; floor rules and out-of-bound values fail with their row.
+export async function handleWaive(req) {
+    const human = checkHuman(commandEnv(), []);
+    if (!human.ok) {
+        return fail("CDX-E107", human.error.message, human.error.remediation, req.json);
+    }
+    const root = await needRoot(req);
+    if (typeof root !== "string") {
+        return root;
+    }
+    const flags = parseWaiveFlags(req.args);
+    if (flags === undefined ||
+        flags.rule === "" ||
+        flags.reason === "" ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(flags.expires)) {
+        return usageError(WAIVE_USAGE);
+    }
+    const ports = await portsFor(root);
+    if (!ports.ok) {
+        return fail("CDX-E903", ports.error.message, ports.error.remediation, req.json);
+    }
+    const now = ports.value.clock.now();
+    if (flags.expires <= dateOnly(now)) {
+        return fail("CDX-E110", `waiver expiry ${flags.expires} is not in the future`, "Pick an expiry within maxWaiverDays, then retry.", req.json);
+    }
+    const params = buildWaiverParams(flags.sets);
+    if (params === undefined) {
+        return usageError(WAIVE_USAGE);
+    }
+    const gated = await checkWaiveBounds(flags.rule, params, req);
+    if (!gated.ok) {
+        return gated;
+    }
+    const written = await writeWaiverFile(root, {
+        rule: flags.rule,
+        params,
+        paths: flags.paths,
+        reason: flags.reason,
+        expires: flags.expires,
+        renews: flags.renews,
+        now,
+    }, req);
+    if (!written.ok) {
+        return written;
+    }
+    if (req.json) {
+        printJson({
+            waived: written.value.id,
+            rule: flags.rule,
+            expires: flags.expires,
+        });
+    }
+    else {
+        printHuman(`waived ${flags.rule} as ${written.value.id} until ${flags.expires}`, req.quiet);
+    }
+    return ok(0);
+}

package/dist/features/adapters/claude-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 normalizeClaudeCodeToolName(name: string): ToolKind;
+export declare function parseClaudeCodeEvent(event: string, raw: unknown): Result<HookEvent>;
+export declare function replyClaudeCode(decision: HookDecision): HookReply;
+export declare function staticBlockClaudeCode(code: string, message: string): HookReply;
+export declare const CLAUDE_CODE_CAPABILITIES: CapabilityDeclaration;
+export declare const claudeCodeAdapter: Adapter;