@oscharko-dev/keiko 0.1.6 → 0.1.7

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/detect.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceFs, WorkspaceInfo } from "../workspace/index.js";
+import type { ScriptCatalog, ScriptMapping } from "./types.js";
+export declare function classifyScripts(scripts: Readonly<Record<string, string>>): ScriptMapping;
+export declare function detectScripts(workspace: WorkspaceInfo, fs?: WorkspaceFs): ScriptCatalog;
+//# sourceMappingURL=detect.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../../../src/verification/detect.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAkE/D,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,aAAa,CAQxF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,aAAa,EAAE,EAAE,CAAC,EAAE,WAAW,GAAG,aAAa,CAevF"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/detect.js

@@ -0,0 +1,81 @@
+// npm-script detection and kind classification. Reads package.json through the workspace
+// WorkspaceFs boundary (never raw node:fs), mirroring the parseScripts approach in
+// src/tools/registry.ts but adding the kind-mapping layer the plan consumes.
+//
+// All name matching is done with plain substring/equality checks (no regex), so there is no
+// ReDoS surface at all (CodeQL js/polynomial-redos). Script NAMES are matched, never values.
+import { readWorkspaceFile } from "../workspace/index.js";
+// package.json is small; this cap is generous and prevents reading a pathological file.
+const PACKAGE_READ_BYTES = 262_144;
+function parseScripts(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        // A malformed package.json yields no scripts rather than throwing: detection is best-effort
+        // and the plan will mark every kind skipped, which is a visible, testable outcome (D4).
+        return {};
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return {};
+    }
+    const scripts = parsed.scripts;
+    if (typeof scripts !== "object" || scripts === null) {
+        return {};
+    }
+    const out = {};
+    for (const [name, value] of Object.entries(scripts)) {
+        if (typeof value === "string") {
+            out[name] = value;
+        }
+    }
+    return out;
+}
+// Returns the first script name whose lowercased name satisfies `match`, preferring an exact-name
+// hit over a substring hit so `test` wins over `pretest`/`test:watch` for the test kind.
+function pickScript(names, exact, contains) {
+    for (const name of names) {
+        if (exact.includes(name.toLowerCase())) {
+            return name;
+        }
+    }
+    for (const name of names) {
+        const lower = name.toLowerCase();
+        if (contains.some((needle) => lower.includes(needle)) &&
+            !contains.some((needle) => isLifecycleWrapper(lower, needle))) {
+            return name;
+        }
+    }
+    return undefined;
+}
+function isLifecycleWrapper(lowerName, needle) {
+    return (lowerName === `pre${needle}` ||
+        lowerName === `post${needle}` ||
+        lowerName.startsWith(`pre${needle}:`) ||
+        lowerName.startsWith(`post${needle}:`));
+}
+// Maps script names to verification kinds via conventional heuristics. Exact-name matches win;
+// otherwise a substring of the lowercased name. `typecheck`/`type-check`/`tsc` → typecheck;
+// `lint`/`eslint` → lint; `build` → build; `test` → test.
+export function classifyScripts(scripts) {
+    const names = Object.keys(scripts);
+    return {
+        test: pickScript(names, ["test"], ["test"]),
+        typecheck: pickScript(names, ["typecheck", "type-check", "tsc"], ["typecheck", "type-check"]),
+        lint: pickScript(names, ["lint"], ["lint", "eslint"]),
+        build: pickScript(names, ["build"], ["build"]),
+    };
+}
+export function detectScripts(workspace, fs) {
+    let scripts;
+    try {
+        const content = readWorkspaceFile(workspace, "package.json", { maxBytes: PACKAGE_READ_BYTES }, fs);
+        scripts = parseScripts(content.text);
+    }
+    catch {
+        // No package.json or an unreadable one: no scripts detected. The plan marks kinds skipped (D4).
+        scripts = {};
+    }
+    return { scripts, mapping: classifyScripts(scripts) };
+}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/errors.d.ts

@@ -0,0 +1,3 @@
+export { VERIFICATION_CODES, VerificationError, EmptyPlanError, } from "@oscharko-dev/keiko-security/errors/verification";
+export type { VerificationCode } from "@oscharko-dev/keiko-security/errors/verification";
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/verification/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,GACf,MAAM,kDAAkD,CAAC;AAC1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/errors.js

@@ -0,0 +1,4 @@
+// Re-export shim: the verification error taxonomy now lives in @oscharko-dev/keiko-security
+// (issue #159, ADR-0019). All existing import sites (`from "./errors.js"`) keep resolving
+// unchanged via this barrel.
+export { VERIFICATION_CODES, VerificationError, EmptyPlanError, } from "@oscharko-dev/keiko-security/errors/verification";

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/index.d.ts

