@oscharko-dev/keiko 0.1.0-beta.0

package/dist/cli/run.js

@@ -0,0 +1,187 @@
+// `keiko run` — the dry-run task command. It builds an AgentSession wired to deterministic mocked
+// model/tool fixtures (no provider call, no real tools) and renders the HarnessEvent stream to
+// CliIo. Since ADR-0010 it ALSO writes a redacted evidence manifest by default (evidence is the
+// product value): a tee EventSink forwards every event to BOTH a MemoryEventSink (which retains raw
+// content to assemble the replay manifest) and the existing CliEventSink (whose summarisers never
+// print sensitive fields). After the run resolves, the audit layer builds + redacts + persists the
+// manifest and the EvidenceReport is printed. Writing is on by default; --no-evidence disables it,
+// --evidence-dir relocates it. Tests inject an in-memory EvidenceStore via deps so no write ever
+// touches the repository tree.
+import { DryRunToolPort } from "../harness/adapters.js";
+import { createSession, HARNESS_VERSION } from "../harness/session.js";
+import { CliEventSink, MemoryEventSink } from "../harness/sinks.js";
+import { DEFAULT_LIMITS } from "../harness/types.js";
+import { persistEvidence } from "../audit/persist.js";
+import { renderEvidenceReport } from "../audit/report.js";
+import { createNodeEvidenceStore, resolveEvidenceDir } from "../audit/store.js";
+import { AuditError } from "../audit/errors.js";
+import { redact } from "../gateway/redaction.js";
+const TASK_TYPES = new Set([
+    "generate-unit-tests",
+    "investigate-bug",
+    "explain-plan",
+]);
+const USAGE = `Usage:
+  keiko run explain-plan --file PATH [--question TEXT]
+  keiko run generate-unit-tests --file PATH [--function NAME]
+  keiko run investigate-bug --description TEXT [--file PATH]
+
+  Evidence flags (a redacted manifest is written by default):
+    --no-evidence            Do not write an evidence manifest.
+    --evidence-dir PATH      Write evidence under PATH (default $KEIKO_EVIDENCE_DIR or ./.keiko/evidence).
+    --include-reasoning      Include redacted reasoning entries in the manifest.
+    --include-diff           Include the redacted proposed diff in the manifest.
+
+All tasks run in dry-run mode: a patch is proposed as an event, never written to disk.
+`;
+function flag(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return undefined;
+    }
+    const value = args[i + 1];
+    return value === undefined || value.startsWith("--") ? undefined : value;
+}
+function parseEvidenceFlags(args) {
+    return {
+        write: !args.includes("--no-evidence"),
+        evidenceDirFlag: flag(args, "--evidence-dir"),
+        includeReasoning: args.includes("--include-reasoning"),
+        includeDiff: args.includes("--include-diff"),
+    };
+}
+// A deterministic, dependency-free canned final response. It never requests tools, so the dry-run
+// path is reproducible regardless of task type.
+function cannedResponse() {
+    return {
+        modelId: "mock-model",
+        content: "--- a/file\n+++ b/file\n+// dry-run proposed change\n",
+        finishReason: "stop",
+        toolCalls: [],
+        structuredOutput: null,
+        usage: {
+            requestId: "dry-run",
+            promptTokens: 0,
+            completionTokens: 0,
+            latencyMs: 1,
+            costClass: "low",
+        },
+    };
+}
+function parseTask(taskType, args) {
+    const file = flag(args, "--file");
+    if (taskType === "explain-plan") {
+        if (file === undefined) {
+            return null;
+        }
+        return { taskType, input: { filePath: file, question: flag(args, "--question") } };
+    }
+    if (taskType === "generate-unit-tests") {
+        if (file === undefined) {
+            return null;
+        }
+        return { taskType, input: { filePath: file, targetFunction: flag(args, "--function") } };
+    }
+    const description = flag(args, "--description");
+    if (description === undefined) {
+        return null;
+    }
+    return { taskType, input: { description, filePaths: file === undefined ? undefined : [file] } };
+}
+// Forwards each event to every wrapped sink. retainsRawContent is true so the harness emits raw
+// SENSITIVE fields — required for the MemoryEventSink's faithful replay manifest. The CliEventSink
+// summarisers never print those fields, and the audit layer redacts before anything is persisted.
+function teeSink(sinks) {
+    return {
+        retainsRawContent: true,
+        emit: (event) => {
+            for (const sink of sinks) {
+                sink.emit(event);
+            }
+        },
+    };
+}
+function seedFor(task, result) {
+    return {
+        runId: result.runId,
+        fingerprint: result.fingerprint,
+        harnessVersion: HARNESS_VERSION,
+        taskType: task.taskType,
+        taskInput: task,
+        limits: DEFAULT_LIMITS,
+        modelId: "mock-model",
+        workingDirectory: ".",
+        dryRun: true,
+        startedAt: new Date(result.startedAt).toISOString(),
+    };
+}
+// Persists the evidence manifest. This is a system boundary (filesystem write), so try/catch is
+// correct here (CLAUDE.md): on any failure — typed AuditError or otherwise — print a REDACTED
+// message and return exit 1 rather than rejecting out of runAgentCli as an unhandled rejection (C3).
+// Returns undefined on success so the caller falls through to the run-outcome exit code.
+function writeEvidence(result, memory, task, ctx, io) {
+    try {
+        const manifest = memory.collectManifest(seedFor(task, result));
+        const store = ctx.deps.store ??
+            createNodeEvidenceStore(resolveEvidenceDir(ctx.flags.evidenceDirFlag, ctx.env));
+        const out = persistEvidence({
+            result,
+            manifest,
+            options: {
+                includeReasoning: ctx.flags.includeReasoning,
+                includeDiff: ctx.flags.includeDiff,
+            },
+        }, { store, env: ctx.env });
+        io.out(renderEvidenceReport(out.report));
+        return undefined;
+    }
+    catch (error) {
+        const detail = error instanceof AuditError ? error.message : redact(String(error));
+        io.err(`keiko run: failed to write evidence: ${detail}\n`);
+        return 1;
+    }
+}
+function outcomeToExitCode(result, io) {
+    if (result.outcome === "completed") {
+        io.out(`run ${result.runId} completed (fingerprint ${result.fingerprint})\n`);
+        return 0;
+    }
+    if (result.outcome === "cancelled") {
+        io.err(`run ${result.runId} cancelled\n`);
+        return 1;
+    }
+    const category = result.failure?.category ?? "HARNESS_INTERNAL";
+    io.err(`run ${result.runId} ${result.outcome} [${category}]: ${result.failure?.message ?? ""}\n`);
+    return 1;
+}
+export async function runAgentCli(args, io, env = {}, deps = {}) {
+    const taskType = args[0];
+    if (taskType === undefined || !TASK_TYPES.has(taskType)) {
+        io.err(taskType === undefined ? USAGE : `keiko run: unknown task type: ${taskType}\n${USAGE}`);
+        return 2;
+    }
+    const task = parseTask(taskType, args.slice(1));
+    if (task === null) {
+        io.err(`keiko run: missing required argument for ${taskType}.\n${USAGE}`);
+        return 2;
+    }
+    const flags = parseEvidenceFlags(args);
+    const response = cannedResponse();
+    const memory = new MemoryEventSink();
+    const config = { model: "mock-model", workingDirectory: ".", dryRun: true };
+    const session = createSession(task, config, {
+        model: {
+            call: (request) => Promise.resolve({ ...response, modelId: request.modelId }),
+        },
+        tools: new DryRunToolPort(),
+        sink: teeSink([memory, new CliEventSink(io)]),
+    });
+    const result = await session.result;
+    if (flags.write) {
+        const evidenceFailure = writeEvidence(result, memory, task, { flags, env, deps }, io);
+        if (evidenceFailure !== undefined) {
+            return evidenceFailure;
+        }
+    }
+    return outcomeToExitCode(result, io);
+}

