kibi-cli 1.0.1 → 2.1.0

package/dist/proof/inspect.js

@@ -0,0 +1,236 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { loadProofIntegrations } from "./integrations.js";
+/**
+ * Declarative detection manifests. Deterministic CLI logic consumes these;
+ * agents consume the inspection output and never reinvent runner discovery.
+ */
+const DETECTORS = [
+    {
+        language: "typescript",
+        runner: "playwright",
+        files: [
+            "playwright.config.ts",
+            "playwright.config.mjs",
+            "playwright.config.js",
+        ],
+        command: ["npx", "playwright", "test"],
+        producer: "playwright",
+    },
+    {
+        language: "typescript",
+        runner: "vitest",
+        files: ["vitest.config.ts", "vitest.config.mjs", "vitest.config.js"],
+        command: [
+            "npx",
+            "vitest",
+            "run",
+            "--reporter=junit",
+            "--outputFile=.kb/proof/runs/vitest-junit.xml",
+        ],
+        producer: "junit",
+    },
+    {
+        language: "typescript",
+        runner: "jest",
+        files: ["jest.config.ts", "jest.config.mjs", "jest.config.js"],
+        command: [
+            "npx",
+            "jest",
+            "--ci",
+            "--reporters=default",
+            "--reporters=jest-junit",
+        ],
+        producer: "junit",
+    },
+    {
+        language: "python",
+        runner: "pytest",
+        files: ["pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"],
+        command: ["pytest", "--junitxml=.kb/proof/runs/pytest-junit.xml"],
+        producer: "junit",
+    },
+    {
+        language: "go",
+        runner: "go test",
+        files: ["go.mod"],
+        command: ["go", "test", "./...", "-json"],
+        producer: "tap",
+    },
+    {
+        language: "rust",
+        runner: "cargo test",
+        files: ["Cargo.toml"],
+        command: ["cargo", "test"],
+        producer: "tap",
+    },
+    {
+        language: "java",
+        runner: "maven",
+        files: ["pom.xml"],
+        command: ["mvn", "test"],
+        producer: "junit",
+    },
+    {
+        language: "java",
+        runner: "gradle",
+        files: ["build.gradle", "build.gradle.kts"],
+        command: ["gradle", "test"],
+        producer: "junit",
+    },
+    {
+        language: "csharp",
+        runner: "dotnet test",
+        files: ["*.csproj", "*.sln"],
+        command: ["dotnet", "test", "--logger", "junit"],
+        producer: "junit",
+    },
+    {
+        language: "ruby",
+        runner: "rake test",
+        files: ["Rakefile", "Gemfile"],
+        command: ["bundle", "exec", "rake", "test"],
+        producer: "junit",
+    },
+];
+const PACKAGE_RUNNERS = [
+    {
+        runner: "npm test",
+        script: "test",
+        command: ["npm", "test"],
+        producer: "command",
+    },
+    {
+        runner: "cargo test",
+        script: "",
+        command: ["cargo", "test"],
+        producer: "command",
+    },
+];
+function packageJson(root) {
+    const filePath = path.join(root, "package.json");
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function directoryEntriesMatch(directory, regex) {
+    try {
+        return readdirSync(directory).some((entry) => regex.test(entry));
+    }
+    catch {
+        return false;
+    }
+}
+function globExists(root, pattern) {
+    if (pattern.includes("*")) {
+        const directory = path.dirname(path.join(root, pattern));
+        if (!existsSync(directory))
+            return false;
+        const base = path.basename(pattern);
+        const regex = new RegExp(`^${base
+            .split("*")
+            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+            .join(".*")}$`);
+        return directoryEntriesMatch(directory, regex);
+    }
+    return existsSync(path.join(root, pattern));
+}
+function directoryExists(root, relative) {
+    try {
+        return existsSync(path.join(root, relative));
+    }
+    catch {
+        return false;
+    }
+}
+// implements REQ-kibi-verification-evidence-contract
+export function inspectProofEnvironment(root) {
+    const languages = new Set();
+    const buildSystems = new Set();
+    const runners = [];
+    const missing = [];
+    for (const detector of DETECTORS) {
+        if (!detector.files.some((pattern) => globExists(root, pattern)))
+            continue;
+        languages.add(detector.language);
+        if (!runners.includes(detector.runner))
+            runners.push(detector.runner);
+    }
+    if (existsSync(path.join(root, "package.json"))) {
+        languages.add("javascript/typescript");
+        const pkg = packageJson(root);
+        const scripts = pkg?.scripts !== null &&
+            typeof pkg?.scripts === "object" &&
+            pkg?.scripts !== undefined
+            ? pkg.scripts
+            : {};
+        if (scripts.dependencies !== undefined ||
+            pkg?.devDependencies !== undefined)
+            buildSystems.add("npm");
+        if (existsSync(path.join(root, "bun.lockb")) ||
+            existsSync(path.join(root, "bun.lock")))
+            buildSystems.add("bun");
+        for (const entry of PACKAGE_RUNNERS) {
+            if (entry.script !== "" && typeof scripts[entry.script] === "string") {
+                if (!runners.includes(entry.runner))
+                    runners.push(entry.runner);
+            }
+        }
+    }
+    if (existsSync(path.join(root, "Cargo.toml")))
+        buildSystems.add("cargo");
+    if (existsSync(path.join(root, "go.mod")))
+        buildSystems.add("go");
+    if (existsSync(path.join(root, "pom.xml")))
+        buildSystems.add("maven");
+    if (existsSync(path.join(root, "Makefile")))
+        buildSystems.add("make");
+    const ciWorkflows = [];
+    const workflowsDir = path.join(root, ".github", "workflows");
+    if (directoryExists(root, path.join(".github", "workflows"))) {
+        try {
+            for (const file of readdirSync(workflowsDir)) {
+                if (file.endsWith(".yml") || file.endsWith(".yaml"))
+                    ciWorkflows.push(file);
+            }
+        }
+        catch {
+            // unreadable workflow directory is not fatal for inspection
+        }
+    }
+    const integrations = loadProofIntegrations(root);
+    const currentIntegration = integrations.available
+        ? integrations.integrations.integrations.map((entry) => entry.id).join(", ")
+        : null;
+    let recommendation;
+    if (!integrations.available) {
+        if (runners.length === 0) {
+            recommendation =
+                "No test harness detected. Proof integration is deferred until the first proof-bearing test introduces one; command proof can prove any command.";
+            missing.push(".kb/proof/integrations.json (created by bootstrap)");
+        }
+        else {
+            recommendation =
+                "Run bootstrap to configure proof integrations: native producers or standard-format adapters for detected runners, or command proof as the universal fallback.";
+            missing.push(".kb/proof/integrations.json (created by bootstrap)");
+        }
+    }
+    else {
+        recommendation =
+            "Proof integration configured; run `kibi prove --all` to record fresh evidence.";
+    }
+    return {
+        languages: [...languages].sort(),
+        buildSystems: [...buildSystems].sort(),
+        detectedRunners: runners,
+        ciWorkflows,
+        currentIntegration,
+        recommendation,
+        missing,
+    };
+}

package/dist/proof/integrations.d.ts

@@ -0,0 +1,35 @@
+import type { ProofIntegrationExecution } from "../public/proof-fingerprint.js";
+import { PROOF_INTEGRATION_VERSION } from "../public/proof-protocol.js";
+/** Tracked, Kibi-managed proof integration configuration. */
+export declare const PROOF_INTEGRATIONS_PATH = ".kb/proof/integrations.json";
+/** Derived runtime artifacts of proof runs; never tracked knowledge. */
+export declare const PROOF_RUNS_DIR = ".kb/proof/runs";
+export declare const PRODUCER_KINDS: readonly ["command", "playwright", "junit", "tap"];
+export type ProducerKind = (typeof PRODUCER_KINDS)[number];
+export type ProofIntegration = Readonly<{
+    id: string;
+    producer: string;
+    producer_version?: string;
+    command: readonly string[];
+    artifact?: string;
+    targets?: readonly string[];
+    options?: Record<string, unknown>;
+    description?: string;
+}>;
+export type ProofIntegrationsFile = Readonly<{
+    version: typeof PROOF_INTEGRATION_VERSION;
+    integrations: readonly ProofIntegration[];
+}>;
+export type LoadedProofIntegrations = {
+    available: true;
+    integrations: ProofIntegrationsFile;
+} | {
+    available: false;
+    error: string;
+};
+export declare function integrationsPath(workspaceRoot: string): string;
+export declare function proofIntegrationErrors(value: unknown): string[];
+export declare function loadProofIntegrations(workspaceRoot: string): LoadedProofIntegrations;
+export declare function resolveIntegration(integrations: ProofIntegrationsFile, id: string): ProofIntegration | null;
+export declare function toExecution(integration: ProofIntegration): ProofIntegrationExecution;
+//# sourceMappingURL=integrations.d.ts.map

package/dist/proof/integrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../../src/proof/integrations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AAErE,wEAAwE;AACxE,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAE/C,eAAO,MAAM,cAAc,oDAKjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,OAAO,EAAE,OAAO,yBAAyB,CAAC;IAC1C,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAC/B;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,YAAY,EAAE,qBAAqB,CAAA;CAAE,GACxD;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAkE/D;AAED,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,GACpB,uBAAuB,CAwBzB;AAED,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,qBAAqB,EACnC,EAAE,EAAE,MAAM,GACT,gBAAgB,GAAG,IAAI,CAEzB;AAED,wBAAgB,WAAW,CACzB,WAAW,EAAE,gBAAgB,GAC5B,yBAAyB,CAkB3B"}

package/dist/proof/integrations.js

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { PROOF_INTEGRATION_VERSION } from "../public/proof-protocol.js";
+/** Tracked, Kibi-managed proof integration configuration. */
+export const PROOF_INTEGRATIONS_PATH = ".kb/proof/integrations.json";
+/** Derived runtime artifacts of proof runs; never tracked knowledge. */
+export const PROOF_RUNS_DIR = ".kb/proof/runs";
+export const PRODUCER_KINDS = [
+    "command",
+    "playwright",
+    "junit",
+    "tap",
+];
+export function integrationsPath(workspaceRoot) {
+    return path.join(workspaceRoot, PROOF_INTEGRATIONS_PATH);
+}
+export function proofIntegrationErrors(value) {
+    const file = record(value);
+    if (!file)
+        return [
+            `${PROOF_INTEGRATIONS_PATH} must be an object with version and integrations`,
+        ];
+    const errors = [];
+    if (file.version !== PROOF_INTEGRATION_VERSION)
+        errors.push(`version must be ${PROOF_INTEGRATION_VERSION}; received ${JSON.stringify(file.version ?? null)}`);
+    if (!Array.isArray(file.integrations) || file.integrations.length === 0) {
+        errors.push("integrations must be a non-empty array");
+        return errors;
+    }
+    const seen = new Set();
+    file.integrations.forEach((entry, index) => {
+        const row = record(entry);
+        const label = `integrations[${index}]`;
+        if (!row) {
+            errors.push(`${label} must be an object`);
+            return;
+        }
+        if (!nonEmpty(row.id))
+            errors.push(`${label}.id must be a non-empty string`);
+        else {
+            if (seen.has(String(row.id)))
+                errors.push(`${label}.id duplicates '${String(row.id)}'`);
+            seen.add(String(row.id));
+        }
+        if (!nonEmpty(row.producer))
+            errors.push(`${label}.producer must be one of: ${PRODUCER_KINDS.join(", ")} (or a custom producer id)`);
+        if (!Array.isArray(row.command) ||
+            row.command.length === 0 ||
+            !row.command.every((argument) => nonEmpty(argument)))
+            errors.push(`${label}.command must be a non-empty argv array`);
+        if (nonEmpty(row.producer) &&
+            (row.producer === "junit" || row.producer === "tap") &&
+            !nonEmpty(row.artifact))
+            errors.push(`${label}.artifact is required for producer '${String(row.producer)}' (path of the native report to convert)`);
+        if (row.targets !== undefined) {
+            if (!Array.isArray(row.targets) ||
+                row.targets.length === 0 ||
+                !row.targets.every((target) => nonEmpty(target)))
+                errors.push(`${label}.targets must be a non-empty array of target names`);
+        }
+        if (row.options !== undefined && !record(row.options))
+            errors.push(`${label}.options must be an object when present`);
+        if (row.description !== undefined && !nonEmpty(row.description))
+            errors.push(`${label}.description must be a non-empty string when present`);
+    });
+    return errors;
+}
+export function loadProofIntegrations(workspaceRoot) {
+    const filePath = integrationsPath(workspaceRoot);
+    if (!existsSync(filePath)) {
+        return {
+            available: false,
+            error: `No proof integration configuration at ${PROOF_INTEGRATIONS_PATH}. Run bootstrap for this repository to configure proof producers.`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        return {
+            available: false,
+            error: `${PROOF_INTEGRATIONS_PATH} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    const errors = proofIntegrationErrors(parsed);
+    if (errors.length > 0)
+        return {
+            available: false,
+            error: `Invalid ${PROOF_INTEGRATIONS_PATH}: ${errors.join("; ")}`,
+        };
+    return { available: true, integrations: parsed };
+}
+export function resolveIntegration(integrations, id) {
+    return integrations.integrations.find((entry) => entry.id === id) ?? null;
+}
+export function toExecution(integration) {
+    return {
+        id: integration.id,
+        producer: integration.producer,
+        ...(integration.producer_version !== undefined
+            ? { producer_version: integration.producer_version }
+            : {}),
+        command: integration.command,
+        ...(integration.artifact !== undefined
+            ? { artifact: integration.artifact }
+            : {}),
+        ...(integration.targets !== undefined
+            ? { targets: integration.targets }
+            : {}),
+        ...(integration.options !== undefined
+            ? { options: integration.options }
+            : {}),
+    };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/proof/producers/junit-adapter.d.ts

@@ -0,0 +1,26 @@
+import type { ProofResult } from "../../public/proof-protocol.js";
+export type NativeBinding = Readonly<{
+    symbol_id: string;
+    target: string;
+    native_id?: string;
+    aliases?: readonly string[];
+}>;
+export type NativeConversion = Readonly<{
+    results: ProofResult[];
+    diagnostics: string[];
+    /** A malformed or ambiguous report must never be projected partially. */
+    fatal?: boolean;
+}>;
+export declare function ambiguousNativeBindings(bindings: readonly NativeBinding[]): readonly string[];
+export declare function bindingLookup(bindings: readonly NativeBinding[]): (nativeId: string) => {
+    symbol_id: string;
+    target: string;
+} | null;
+/**
+ * JUnit XML exposes native case outcomes but no trustworthy attempt history.
+ * Explicit rerunFailure/rerunError children are the only exception: they
+ * provide a complete failed-then-passed sequence. Plain passes remain
+ * unavailable and are rejected by the strict first-attempt evaluator.
+ */
+export declare function convertJUnitXml(xml: string, bindings: readonly NativeBinding[]): NativeConversion;
+//# sourceMappingURL=junit-adapter.d.ts.map

package/dist/proof/producers/junit-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"junit-adapter.d.ts","sourceRoot":"","sources":["../../../src/proof/producers/junit-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,yEAAyE;IACzE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AA+EH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,SAAS,MAAM,EAAE,CAEnB;AAGD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,CAAC,QAAQ,EAAE,MAAM,KAAK;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIpE;AA2BD;;;;;GAKG;AAEH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,gBAAgB,CAmFlB"}

package/dist/proof/producers/junit-adapter.js

@@ -0,0 +1,186 @@
+import { SaxesParser } from "saxes";
+/** Build a tree from SAX events so nested suites/cases cannot be confused by regex boundaries. */
+function parseXml(xml) {
+    const parser = new SaxesParser({ xmlns: false });
+    const stack = [];
+    let root = null;
+    let parserError = null;
+    parser.on("doctype", () => {
+        throw new Error("DTD is not accepted in JUnit reports");
+    });
+    parser.on("error", (error) => {
+        parserError ??= error;
+    });
+    parser.on("opentag", (tag) => {
+        const attributes = {};
+        for (const [name, value] of Object.entries(tag.attributes)) {
+            attributes[name] = typeof value === "string" ? value : String(value);
+        }
+        stack.push({ name: tag.name, attributes, children: [] });
+    });
+    parser.on("closetag", () => {
+        const node = stack.pop();
+        if (!node) {
+            parserError ??= new Error("unexpected XML closing tag");
+            return;
+        }
+        const parent = stack[stack.length - 1];
+        if (parent)
+            parent.children.push(node);
+        else if (root)
+            parserError ??= new Error("multiple XML root elements");
+        else
+            root = node;
+    });
+    try {
+        parser.write(xml).close();
+    }
+    catch (error) {
+        parserError ??= error instanceof Error ? error : new Error(String(error));
+    }
+    if (parserError)
+        throw parserError;
+    if (stack.length > 0)
+        throw new Error(`unclosed XML element <${stack[stack.length - 1]?.name}>`);
+    if (!root)
+        throw new Error("empty XML report");
+    return root;
+}
+function bindingIndex(bindings) {
+    const values = new Map();
+    const ambiguous = new Set();
+    for (const binding of bindings) {
+        const value = { symbol_id: binding.symbol_id, target: binding.target };
+        for (const nativeId of [binding.native_id, ...(binding.aliases ?? [])]) {
+            if (!nativeId)
+                continue;
+            const previous = values.get(nativeId);
+            if (previous &&
+                (previous.symbol_id !== value.symbol_id ||
+                    previous.target !== value.target)) {
+                ambiguous.add(nativeId);
+                continue;
+            }
+            values.set(nativeId, value);
+        }
+    }
+    return { values, ambiguous };
+}
+// implements REQ-kibi-verification-evidence-contract
+export function ambiguousNativeBindings(bindings) {
+    return [...bindingIndex(bindings).ambiguous];
+}
+// implements REQ-kibi-verification-evidence-contract
+export function bindingLookup(bindings) {
+    const index = bindingIndex(bindings);
+    return (nativeId) => index.ambiguous.has(nativeId) ? null : (index.values.get(nativeId) ?? null);
+}
+function descendants(node, name) {
+    const found = [];
+    for (const child of node.children) {
+        if (child.name === name)
+            found.push(child);
+        found.push(...descendants(child, name));
+    }
+    return found;
+}
+function outcomeFromJUnitCase(testcase) {
+    const hasFailure = descendants(testcase, "failure").length > 0 ||
+        descendants(testcase, "error").length > 0;
+    const hasSkipped = descendants(testcase, "skipped").length > 0;
+    const reruns = descendants(testcase, "rerunFailure").length +
+        descendants(testcase, "rerunError").length;
+    if (hasSkipped && !hasFailure)
+        return { outcome: "skipped", reruns };
+    if (hasFailure)
+        return { outcome: "failed", reruns };
+    return { outcome: "passed", reruns };
+}
+/**
+ * JUnit XML exposes native case outcomes but no trustworthy attempt history.
+ * Explicit rerunFailure/rerunError children are the only exception: they
+ * provide a complete failed-then-passed sequence. Plain passes remain
+ * unavailable and are rejected by the strict first-attempt evaluator.
+ */
+// implements REQ-kibi-verification-evidence-contract
+export function convertJUnitXml(xml, bindings) {
+    const index = bindingIndex(bindings);
+    const diagnostics = [];
+    let root;
+    try {
+        root = parseXml(xml);
+    }
+    catch (error) {
+        diagnostics.push(`malformed junit XML: ${error instanceof Error ? error.message : String(error)}`);
+        if (!/<testsuite\b/i.test(xml))
+            diagnostics.push("no <testsuite> element found; not a JUnit XML report");
+        return { results: [], diagnostics, fatal: true };
+    }
+    if (root.name !== "testsuite" && root.name !== "testsuites") {
+        diagnostics.push("no <testsuite> element found; not a JUnit XML report");
+        return { results: [], diagnostics, fatal: true };
+    }
+    for (const nativeId of index.ambiguous)
+        diagnostics.push(`ambiguous junit binding for ${nativeId}`);
+    let fatal = index.ambiguous.size > 0;
+    const results = [];
+    const seen = new Map();
+    for (const testcase of descendants(root, "testcase")) {
+        const name = testcase.attributes.name;
+        if (name === undefined)
+            continue;
+        const classname = testcase.attributes.classname;
+        const nativeId = classname ? `${classname}::${name}` : name;
+        if (index.ambiguous.has(nativeId))
+            continue;
+        const bound = index.values.get(nativeId);
+        if (!bound) {
+            diagnostics.push(`unbound junit testcase ignored: ${nativeId}`);
+            continue;
+        }
+        const key = `${bound.target}\0${bound.symbol_id}`;
+        const { outcome, reruns } = outcomeFromJUnitCase(testcase);
+        const previous = seen.get(key);
+        if (previous) {
+            if (previous.nativeId !== nativeId || previous.outcome !== outcome) {
+                diagnostics.push(`ambiguous duplicate junit result for ${nativeId}`);
+                fatal = true;
+            }
+            else {
+                diagnostics.push(`duplicate junit result for ${nativeId}; ignored`);
+            }
+            continue;
+        }
+        seen.set(key, { nativeId, outcome });
+        const time = testcase.attributes.time;
+        const durationMs = time !== undefined && Number.isFinite(Number(time))
+            ? Math.max(0, Math.round(Number(time) * 1000))
+            : undefined;
+        results.push({
+            symbol_id: bound.symbol_id,
+            target: bound.target,
+            outcome,
+            binding: "native_case",
+            native_id: nativeId,
+            attempts: reruns > 0 && outcome === "passed"
+                ? {
+                    status: "complete",
+                    entries: [
+                        ...Array.from({ length: reruns }, () => ({
+                            outcome: "failed",
+                        })),
+                        {
+                            outcome: "passed",
+                            ...(durationMs !== undefined
+                                ? { duration_ms: durationMs }
+                                : {}),
+                        },
+                    ],
+                }
+                : { status: "unavailable" },
+        });
+    }
+    return fatal
+        ? { results: [], diagnostics, fatal: true }
+        : { results, diagnostics };
+}

package/dist/{public → proof/producers}/playwright-case-id.d.ts

@@ -1,5 +1,5 @@
 /**
- * Stable identity for a statically named Playwright test case.
+ * Stable identity for a statically named Playwright proof case.
  * The path is always repository-relative before hashing so the same case has
  * the same identity in a checkout, packed consumer, and dogfood workspace.
  */

package/dist/proof/producers/playwright-case-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-case-id.d.ts","sourceRoot":"","sources":["../../../src/proof/producers/playwright-case-id.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,MAAM,CAOR;AAGD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CASR"}

package/dist/{public → proof/producers}/playwright-case-id.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 /**
- * Stable identity for a statically named Playwright test case.
+ * Stable identity for a statically named Playwright proof case.
  * The path is always repository-relative before hashing so the same case has
  * the same identity in a checkout, packed consumer, and dogfood workspace.
  */

package/dist/proof/producers/playwright-reporter.d.ts

@@ -0,0 +1,27 @@
+import { PROOF_RUN_VERSION } from "../../public/proof-protocol.js";
+export { PROOF_RUN_VERSION };
+export type KibiPlaywrightProducerOptions = Readonly<{
+    outputPath?: string;
+    codeSnapshot?: string;
+    commandArgv?: readonly string[];
+    integration?: string;
+    workspaceRoot?: string;
+    now?: () => Date;
+}>;
+/**
+ * First-party Playwright producer. It reports what happened as a
+ * kibi.proof-run.v1 artifact with complete attempt history; Kibi evaluates
+ * proof obligations and policies. Structural callback surface only — no
+ * Playwright dependency.
+ */
+export declare class KibiPlaywrightProducer {
+    private readonly options;
+    private readonly results;
+    private startedAt;
+    constructor(options?: KibiPlaywrightProducerOptions);
+    onBegin(): void;
+    onTestEnd(test: unknown, result: unknown): void;
+    onEnd(result?: unknown): Promise<void>;
+}
+export default KibiPlaywrightProducer;
+//# sourceMappingURL=playwright-reporter.d.ts.map

package/dist/proof/producers/playwright-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-reporter.d.ts","sourceRoot":"","sources":["../../../src/proof/producers/playwright-reporter.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EAIlB,MAAM,gCAAgC,CAAC;AAOxC,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAG7B,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC,CAAC;AAwCH;;;;;GAKG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,GAAE,6BAAkC;IAMvD,OAAO,IAAI,IAAI;IAKf,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAoDzC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAkC7C;AAED,eAAe,sBAAsB,CAAC"}