@@ -0,0 +1,18 @@
+export type { ResourceDimension, ResourceLimitDecision, ScriptCatalog, ScriptMapping, VerificationKind, VerificationPlan, VerificationReport, VerificationResourceLimits, VerificationResult, VerificationStatus, VerificationStep, } from "./types.js";
+export { DEFAULT_VERIFICATION_LIMITS } from "./types.js";
+export { VERIFICATION_CODES, VerificationError, EmptyPlanError } from "./errors.js";
+export type { VerificationCode } from "./errors.js";
+export { classifyScripts, detectScripts } from "./detect.js";
+export { classifyOutcome } from "./classify.js";
+export type { AbortReason, OutcomeInput } from "./classify.js";
+export { buildVerificationPlan, resolveTargetedTests } from "./plan.js";
+export type { PlanOptions } from "./plan.js";
+export { nodeResourceMonitor } from "./monitor.js";
+export type { ResourceMonitor } from "./monitor.js";
+export { buildAppliedLimits } from "./limits.js";
+export type { BreachedDimension } from "./limits.js";
+export { runVerification } from "./orchestrator.js";
+export type { VerificationDeps } from "./orchestrator.js";
+export { buildVerificationSummary, renderMarkdownSummary, summarizeForAudit } from "./summary.js";
+export type { AuditResultEntry, VerificationAuditSummary, VerificationResultSummary, VerificationSummary, } from "./summary.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/verification/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACpF,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACxE,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClG,YAAY,EACV,gBAAgB,EAChB,wBAAwB,EACxB,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,cAAc,CAAC"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/index.js

@@ -0,0 +1,13 @@
+// Public barrel for the verification orchestrator layer (ADR-0007). Verification reuses the #6
+// command boundary unchanged; this layer adds plan construction, per-command resource limits,
+// best-effort memory monitoring, classified+redacted evidence, and audit/CLI/Markdown surfaces.
+// Explicit named re-exports, `type` keyword for type-only, double quotes, `.js`.
+export { DEFAULT_VERIFICATION_LIMITS } from "./types.js";
+export { VERIFICATION_CODES, VerificationError, EmptyPlanError } from "./errors.js";
+export { classifyScripts, detectScripts } from "./detect.js";
+export { classifyOutcome } from "./classify.js";
+export { buildVerificationPlan, resolveTargetedTests } from "./plan.js";
+export { nodeResourceMonitor } from "./monitor.js";
+export { buildAppliedLimits } from "./limits.js";
+export { runVerification } from "./orchestrator.js";
+export { buildVerificationSummary, renderMarkdownSummary, summarizeForAudit } from "./summary.js";

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/limits.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceLimitDecision, VerificationResourceLimits } from "./types.js";
+export type BreachedDimension = "wall-time" | "output-size" | "memory" | undefined;
+export declare function buildAppliedLimits(limits: VerificationResourceLimits, breached: BreachedDimension): readonly ResourceLimitDecision[];
+//# sourceMappingURL=limits.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../../../../src/verification/limits.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAGpF,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AASnF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,0BAA0B,EAClC,QAAQ,EAAE,iBAAiB,GAC1B,SAAS,qBAAqB,EAAE,CA8BlC"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/limits.js

@@ -0,0 +1,40 @@
+// Builds the four-dimension appliedLimits record for a step (ADR-0007 D2), with HONEST `enforced`
+// flags: wall-time and output-size are enforced by #6; memory is enforced only on Linux with a
+// ceiling set; network is documented-not-OS-enforced in Wave 1. `breached` is set only on the
+// single dimension that actually fired for the step. Pure — no IO.
+const NETWORK_NOTE = "documented; OS-level isolation deferred to container wave (ADR-0006)";
+const MEMORY_OFF_NOTE = "best-effort; Linux /proc sampler only — not enforced on this run";
+function memoryEnforced(limits) {
+    return process.platform === "linux" && limits.maxMemoryBytes !== undefined;
+}
+export function buildAppliedLimits(limits, breached) {
+    const memEnforced = memoryEnforced(limits);
+    return [
+        {
+            dimension: "wall-time",
+            limit: limits.wallTimeMs,
+            enforced: true,
+            breached: breached === "wall-time" ? true : undefined,
+        },
+        {
+            dimension: "output-size",
+            limit: limits.maxOutputBytes,
+            enforced: true,
+            breached: breached === "output-size" ? true : undefined,
+        },
+        {
+            dimension: "memory",
+            limit: limits.maxMemoryBytes ?? 0,
+            enforced: memEnforced,
+            note: memEnforced ? undefined : MEMORY_OFF_NOTE,
+            breached: breached === "memory" ? true : undefined,
+        },
+        {
+            dimension: "network",
+            limit: limits.network,
+            enforced: false,
+            note: NETWORK_NOTE,
+            breached: undefined,
+        },
+    ];
+}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/monitor.d.ts

