@oscharko-dev/keiko 0.1.0-beta.0

package/dist/verification/orchestrator.js

@@ -0,0 +1,363 @@
+// The verification orchestrator (ADR-0007 D2–D5). Runs each plan step sequentially through the
+// UNCHANGED #6 runCommand, applying per-command resource limits, honest appliedLimits, memory
+// monitoring via a SpawnFn wrapper + ResourceMonitor seam (never modifying src/tools), cross-step
+// cancellation, and a redacted output digest. Error handling lives only at this IO boundary; the
+// classification it feeds is pure.
+import { redact } from "../gateway/redaction.js";
+import { DEFAULT_COMMAND_RULES, DEFAULT_SANDBOX_POLICY, nodeSpawnFn, runCommand, } from "../tools/index.js";
+import { nodeWorkspaceFs } from "../workspace/fs.js";
+import { classifyOutcome } from "./classify.js";
+import { classifyScripts } from "./detect.js";
+import { buildAppliedLimits } from "./limits.js";
+import { nodeResourceMonitor } from "./monitor.js";
+// Verification runs deterministic repository gates selected by Keiko, not arbitrary model-issued
+// run_command calls. Keep the model-facing defaults read-only while allowing the verification
+// orchestrator to invoke npm scripts and framework-targeted npx runs through the same #6 boundary.
+export const VERIFICATION_COMMAND_RULES = Object.freeze([
+    {
+        executable: "npm",
+        allowedSubcommands: Object.freeze(["test", "run"]),
+        denyFlags: Object.freeze(["-c", "--call"]),
+    },
+    {
+        executable: "npx",
+        allowedSubcommands: Object.freeze(["vitest", "jest"]),
+        denyFlags: Object.freeze(["-c", "--call"]),
+    },
+    ...DEFAULT_COMMAND_RULES,
+]);
+const ALL_STATUSES = [
+    "passed",
+    "failed",
+    "skipped",
+    "denied",
+    "timed-out",
+    "cancelled",
+    "resource-exceeded",
+];
+// Maps a step's resource limits onto a #6 SandboxPolicy: wall-time and output-size are enforced by
+// runCommand; network is passed through (documented-not-enforced). Memory is NOT a SandboxPolicy
+// field — it is handled by the SpawnFn-wrapper monitor, so it does not appear here.
+function policyForStep(limits) {
+    return {
+        ...DEFAULT_SANDBOX_POLICY,
+        maxOutputBytes: limits.maxOutputBytes,
+        defaultTimeoutMs: limits.wallTimeMs,
+        network: limits.network,
+    };
+}
+// Data-minimal output metadata. #6 already redacts/caps each stream, but regulated CLI/SDK
+// summaries should not echo arbitrary repository logs or customer data by default.
+function outputDigest(result) {
+    if (result === undefined) {
+        return "";
+    }
+    const combined = `${result.stdout}${result.stderr}`;
+    if (combined.length === 0) {
+        return "";
+    }
+    if (result.truncated) {
+        return "command output exceeded the configured output-size limit and was omitted";
+    }
+    const bytes = Buffer.byteLength(combined, "utf8");
+    return `command output captured (${String(bytes)} bytes) and omitted from summary`;
+}
+// Derives which single dimension tripped, so exactly one appliedLimits row is breached:true.
+function breachedDimension(status, abortReason, result) {
+    if (abortReason === "memory") {
+        return "memory";
+    }
+    if (status === "timed-out") {
+        return "wall-time";
+    }
+    if (status === "resource-exceeded" && result?.truncated === true) {
+        return "output-size";
+    }
+    return undefined;
+}
+function deniedResult(step, reason) {
+    return {
+        kind: step.kind,
+        scriptName: step.scriptName,
+        command: step.command,
+        args: step.args,
+        status: "denied",
+        exitCode: null,
+        signal: null,
+        durationMs: 0,
+        truncated: false,
+        redacted: true,
+        outputSummary: "",
+        appliedLimits: buildAppliedLimits(step.limits, undefined),
+        detail: redact(reason),
+    };
+}
+function isGeneratedSkipShape(step) {
+    return (step.kind !== "targeted-test" &&
+        step.skipReason !== undefined &&
+        step.scriptName === undefined &&
+        step.command === "npm" &&
+        step.args.length === 2 &&
+        step.args[0] === "run" &&
+        step.args[1] === step.kind);
+}
+function hasWindowsDrivePrefix(value) {
+    return value.length >= 2 && value[1] === ":";
+}
+function isGeneratedTargetPath(value) {
+    if (value.length === 0 ||
+        value.startsWith("-") ||
+        value.startsWith("/") ||
+        value.includes("\u0000") ||
+        hasWindowsDrivePrefix(value)) {
+        return false;
+    }
+    return value
+        .split("\\")
+        .join("/")
+        .split("/")
+        .every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function scriptNameMatchesKind(step) {
+    if (step.kind === "targeted-test" || step.scriptName === undefined) {
+        return false;
+    }
+    return classifyScripts({ [step.scriptName]: "" })[step.kind] === step.scriptName;
+}
+function isValidTargetedStep(step) {
+    if (step.scriptName !== undefined || step.command !== "npx" || step.args.length < 2) {
+        return false;
+    }
+    if (step.args[0] === "vitest") {
+        return (step.args[1] === "run" &&
+            step.args.length >= 3 &&
+            step.args.slice(2).every(isGeneratedTargetPath));
+    }
+    if (step.args[0] === "jest") {
+        return step.args.length >= 2 && step.args.slice(1).every(isGeneratedTargetPath);
+    }
+    return false;
+}
+function isValidTestStep(step) {
+    if (step.kind === "test") {
+        if (step.scriptName === "test") {
+            return step.args.length === 1 && step.args[0] === "test";
+        }
+        return (scriptNameMatchesKind(step) &&
+            step.args.length === 2 &&
+            step.args[0] === "run" &&
+            step.args[1] === step.scriptName);
+    }
+    return false;
+}
+function isValidScriptStep(step) {
+    if (step.command !== "npm") {
+        return false;
+    }
+    if (step.kind === "test") {
+        return isValidTestStep(step);
+    }
+    if (!scriptNameMatchesKind(step)) {
+        return false;
+    }
+    return step.args.length === 2 && step.args[0] === "run" && step.args[1] === step.scriptName;
+}
+function isValidVerificationStep(step) {
+    if (isGeneratedSkipShape(step)) {
+        return true;
+    }
+    return step.kind === "targeted-test" ? isValidTargetedStep(step) : isValidScriptStep(step);
+}
+// Runs one command step through #6, wrapping the base SpawnFn with the memory monitor and owning
+// the AbortController. The monitor's unwatch runs in `finally` on EVERY settle path (resolve,
+// reject, denied-before-spawn where stop is never set, or a throwing await), so the sampling
+// interval can never leak (ADR-0007 D3).
+async function runStep(step, deps, baseSpawn, monitor) {
+    const now = deps.now ?? Date.now;
+    const startedAt = now();
+    let abortReason;
+    const ac = new AbortController();
+    const onHarnessAbort = () => {
+        abortReason ??= "harness";
+        ac.abort();
+    };
+    deps.signal?.addEventListener("abort", onHarnessAbort, { once: true });
+    let stop;
+    const spawn = (cmd, args, opts) => {
+        const child = baseSpawn(cmd, args, opts);
+        stop = monitor.watch(child.pid, step.limits.maxMemoryBytes, () => {
+            abortReason ??= "memory";
+            ac.abort();
+        });
+        return child;
+    };
+    try {
+        const result = await runCommand({
+            command: step.command,
+            args: step.args,
+            cwd: undefined,
+            timeoutMs: step.limits.wallTimeMs,
+            signal: ac.signal,
+        }, buildRunDeps(deps, step, spawn));
+        return { result, error: undefined, abortReason, durationMs: result.durationMs };
+    }
+    catch (error) {
+        return { result: undefined, error, abortReason, durationMs: now() - startedAt };
+    }
+    finally {
+        stop?.();
+        deps.signal?.removeEventListener("abort", onHarnessAbort);
+    }
+}
+function buildRunDeps(deps, step, spawn) {
+    return {
+        workspace: deps.workspace,
+        policy: policyForStep(step.limits),
+        commandRules: VERIFICATION_COMMAND_RULES,
+        spawn,
+        processEnv: deps.processEnv ?? process.env,
+        now: deps.now ?? Date.now,
+        fs: deps.fs ?? nodeWorkspaceFs,
+    };
+}
+function skippedResult(step) {
+    return {
+        kind: step.kind,
+        scriptName: step.scriptName,
+        command: step.command,
+        args: step.args,
+        status: "skipped",
+        exitCode: null,
+        signal: null,
+        durationMs: 0,
+        truncated: false,
+        redacted: true,
+        outputSummary: "",
+        appliedLimits: buildAppliedLimits(step.limits, undefined),
+        detail: redact(step.skipReason ?? "skipped"),
+    };
+}
+function cancelledResult(step) {
+    return {
+        kind: step.kind,
+        scriptName: step.scriptName,
+        command: step.command,
+        args: step.args,
+        status: "cancelled",
+        exitCode: null,
+        signal: null,
+        durationMs: 0,
+        truncated: false,
+        redacted: true,
+        outputSummary: "",
+        appliedLimits: buildAppliedLimits(step.limits, undefined),
+        detail: "cancelled before execution",
+    };
+}
+function toResult(step, run) {
+    const status = classifyOutcome({
+        skipped: false,
+        result: run.result,
+        error: run.error,
+        abortReason: run.abortReason,
+    });
+    const breached = breachedDimension(status, run.abortReason, run.result);
+    return {
+        kind: step.kind,
+        scriptName: step.scriptName,
+        command: step.command,
+        args: step.args,
+        status,
+        exitCode: run.result?.exitCode ?? null,
+        signal: run.result?.signal ?? null,
+        durationMs: run.result?.durationMs ?? run.durationMs,
+        truncated: run.result?.truncated ?? false,
+        redacted: true,
+        outputSummary: outputDigest(run.result),
+        appliedLimits: buildAppliedLimits(step.limits, breached),
+        detail: detailFor(status, run),
+    };
+}
+function detailFor(status, run) {
+    if (run.abortReason === "memory") {
+        return "memory ceiling exceeded";
+    }
+    // For denied/failed paths the rejection message (already a redacted Error from #6 for denied)
+    // is re-redacted here as defence in depth before it reaches the report.
+    if ((status === "denied" || status === "failed") && run.error instanceof Error) {
+        return redact(run.error.message);
+    }
+    return undefined;
+}
+function overallStatus(results, cancelled) {
+    if (cancelled) {
+        return "cancelled";
+    }
+    const allOk = results.every((r) => r.status === "passed" || r.status === "skipped");
+    return allOk ? "passed" : "failed";
+}
+function countByStatus(results) {
+    const counts = Object.fromEntries(ALL_STATUSES.map((s) => [s, 0]));
+    for (const r of results) {
+        counts[r.status] += 1;
+    }
+    return counts;
+}
+function finishReport(workspaceRoot, results, cancelled, startedAtMs, now) {
+    return {
+        workspaceRoot,
+        results,
+        overallStatus: overallStatus(results, cancelled),
+        startedAtMs,
+        durationMs: now() - startedAtMs,
+        counts: countByStatus(results),
+    };
+}
+function rootMismatchReport(plan, workspaceRoot, startedAtMs, now) {
+    const results = plan.steps.map((step) => deniedResult(step, "verification plan rejected: workspace root mismatch"));
+    return finishReport(workspaceRoot, results, false, startedAtMs, now);
+}
+function preExecutionResult(step, cancelled, signal) {
+    if (!isValidVerificationStep(step)) {
+        return {
+            result: deniedResult(step, "verification plan rejected: unsupported step shape"),
+            cancelled,
+        };
+    }
+    if (cancelled) {
+        return { result: cancelledResult(step), cancelled };
+    }
+    if (step.skipReason !== undefined) {
+        return { result: skippedResult(step), cancelled };
+    }
+    if (signal?.aborted === true) {
+        return { result: cancelledResult(step), cancelled: true };
+    }
+    return undefined;
+}
+async function runPlanSteps(plan, deps, baseSpawn, monitor) {
+    const results = [];
+    let cancelled = false;
+    for (const step of plan.steps) {
+        const early = preExecutionResult(step, cancelled, deps.signal);
+        if (early !== undefined) {
+            results.push(early.result);
+            cancelled = early.cancelled;
+            continue;
+        }
+        const result = toResult(step, await runStep(step, deps, baseSpawn, monitor));
+        results.push(result);
+        cancelled ||= result.status === "cancelled";
+    }
+    return { results, cancelled };
+}
+export async function runVerification(plan, deps) {
+    const now = deps.now ?? Date.now;
+    const startedAtMs = now();
+    const workspaceRoot = deps.workspace.root;
+    if (plan.workspaceRoot !== workspaceRoot) {
+        return rootMismatchReport(plan, workspaceRoot, startedAtMs, now);
+    }
+    const { results, cancelled } = await runPlanSteps(plan, deps, deps.spawn ?? nodeSpawnFn, deps.monitor ?? nodeResourceMonitor);
+    return finishReport(workspaceRoot, results, cancelled, startedAtMs, now);
+}

package/dist/verification/plan.d.ts

@@ -0,0 +1,9 @@
+import { type WorkspaceFs, type WorkspaceInfo } from "../workspace/index.js";
+import { type ScriptCatalog, type VerificationKind, type VerificationPlan, type VerificationResourceLimits, type VerificationStep } from "./types.js";
+export interface PlanOptions {
+    readonly only?: readonly VerificationKind[] | undefined;
+    readonly limits?: Partial<VerificationResourceLimits> | undefined;
+    readonly changedFiles?: readonly string[] | undefined;
+}
+export declare function resolveTargetedTests(workspace: WorkspaceInfo, changedFiles: readonly string[], fs?: WorkspaceFs, limits?: VerificationResourceLimits): readonly VerificationStep[];
+export declare function buildVerificationPlan(workspace: WorkspaceInfo, catalog: ScriptCatalog, options?: PlanOptions, fs?: WorkspaceFs): VerificationPlan;

package/dist/verification/plan.js

@@ -0,0 +1,125 @@
+// Plan construction: turns a detected ScriptCatalog into an ordered VerificationPlan, and resolves
+// targeted-test steps from a changed-file set. All path handling goes through the workspace
+// boundary (resolveWithinWorkspace + WorkspaceFs.exists); no raw node:fs. Candidate test-path
+// derivation uses plain string ops (no regex), so there is no ReDoS surface.
+import { basename, dirname, extname, join, relative } from "node:path";
+import { resolveWithinWorkspace, } from "../workspace/index.js";
+import { nodeWorkspaceFs } from "../workspace/fs.js";
+import { DEFAULT_VERIFICATION_LIMITS, } from "./types.js";
+// The script-backed kinds, in run order. `targeted-test` is synthesised, not script-backed.
+const SCRIPT_KINDS = [
+    "typecheck",
+    "lint",
+    "test",
+    "build",
+];
+function resolveLimits(overrides) {
+    return { ...DEFAULT_VERIFICATION_LIMITS, ...overrides };
+}
+function scriptStep(kind, scriptName, limits) {
+    if (scriptName === undefined) {
+        return {
+            kind,
+            scriptName: undefined,
+            command: "npm",
+            args: ["run", kind],
+            limits,
+            skipReason: `no ${kind} script detected in package.json`,
+        };
+    }
+    // `npm test` has a dedicated subcommand; every other kind runs via `npm run <script>`.
+    const args = scriptName === "test" ? ["test"] : ["run", scriptName];
+    return { kind, scriptName, command: "npm", args, limits };
+}
+function wants(only, kind) {
+    return only === undefined || only.includes(kind);
+}
+// Derives candidate test paths for a changed source file: a sibling `X.test.ts`/`X.spec.ts`
+// (and .tsx/.js/.jsx variants), and the same basename mirrored under each configured testDir.
+function candidateTestPaths(workspace, file) {
+    const ext = extname(file);
+    if (ext === "") {
+        return [];
+    }
+    const dir = dirname(file);
+    const stem = basename(file, ext);
+    const suffixes = [".test", ".spec"];
+    const siblings = suffixes.map((s) => join(dir, `${stem}${s}${ext}`));
+    const sourceSubdir = sourceRelativeDir(workspace, file);
+    const mirrored = workspace.testDirs.flatMap((testDir) => suffixes.map((s) => join(testDir, sourceSubdir, `${stem}${s}${ext}`)));
+    return [...siblings, ...mirrored];
+}
+function sourceRelativeDir(workspace, file) {
+    const dir = dirname(file);
+    for (const sourceDir of workspace.sourceDirs) {
+        const rel = relative(sourceDir, dir);
+        if (rel === "") {
+            return "";
+        }
+        if (!rel.startsWith("..") && !rel.startsWith("/") && !rel.includes(":")) {
+            return rel;
+        }
+    }
+    return dir === "." ? "" : dir;
+}
+function existsInWorkspace(workspace, fs, relPath) {
+    try {
+        const abs = resolveWithinWorkspace(workspace.root, relPath);
+        return fs.exists(abs);
+    }
+    catch {
+        // A path that escapes the workspace is simply not a resolvable target; skip it.
+        return false;
+    }
+}
+// Builds the framework-appropriate invocation that runs ONLY the given test files. vitest and jest
+// both accept positional file paths. Returns undefined for an unknown framework, so no targeted
+// step is added rather than guessing. The `npx <runner> ...` shape passes the #6 allowlist.
+function targetedInvocation(workspace, files) {
+    if (workspace.testFramework === "vitest") {
+        return { command: "npx", args: ["vitest", "run", ...files] };
+    }
+    if (workspace.testFramework === "jest") {
+        return { command: "npx", args: ["jest", ...files] };
+    }
+    return undefined;
+}
+export function resolveTargetedTests(workspace, changedFiles, fs = nodeWorkspaceFs, limits = DEFAULT_VERIFICATION_LIMITS) {
+    const resolved = [];
+    for (const file of changedFiles) {
+        for (const candidate of candidateTestPaths(workspace, file)) {
+            if (existsInWorkspace(workspace, fs, candidate) && !resolved.includes(candidate)) {
+                resolved.push(candidate);
+            }
+        }
+    }
+    if (resolved.length === 0) {
+        return [];
+    }
+    const invocation = targetedInvocation(workspace, resolved);
+    if (invocation === undefined) {
+        return [];
+    }
+    return [
+        {
+            kind: "targeted-test",
+            scriptName: undefined,
+            command: invocation.command,
+            args: invocation.args,
+            limits,
+        },
+    ];
+}
+export function buildVerificationPlan(workspace, catalog, options = {}, fs = nodeWorkspaceFs) {
+    const limits = resolveLimits(options.limits);
+    const steps = [];
+    for (const kind of SCRIPT_KINDS) {
+        if (wants(options.only, kind)) {
+            steps.push(scriptStep(kind, catalog.mapping[kind], limits));
+        }
+    }
+    if (wants(options.only, "targeted-test") && options.changedFiles !== undefined) {
+        steps.push(...resolveTargetedTests(workspace, options.changedFiles, fs, limits));
+    }
+    return { workspaceRoot: workspace.root, steps };
+}

package/dist/verification/summary.d.ts

@@ -0,0 +1,40 @@
+import type { ResourceLimitDecision, VerificationReport, VerificationResult, VerificationStatus } from "./types.js";
+export interface VerificationResultSummary {
+    readonly kind: VerificationResult["kind"];
+    readonly scriptName: string | undefined;
+    readonly command: string;
+    readonly status: VerificationStatus;
+    readonly exitCode: number | null;
+    readonly durationMs: number;
+    readonly truncated: boolean;
+    readonly outputSummary: string;
+    readonly appliedLimits: readonly ResourceLimitDecision[];
+    readonly detail: string | undefined;
+}
+export interface VerificationSummary {
+    readonly workspaceRoot: string;
+    readonly overallStatus: VerificationStatus;
+    readonly durationMs: number;
+    readonly counts: Readonly<Record<VerificationStatus, number>>;
+    readonly results: readonly VerificationResultSummary[];
+}
+export interface AuditResultEntry {
+    readonly kind: VerificationResult["kind"];
+    readonly scriptName: string | undefined;
+    readonly command: string;
+    readonly status: VerificationStatus;
+    readonly exitCode: number | null;
+    readonly durationMs: number;
+    readonly truncated: boolean;
+    readonly appliedLimits: readonly ResourceLimitDecision[];
+}
+export interface VerificationAuditSummary {
+    readonly workspaceRoot: string;
+    readonly overallStatus: VerificationStatus;
+    readonly durationMs: number;
+    readonly counts: Readonly<Record<VerificationStatus, number>>;
+    readonly results: readonly AuditResultEntry[];
+}
+export declare function buildVerificationSummary(report: VerificationReport): VerificationSummary;
+export declare function summarizeForAudit(report: VerificationReport): VerificationAuditSummary;
+export declare function renderMarkdownSummary(report: VerificationReport): string;

package/dist/verification/summary.js

@@ -0,0 +1,67 @@
+// The render surfaces over a VerificationReport (ADR-0007). buildVerificationSummary is the
+// structured CLI/SDK view (keeps the redacted output digest); summarizeForAudit is the audit-ledger
+// projection that EXCLUDES raw output text (mirroring ADR-0005 audit excerpt-exclusion), keeping
+// only status/exit/duration/appliedLimits/counts; renderMarkdownSummary is a PR/issue table. Every
+// composed string is run through redact() so nothing a summary emits can leak a secret. Pure — no IO.
+import { redact } from "../gateway/redaction.js";
+export function buildVerificationSummary(report) {
+    return {
+        workspaceRoot: report.workspaceRoot,
+        overallStatus: report.overallStatus,
+        durationMs: report.durationMs,
+        counts: report.counts,
+        results: report.results.map((r) => ({
+            kind: r.kind,
+            scriptName: r.scriptName,
+            command: redact(`${r.command} ${r.args.join(" ")}`.trim()),
+            status: r.status,
+            exitCode: r.exitCode,
+            durationMs: r.durationMs,
+            truncated: r.truncated,
+            // r.outputSummary is already redacted at the orchestrator; re-redact as defence in depth.
+            outputSummary: redact(r.outputSummary),
+            appliedLimits: r.appliedLimits,
+            detail: r.detail === undefined ? undefined : redact(r.detail),
+        })),
+    };
+}
+export function summarizeForAudit(report) {
+    return {
+        workspaceRoot: report.workspaceRoot,
+        overallStatus: report.overallStatus,
+        durationMs: report.durationMs,
+        counts: report.counts,
+        results: report.results.map((r) => ({
+            kind: r.kind,
+            scriptName: r.scriptName,
+            command: redact(`${r.command} ${r.args.join(" ")}`.trim()),
+            status: r.status,
+            exitCode: r.exitCode,
+            durationMs: r.durationMs,
+            truncated: r.truncated,
+            appliedLimits: r.appliedLimits,
+        })),
+    };
+}
+function statusMark(status) {
+    if (status === "passed") {
+        return "pass";
+    }
+    if (status === "skipped") {
+        return "skip";
+    }
+    return "FAIL";
+}
+function markdownRow(result) {
+    const cmd = redact(`${result.command} ${result.args.join(" ")}`.trim());
+    const detail = result.detail === undefined ? "" : redact(result.detail);
+    const exit = result.exitCode === null ? "—" : String(result.exitCode);
+    return `| ${result.kind} | ${result.status} | ${exit} | ${String(result.durationMs)} | \`${cmd}\` | ${detail} |`;
+}
+// A PR/issue Markdown table. Every cell that can carry command-derived text is redacted.
+export function renderMarkdownSummary(report) {
+    const header = `### Verification: ${statusMark(report.overallStatus)} (${report.overallStatus})`;
+    const tableHead = "| Kind | Status | Exit | ms | Command | Detail |\n| --- | --- | --- | --- | --- | --- |";
+    const rows = report.results.map(markdownRow).join("\n");
+    return `${header}\n\n${tableHead}\n${rows}\n`;
+}

package/dist/verification/types.d.ts

@@ -0,0 +1,63 @@
+import type { NetworkPolicy } from "../tools/types.js";
+export type VerificationKind = "test" | "targeted-test" | "typecheck" | "lint" | "build";
+export type VerificationStatus = "passed" | "failed" | "skipped" | "denied" | "timed-out" | "cancelled" | "resource-exceeded";
+export type ResourceDimension = "wall-time" | "output-size" | "memory" | "network";
+export interface ResourceLimitDecision {
+    readonly dimension: ResourceDimension;
+    readonly limit: number | string;
+    readonly enforced: boolean;
+    readonly note?: string | undefined;
+    readonly breached?: boolean | undefined;
+}
+export interface VerificationResourceLimits {
+    readonly wallTimeMs: number;
+    readonly maxOutputBytes: number;
+    readonly maxMemoryBytes: number | undefined;
+    readonly network: NetworkPolicy;
+}
+export declare const DEFAULT_VERIFICATION_LIMITS: VerificationResourceLimits;
+export interface VerificationStep {
+    readonly kind: VerificationKind;
+    readonly scriptName: string | undefined;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly limits: VerificationResourceLimits;
+    readonly skipReason?: string | undefined;
+}
+export interface VerificationPlan {
+    readonly workspaceRoot: string;
+    readonly steps: readonly VerificationStep[];
+}
+export interface VerificationResult {
+    readonly kind: VerificationKind;
+    readonly scriptName: string | undefined;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly status: VerificationStatus;
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly durationMs: number;
+    readonly truncated: boolean;
+    readonly redacted: boolean;
+    readonly outputSummary: string;
+    readonly appliedLimits: readonly ResourceLimitDecision[];
+    readonly detail?: string | undefined;
+}
+export interface VerificationReport {
+    readonly workspaceRoot: string;
+    readonly results: readonly VerificationResult[];
+    readonly overallStatus: VerificationStatus;
+    readonly startedAtMs: number;
+    readonly durationMs: number;
+    readonly counts: Readonly<Record<VerificationStatus, number>>;
+}
+export interface ScriptCatalog {
+    readonly scripts: Readonly<Record<string, string>>;
+    readonly mapping: ScriptMapping;
+}
+export interface ScriptMapping {
+    readonly test: string | undefined;
+    readonly typecheck: string | undefined;
+    readonly lint: string | undefined;
+    readonly build: string | undefined;
+}

package/dist/verification/types.js

@@ -0,0 +1,13 @@
+// All verification-layer interfaces and the frozen default limits. No runtime logic lives here
+// beyond the frozen constant tables the type layer exposes as values, mirroring the
+// ADR-0003/0004/0005/0006 `types.ts` precedent. `readonly` everywhere; optional props are
+// `| undefined` because exactOptionalPropertyTypes is on. Every shape is plain JSON-serializable
+// so the #10 audit ledger can persist a VerificationReport without ad-hoc parsing.
+// Wave-1 defaults. maxMemoryBytes is undefined by default: memory enforcement is opt-in and
+// Linux-only (ADR-0007 D2/D3). network defaults to the no-network posture, documented-not-enforced.
+export const DEFAULT_VERIFICATION_LIMITS = {
+    wallTimeMs: 120_000,
+    maxOutputBytes: 1_048_576,
+    maxMemoryBytes: undefined,
+    network: "none",
+};