package/dist/cli/runner.d.ts

@@ -0,0 +1,6 @@
+import type { EnvSource } from "../gateway/config.js";
+export interface CliIo {
+    readonly out: (text: string) => void;
+    readonly err: (text: string) => void;
+}
+export declare function runCli(args: readonly string[], io: CliIo, env?: EnvSource): number | Promise<number>;

package/dist/cli/runner.js

@@ -0,0 +1,83 @@
+import { runModelsCli } from "./models.js";
+import { runAgentCli } from "./run.js";
+import { runContextCli } from "./context.js";
+import { runVerifyCli } from "./verify.js";
+import { runGenTestsCli } from "./gen-tests.js";
+import { runInvestigateCli } from "./investigate.js";
+import { runEvidenceCli } from "./evidence.js";
+import { runEvaluateCli } from "./evaluate.js";
+import { runUiCli } from "./ui.js";
+import { SDK_VERSION } from "../sdk/index.js";
+const HELP_TEXT = `keiko ${SDK_VERSION}
+Enterprise model-agnostic developer-assist coding agent.
+
+Usage:
+  keiko [--help | -h]      Print this help and exit.
+  keiko [--version | -v]   Print the version and exit.
+  keiko models list        List registered model capabilities.
+  keiko models validate    Validate gateway configuration.
+  keiko run <task>         Run a bounded dry-run task through the agent harness.
+  keiko context [OPTIONS]  Print a redacted workspace context summary (dry-run).
+  keiko verify [OPTIONS]   Run the project's gates and print a redacted evidence summary.
+  keiko gen-tests [OPTIONS] Generate a reviewable unit-test patch (dry-run by default).
+  keiko investigate [OPTIONS] Investigate a bug and propose a fix + regression test (dry-run by default).
+  keiko evidence <list|show> Inspect redacted evidence manifests written by \`keiko run\`.
+  keiko evaluate [OPTIONS]     Run the evaluation harness (offline by default; --live for live model).
+  keiko ui [OPTIONS]       Launch the local UI on 127.0.0.1 and print its URL.
+
+Exit codes:
+  0  Success
+  1  Runtime error
+  2  Usage error
+`;
+// Dispatches named subcommands; returns undefined when the name is not recognised.
+function dispatchCommand(name, rest, io, env) {
+    if (name === "models") {
+        return runModelsCli(rest, io, env);
+    }
+    if (name === "run") {
+        return runAgentCli(rest, io, env);
+    }
+    if (name === "context") {
+        return runContextCli(rest, io);
+    }
+    if (name === "verify") {
+        return runVerifyCli(rest, io);
+    }
+    if (name === "gen-tests") {
+        return runGenTestsCli(rest, io, env);
+    }
+    if (name === "investigate") {
+        return runInvestigateCli(rest, io, env);
+    }
+    if (name === "evidence") {
+        return runEvidenceCli(rest, io, { env });
+    }
+    if (name === "evaluate") {
+        return runEvaluateCli(rest, io, env, {});
+    }
+    if (name === "ui") {
+        return runUiCli(rest, io, env);
+    }
+    return undefined;
+}
+// Returns a number for synchronous commands; the async `run` command returns a Promise.
+// The process shim in index.ts awaits the union before calling process.exit.
+export function runCli(args, io, env = {}) {
+    const first = args[0];
+    if (first === undefined || first === "--help" || first === "-h") {
+        io.out(HELP_TEXT);
+        return 0;
+    }
+    if (first === "--version" || first === "-v") {
+        io.out(`keiko ${SDK_VERSION}\n`);
+        return 0;
+    }
+    const result = dispatchCommand(first, args.slice(1), io, env);
+    if (result !== undefined) {
+        return result;
+    }
+    io.err(`keiko: unknown ${first.startsWith("-") ? "option" : "command"}: ${first}\n`);
+    io.err("Run `keiko --help` for usage.\n");
+    return 2;
+}