@@ -0,0 +1,5 @@
+export interface ResourceMonitor {
+    readonly watch: (pid: number | undefined, maxBytes: number | undefined, onBreach: () => void) => () => void;
+}
+export declare const nodeResourceMonitor: ResourceMonitor;
+//# sourceMappingURL=monitor.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../../../../../src/verification/monitor.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,eAAe;IAE9B,QAAQ,CAAC,KAAK,EAAE,CACd,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,MAAM,IAAI,KACjB,MAAM,IAAI,CAAC;CACjB;AAiCD,eAAO,MAAM,mBAAmB,EAAE,eAkBjC,CAAC"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/monitor.js

@@ -0,0 +1,58 @@
+// The ResourceMonitor seam and its Node adapter (ADR-0007 D3). The orchestrator wraps the injected
+// SpawnFn and calls watch(pid, maxBytes, onBreach) on the spawned child; the returned function
+// clears the interval. This is the swap point the container wave replaces with a cgroup sampler.
+//
+// nodeResourceMonitor reads /proc/<pid>/status VmRSS — a SYSTEM path, not workspace content — so
+// it uses raw node:fs (read-only, bounded, no secrets), NOT WorkspaceFs. VmRSS is reported by the
+// kernel directly in kB, making it page-size-independent (correct on aarch64 with 16/64 KiB pages).
+// On non-Linux, or when maxBytes is undefined, watch is a documented no-op and the memory dimension
+// is recorded enforced:false.
+import { readFileSync } from "node:fs";
+const SAMPLE_INTERVAL_MS = 250;
+const NO_OP = () => {
+    // Documented no-op: nothing to unwatch when monitoring is disabled or unavailable.
+};
+// Reads resident-set bytes from /proc/<pid>/status (VmRSS line). The kernel reports VmRSS
+// directly in kB, so the result is page-size-independent. Returns undefined when the file is
+// gone (process exited), when VmRSS is absent (zombie), or on any parse failure — so a transient
+// read race or zombie process is never treated as a breach.
+function readRssBytes(pid) {
+    let raw;
+    try {
+        raw = readFileSync(`/proc/${String(pid)}/status`, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("VmRSS:")) {
+            const parts = line.split(/\s+/);
+            // Expected format: "VmRSS:    1234 kB"  → parts = ["VmRSS:", "1234", "kB"]
+            const kb = Number.parseInt(parts[1] ?? "", 10);
+            if (!Number.isFinite(kb)) {
+                return undefined;
+            }
+            return kb * 1_024;
+        }
+    }
+    return undefined;
+}
+export const nodeResourceMonitor = {
+    watch: (pid, maxBytes, onBreach) => {
+        if (process.platform !== "linux" || maxBytes === undefined || pid === undefined) {
+            return NO_OP;
+        }
+        let fired = false;
+        const timer = setInterval(() => {
+            const rss = readRssBytes(pid);
+            if (rss !== undefined && rss > maxBytes && !fired) {
+                fired = true;
+                onBreach();
+            }
+        }, SAMPLE_INTERVAL_MS);
+        timer.unref();
+        return () => {
+            clearInterval(timer);
+        };
+    },
+};

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/orchestrator.d.ts

@@ -0,0 +1,17 @@
+import { type CommandRule, type SpawnFn } from "../tools/index.js";
+import { type WorkspaceFs } from "../workspace/fs.js";
+import type { WorkspaceInfo } from "../workspace/index.js";
+import { type ResourceMonitor } from "./monitor.js";
+import type { VerificationPlan, VerificationReport } from "./types.js";
+export interface VerificationDeps {
+    readonly workspace: WorkspaceInfo;
+    readonly signal?: AbortSignal | undefined;
+    readonly spawn?: SpawnFn | undefined;
+    readonly monitor?: ResourceMonitor | undefined;
+    readonly processEnv?: NodeJS.ProcessEnv | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly fs?: WorkspaceFs | undefined;
+}
+export declare const VERIFICATION_COMMAND_RULES: readonly CommandRule[];
+export declare function runVerification(plan: VerificationPlan, deps: VerificationDeps): Promise<VerificationReport>;
+//# sourceMappingURL=orchestrator.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/src/verification/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../../../../src/verification/orchestrator.ts"],"names":[],"mappings":"AAOA,OAAO,EAKL,KAAK,WAAW,EAIhB,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAKnB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAE1C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACvC;AAKD,eAAO,MAAM,0BAA0B,EAAE,SAAS,WAAW,EAY3D,CAAC;AAyZH,wBAAsB,eAAe,CACnC,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CAc7B"}

package/node_modules/@oscharko-dev/keiko-server/dist/src/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/node_modules/@oscharko-dev/keiko-server/dist/src/verification/plan.d.ts

@@ -0,0 +1,10 @@
+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;
+//# sourceMappingURL=plan.d.ts.map