@oscharko-dev/keiko-verification 0.2.0

package/dist/orchestrator.js

@@ -0,0 +1,401 @@
+// 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 "@oscharko-dev/keiko-security";
+import { DEFAULT_COMMAND_RULES, DEFAULT_SANDBOX_POLICY, runCommand, } from "@oscharko-dev/keiko-tools";
+import { nodeSpawnFn } from "@oscharko-dev/keiko-tools/internal/exec";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+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 and the run's resolved network policy onto a #6 SandboxPolicy:
+// wall-time and output-size are enforced by runCommand. Memory is NOT a SandboxPolicy field — it is
+// handled by the SpawnFn-wrapper monitor, so it does not appear here. The network policy is resolved by
+// `resolveStepNetwork` from the run's enforcement mode and probed backend availability (ADR-0043); for
+// an enforced "none" run, runCommand wraps the spawn through keiko-sandbox and records the attestation,
+// which `buildAppliedLimits` reports honestly. The default mode resolves to "inherit", so existing
+// callers are unaffected.
+function policyForStep(limits, network) {
+    return {
+        ...DEFAULT_SANDBOX_POLICY,
+        maxOutputBytes: limits.maxOutputBytes,
+        defaultTimeoutMs: limits.wallTimeMs,
+        network,
+    };
+}
+// Pure resolution of a step's effective network policy from the run's enforcement mode and whether an
+// enforcing backend is available. The default mode ("inherit") and any step that does not declare
+// `network:"none"` always run with "inherit" — byte-identical to the historical orchestrator. Only an
+// explicit enforce-* mode on a `network:"none"` step requests enforcement; when no backend is available
+// it degrades honestly or fails closed per the mode.
+export function resolveStepNetwork(limits, mode, available) {
+    if (mode === "inherit") {
+        return { kind: "run", network: "inherit" };
+    }
+    if (limits.network !== "none") {
+        return { kind: "run", network: limits.network };
+    }
+    if (available) {
+        return { kind: "run", network: "none" };
+    }
+    return mode === "enforce-or-degrade"
+        ? { kind: "run", network: "inherit" }
+        : { kind: "fail-closed" };
+}
+// 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, network) {
+    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, network));
+        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, network) {
+    return {
+        workspace: deps.workspace,
+        policy: policyForStep(step.limits, network),
+        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",
+    };
+}
+// Honest network-enforcement reporting (ADR-0043 D4): the attestation is present only when this run
+// requested network:"none" and keiko-sandbox wrapped the spawn; an inherited-network run carries no
+// attestation, so this is false and the appliedLimits network row stays documented-not-enforced.
+function networkEnforcedOf(result) {
+    return result?.attestation?.networkEnforced ?? false;
+}
+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);
+    const networkEnforced = networkEnforcedOf(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, networkEnforced),
+        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 = [];
+    const mode = deps.networkEnforcement ?? "inherit";
+    const available = deps.enforcedNetworkAvailable ?? false;
+    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 resolution = resolveStepNetwork(step.limits, mode, available);
+        if (resolution.kind === "fail-closed") {
+            results.push(deniedResult(step, "network egress isolation required but no enforcing sandbox backend is available on this host; refusing to execute untrusted code"));
+            continue;
+        }
+        const result = toResult(step, await runStep(step, deps, baseSpawn, monitor, resolution.network));
+        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/plan.d.ts

@@ -0,0 +1,11 @@
+import { type WorkspaceFs, type WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+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 planDirectTargetedTests(workspace: WorkspaceInfo, testFiles: readonly string[], fs?: WorkspaceFs, limits?: VerificationResourceLimits): readonly VerificationStep[];
+export declare function buildVerificationPlan(workspace: WorkspaceInfo, catalog: ScriptCatalog, options?: PlanOptions, fs?: WorkspaceFs): VerificationPlan;
+//# sourceMappingURL=plan.d.ts.map

package/dist/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../src/plan.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAUpB,MAAM,WAAW,WAAW;IAE1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,CAAC;IAExD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,0BAA0B,CAAC,GAAG,SAAS,CAAC;IAElE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACvD;AA6FD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,EAAE,GAAE,WAA6B,EACjC,MAAM,GAAE,0BAAwD,GAC/D,SAAS,gBAAgB,EAAE,CAyB7B;AAQD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,aAAa,EACxB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,EAAE,GAAE,WAA6B,EACjC,MAAM,GAAE,0BAAwD,GAC/D,SAAS,gBAAgB,EAAE,CAuB7B;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,WAAgB,EACzB,EAAE,GAAE,WAA6B,GAChC,gBAAgB,CAYlB"}

package/dist/plan.js

@@ -0,0 +1,155 @@
+// 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 "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+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,
+        },
+    ];
+}
+// Builds a single targeted-test step that runs EXACTLY the given test files (Issue #1204 post-apply
+// verification), rather than deriving sibling test paths from changed source files. Each path is
+// validated to be a workspace-contained, existing file before it is included; an unknown test framework
+// or an empty resolved set yields no step (the caller then reports verification as skipped/not-run).
+// Used to re-confirm a just-applied generated test in place, isolated by the orchestrator's enforced
+// network policy.
+export function planDirectTargetedTests(workspace, testFiles, fs = nodeWorkspaceFs, limits = DEFAULT_VERIFICATION_LIMITS) {
+    const resolved = [];
+    for (const file of testFiles) {
+        if (existsInWorkspace(workspace, fs, file) && !resolved.includes(file)) {
+            resolved.push(file);
+        }
+    }
+    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/summary.d.ts

@@ -0,0 +1,7 @@
+import type { VerificationResultSummary, VerificationSummary, AuditResultEntry, VerificationAuditSummary } from "@oscharko-dev/keiko-contracts";
+export type { VerificationResultSummary, VerificationSummary, AuditResultEntry, VerificationAuditSummary, };
+import type { VerificationReport } from "./types.js";
+export declare function buildVerificationSummary(report: VerificationReport): VerificationSummary;
+export declare function summarizeForAudit(report: VerificationReport): VerificationAuditSummary;
+export declare function renderMarkdownSummary(report: VerificationReport): string;
+//# sourceMappingURL=summary.d.ts.map

package/dist/summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","sourceRoot":"","sources":["../src/summary.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,GACzB,CAAC;AAGF,OAAO,KAAK,EAAE,kBAAkB,EAA0C,MAAM,YAAY,CAAC;AAE7F,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,kBAAkB,GAAG,mBAAmB,CAoBxF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,wBAAwB,CAiBtF;AAoBD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAMxE"}

package/dist/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 "@oscharko-dev/keiko-security";
+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/types.d.ts

@@ -0,0 +1,3 @@
+export type { VerificationKind, VerificationStatus, ResourceDimension, ResourceLimitDecision, VerificationResourceLimits, VerificationStep, VerificationPlan, VerificationResult, VerificationReport, ScriptCatalog, ScriptMapping, } from "@oscharko-dev/keiko-contracts";
+export { DEFAULT_VERIFICATION_LIMITS } from "@oscharko-dev/keiko-contracts";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAIA,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,aAAa,GACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// Re-export shim: verification contract types and the frozen DEFAULT_VERIFICATION_LIMITS table
+// live in @oscharko-dev/keiko-contracts (issue #158). `verbatimModuleSyntax` is on, so type-only
+// names use `export type` and value-emitting frozen tables use `export`.
+export { DEFAULT_VERIFICATION_LIMITS } from "@oscharko-dev/keiko-contracts";