package/dist/cli/ui.d.ts

@@ -0,0 +1,31 @@
+import type { Server } from "node:http";
+import { type SpawnOptions, type ChildProcess } from "node:child_process";
+import { type UiHandlerDeps } from "../ui/index.js";
+import type { EnvSource } from "../gateway/config.js";
+import type { CliIo } from "./runner.js";
+export interface UiCliArgs {
+    readonly port: number;
+    readonly evidenceDir: string | undefined;
+    readonly config: string | undefined;
+    readonly uiDbPath: string | undefined;
+}
+export interface UiCliDeps {
+    readonly createServer?: (deps: {
+        staticRoot: string;
+        csp: string;
+        port: number;
+        handlerDeps: UiHandlerDeps;
+    }) => Server | Promise<Server>;
+    readonly staticRoot?: string;
+    readonly hashesFile?: string;
+    readonly sqliteProbe?: () => boolean;
+    readonly spawnFn?: SpawnFn;
+    readonly currentExecArgv?: () => readonly string[];
+    readonly cwd?: string | undefined;
+}
+export type SpawnFn = (command: string, args: readonly string[], opts: SpawnOptions) => ChildProcess;
+export declare function parseUiArgs(args: readonly string[]): UiCliArgs | null;
+export declare function applyServerTimeouts(server: Server): void;
+export declare function waitForShutdown(server: Server): Promise<void>;
+export declare function reExecWithSqliteFlag(_env: EnvSource, spawnFn: SpawnFn): Promise<number>;
+export declare function runUiCli(args: readonly string[], io: CliIo, env: EnvSource, deps?: UiCliDeps): Promise<number>;

package/dist/cli/ui.js

@@ -0,0 +1,240 @@
+// `keiko ui` — launches the local Wave 1 UI BFF (ADR-0011). It resolves the packaged static export
+// (dist/ui/static) and the precomputed CSP hashes (dist/ui/csp-hashes.json) relative to this
+// compiled module, builds the CSP, starts createUiServer bound to 127.0.0.1 only, prints the local
+// URL, and keeps running until the process is signalled. Exit 2 on a usage error (bad --host/--port
+// or a flag missing its value), 1 when the static export is not present (the package was built with
+// `npm run build` but not `npm run build:ui`).
+//
+// ADR-0013 D2 site 1 — Detect-and-re-exec guard. Node 22.0–22.11 builds require
+// --experimental-sqlite to import node:sqlite; 22.22+ loads it without the flag. The guard tries
+// the import; on failure it re-spawns the current process with --experimental-sqlite prepended,
+// inheriting stdio and forwarding SIGINT/SIGTERM to the child, then propagates the child's exit
+// code. Injected-test invocations skip the guard entirely.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { createUiServer, loadCspHeader, buildUiHandlerDeps, DEFAULT_UI_PORT, UI_HOST, } from "../ui/index.js";
+const ALLOWED_HOSTS = new Set(["127.0.0.1", "localhost"]);
+const SQLITE_FLAG = "--experimental-sqlite";
+const KEIKO_ENV_NAME_RE = /^KEIKO_[A-Z0-9_]+$/;
+const USAGE = `Usage:
+  keiko ui [--port PORT] [--host 127.0.0.1|localhost] [--evidence-dir PATH] [--config PATH] [--ui-db PATH]
+
+Launches the local Keiko UI on the loopback interface and prints its URL. The server
+binds 127.0.0.1 only and serves the packaged UI assets (built with \`npm run build:ui\`).
+`;
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return undefined;
+    }
+    const value = args[i + 1];
+    return value === undefined || value.startsWith("--") ? null : value;
+}
+function parsePort(raw) {
+    if (!/^\d{1,5}$/.test(raw)) {
+        return null;
+    }
+    const port = Number(raw);
+    return port >= 1 && port <= 65535 ? port : null;
+}
+// Parses flags. Returns the parsed args, or null on any usage error (missing flag value, invalid
+// port, or a host other than the two loopback names).
+export function parseUiArgs(args) {
+    const portRaw = flagValue(args, "--port");
+    const hostRaw = flagValue(args, "--host");
+    const evidenceRaw = flagValue(args, "--evidence-dir");
+    const configRaw = flagValue(args, "--config");
+    const uiDbRaw = flagValue(args, "--ui-db");
+    if (portRaw === null ||
+        hostRaw === null ||
+        evidenceRaw === null ||
+        configRaw === null ||
+        uiDbRaw === null) {
+        return null;
+    }
+    if (hostRaw !== undefined && !ALLOWED_HOSTS.has(hostRaw)) {
+        return null;
+    }
+    const port = portRaw === undefined ? DEFAULT_UI_PORT : parsePort(portRaw);
+    if (port === null) {
+        return null;
+    }
+    return { port, evidenceDir: evidenceRaw, config: configRaw, uiDbPath: uiDbRaw };
+}
+function defaultStaticRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "ui", "static");
+}
+function parseEnvValue(raw) {
+    const value = raw.trim();
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === `"` && last === `"`) || (first === "'" && last === "'")) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
+function loadLocalKeikoEnv(cwd, env) {
+    const file = join(cwd, ".env");
+    if (!existsSync(file)) {
+        return env;
+    }
+    const merged = { ...env };
+    const text = readFileSync(file, "utf8");
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line.length === 0 || line.startsWith("#"))
+            continue;
+        const equals = line.indexOf("=");
+        if (equals <= 0)
+            continue;
+        const key = line.slice(0, equals).trim();
+        if (!KEIKO_ENV_NAME_RE.test(key))
+            continue;
+        if (merged[key] !== undefined)
+            continue;
+        merged[key] = parseEnvValue(line.slice(equals + 1));
+    }
+    return merged;
+}
+function resolveUiConfigPath(parsed, env) {
+    return parsed.config ?? env.KEIKO_CONFIG_FILE;
+}
+// Conservative request/header timeouts on the loopback BFF (defense in depth, L2/L3): even on
+// 127.0.0.1 a slow or stuck client must not hold a connection indefinitely. headersTimeout must be
+// at or below requestTimeout so an incomplete request line/header set is cut first.
+const REQUEST_TIMEOUT_MS = 30_000;
+const HEADERS_TIMEOUT_MS = 10_000;
+export function applyServerTimeouts(server) {
+    server.requestTimeout = REQUEST_TIMEOUT_MS;
+    server.headersTimeout = HEADERS_TIMEOUT_MS;
+}
+async function listen(server, port) {
+    await new Promise((res, rej) => {
+        server.once("error", rej);
+        server.listen(port, UI_HOST, res);
+    });
+}
+// Keeps the real-CLI process alive until a shutdown signal or server close. Resolves cleanly so
+// the caller can return 0. Registered listeners are removed on resolve to prevent leaks.
+export function waitForShutdown(server) {
+    return new Promise((resolve) => {
+        const onClose = () => {
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+            resolve();
+        };
+        const onSignal = () => {
+            server.removeListener("close", onClose);
+            server.close(() => {
+                resolve();
+            });
+        };
+        server.once("close", onClose);
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+    });
+}
+// Default probe: try to require node:sqlite. Any failure (ERR_UNKNOWN_BUILTIN_MODULE on early
+// 22.x, or a thrown ExperimentalWarning that escaped) means we need the flag. The require is
+// guarded inside a try; we never throw past here.
+function defaultSqliteProbe() {
+    try {
+        const req = createRequire(import.meta.url);
+        req("node:sqlite");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Returns true if `--experimental-sqlite` is already on execArgv, meaning we are inside the child
+// already and must not loop. Inspects both the supplied execArgv source (Node-level flags the
+// parent inherited) AND NODE_OPTIONS (where the flag may live in env).
+function alreadyFlagged(env, execArgv) {
+    if (execArgv.includes(SQLITE_FLAG))
+        return true;
+    const nodeOptions = env.NODE_OPTIONS;
+    return typeof nodeOptions === "string" && nodeOptions.includes(SQLITE_FLAG);
+}
+// Re-spawns the current process with --experimental-sqlite prepended, inheriting stdio. Returns
+// the exit code the child terminated with so the parent can propagate it.
+export async function reExecWithSqliteFlag(_env, spawnFn) {
+    const entry = process.argv[1];
+    if (entry === undefined)
+        return 1;
+    const childArgs = [SQLITE_FLAG, ...process.execArgv, entry, ...process.argv.slice(2)];
+    const child = spawnFn(process.execPath, childArgs, { stdio: "inherit" });
+    const forwardSigint = () => {
+        child.kill("SIGINT");
+    };
+    const forwardSigterm = () => {
+        child.kill("SIGTERM");
+    };
+    process.on("SIGINT", forwardSigint);
+    process.on("SIGTERM", forwardSigterm);
+    return new Promise((res) => {
+        child.on("exit", (code, signal) => {
+            process.removeListener("SIGINT", forwardSigint);
+            process.removeListener("SIGTERM", forwardSigterm);
+            if (typeof code === "number") {
+                res(code);
+                return;
+            }
+            res(signal === null ? 1 : 128);
+        });
+    });
+}
+// Returns undefined when no re-exec is needed; returns the child's exit code when a re-exec
+// happened. The guard never runs when an injected test factory bypasses the production loop, and
+// it never re-loops once --experimental-sqlite is already in execArgv.
+async function maybeReExecForSqlite(env, deps) {
+    if (deps.createServer !== undefined)
+        return undefined;
+    const execArgv = (deps.currentExecArgv ?? (() => process.execArgv))();
+    if (alreadyFlagged(env, execArgv))
+        return undefined;
+    const probe = deps.sqliteProbe ?? defaultSqliteProbe;
+    if (probe())
+        return undefined;
+    const spawnFn = deps.spawnFn ?? spawn;
+    return reExecWithSqliteFlag(env, spawnFn);
+}
+export async function runUiCli(args, io, env, deps = {}) {
+    const effectiveEnv = loadLocalKeikoEnv(deps.cwd ?? process.cwd(), env);
+    const reExec = await maybeReExecForSqlite(effectiveEnv, deps);
+    if (reExec !== undefined)
+        return reExec;
+    const parsed = parseUiArgs(args);
+    if (parsed === null) {
+        io.err(USAGE);
+        return 2;
+    }
+    const staticRoot = deps.staticRoot ?? defaultStaticRoot();
+    if (!existsSync(staticRoot)) {
+        io.err(`keiko ui: UI assets not found at ${staticRoot}. Run \`npm run build:ui\` first.\n`);
+        return 1;
+    }
+    const csp = await loadCspHeader(deps.hashesFile ?? join(staticRoot, "..", "csp-hashes.json"));
+    const handlerDeps = buildUiHandlerDeps({
+        configPath: resolveUiConfigPath(parsed, effectiveEnv),
+        evidenceDir: parsed.evidenceDir,
+        uiDbPath: parsed.uiDbPath,
+        env: effectiveEnv,
+    });
+    const factory = deps.createServer ?? createUiServer;
+    const server = await factory({ staticRoot, csp, port: parsed.port, handlerDeps });
+    applyServerTimeouts(server);
+    await listen(server, parsed.port);
+    io.out(`Keiko UI listening on http://${UI_HOST}:${String(parsed.port)}\n`);
+    // Block only in the real CLI path (no injected factory). Injected-server tests skip blocking so
+    // they don't hang; the real process must stay alive until signalled.
+    if (deps.createServer === undefined) {
+        await waitForShutdown(server);
+    }
+    return 0;
+}

package/dist/cli/verify.d.ts

@@ -0,0 +1,2 @@
+import type { CliIo } from "./runner.js";
+export declare function runVerifyCli(args: readonly string[], io: CliIo): Promise<number>;

package/dist/cli/verify.js

@@ -0,0 +1,103 @@
+// `keiko verify` — the real verification gate (NOT a dry-run). It detects the workspace, builds a
+// plan from the detected npm scripts, runs the allowlisted commands through the #6 safe tool layer
+// under per-command resource limits, and prints a redacted human table (or --json of the report).
+// Exit 0 when overall status is `passed`; 1 when any step did not pass or a workspace/runtime error
+// occurred; 2 on a usage error. Mirrors runContextCli's structure (flag parsing, --json, typed
+// error catch at the boundary).
+import { detectWorkspace } from "../workspace/index.js";
+import { WorkspaceError } from "../workspace/index.js";
+import { buildVerificationPlan, buildVerificationSummary, detectScripts, EmptyPlanError, runVerification, VerificationError, } from "../verification/index.js";
+const VALID_KINDS = new Set([
+    "test",
+    "targeted-test",
+    "typecheck",
+    "lint",
+    "build",
+]);
+const USAGE = `Usage:
+  keiko verify [--dir PATH] [--only KIND[,KIND]] [--changed FILE[,FILE]] [--json]
+
+Runs the project's own gates (typecheck, lint, test, build) through the safe tool
+layer under per-command resource limits and prints a redacted evidence summary.
+KIND is one of: test, targeted-test, typecheck, lint, build.
+`;
+// Returns the value of a `--flag value` pair, undefined if absent, or null if present without a
+// value (a usage error) — identical contract to runContextCli's flagValue.
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return undefined;
+    }
+    const value = args[i + 1];
+    return value === undefined || value.startsWith("--") ? null : value;
+}
+function parseKinds(raw) {
+    const parts = raw.split(",").map((p) => p.trim());
+    if (parts.some((p) => !VALID_KINDS.has(p))) {
+        return null;
+    }
+    return parts;
+}
+function parseArgs(args) {
+    const dirRaw = flagValue(args, "--dir");
+    const onlyRaw = flagValue(args, "--only");
+    const changedRaw = flagValue(args, "--changed");
+    if (dirRaw === null || onlyRaw === null || changedRaw === null) {
+        return null;
+    }
+    const only = onlyRaw === undefined ? undefined : parseKinds(onlyRaw);
+    if (only === null) {
+        return null;
+    }
+    const changed = changedRaw === undefined ? undefined : changedRaw.split(",").map((p) => p.trim());
+    return { dir: dirRaw ?? ".", only, changed, json: args.includes("--json") };
+}
+async function runPlan(parsed) {
+    const workspace = detectWorkspace(parsed.dir);
+    const catalog = detectScripts(workspace);
+    const plan = buildVerificationPlan(workspace, catalog, {
+        only: parsed.only,
+        changedFiles: parsed.changed,
+    });
+    if (plan.steps.length === 0) {
+        throw new EmptyPlanError("verification plan contains no runnable or skipped steps");
+    }
+    return runVerification(plan, { workspace });
+}
+function renderText(report, io) {
+    const summary = buildVerificationSummary(report);
+    io.out(`Verification: ${summary.overallStatus} (${String(summary.durationMs)}ms)\n`);
+    io.out("KIND\tSTATUS\tEXIT\tMS\tCOMMAND\tDETAIL\n");
+    for (const r of summary.results) {
+        const exit = r.exitCode === null ? "-" : String(r.exitCode);
+        io.out(`${r.kind}\t${r.status}\t${exit}\t${String(r.durationMs)}\t${r.command}\t${r.detail ?? ""}\n`);
+    }
+}
+export async function runVerifyCli(args, io) {
+    const parsed = parseArgs(args);
+    if (parsed === null) {
+        io.err(USAGE);
+        return 2;
+    }
+    try {
+        const report = await runPlan(parsed);
+        if (parsed.json) {
+            io.out(`${JSON.stringify(buildVerificationSummary(report), null, 2)}\n`);
+        }
+        else {
+            renderText(report, io);
+        }
+        return report.overallStatus === "passed" ? 0 : 1;
+    }
+    catch (error) {
+        if (error instanceof WorkspaceError) {
+            io.err(`Error [${error.code}]: ${error.message}\n`);
+            return 1;
+        }
+        if (error instanceof VerificationError) {
+            io.err(`Error [${error.code}]: ${error.message}\n`);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/evaluations/fixtures/bug-investigation/happy-path.d.ts

@@ -0,0 +1,2 @@
+import type { EvaluationFixture } from "../../types.js";
+export declare const bugHappyPath: EvaluationFixture;