kibi-cli 2.31.1 → 2.35.1

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

@@ -1 +1 @@
-{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/proof/evaluate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC1B,gBAAgB,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C,CAAC,CAAC;AAEH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,GAC1C,mBAAmB,CAgBrB;AA6CD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,kBAAkB,CA4GpB"}
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/proof/evaluate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC1B,gBAAgB,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C,CAAC,CAAC;AAEH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,GAC1C,mBAAmB,CAgBrB;AA6CD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,kBAAkB,CA6HpB"}

package/dist/proof/evaluate.js

@@ -64,6 +64,14 @@ function failingMemberSummary(artifact, observed) {
  */
 export function evaluateContractAgainstRun(artifact, contract) {
     const runPassed = artifact.run.outcome === "passed";
+    // Under own_results_first_attempt a run that only failed other cases is
+    // judged per obligation; setup, collection, infrastructure or teardown
+    // failures, errors, interruptions and empty runs still refuse every one.
+    const judgeOwnResults = !runPassed &&
+        contract.success_policy === "own_results_first_attempt" &&
+        artifact.run.outcome === "failed" &&
+        (artifact.run.failure_phase === undefined ||
+            artifact.run.failure_phase === "execution");
     const gaps = [];
     const projectedResults = [];
     for (const obligation of contract.required_proofs) {
@@ -71,7 +79,15 @@ export function evaluateContractAgainstRun(artifact, contract) {
             result.target === obligation.target);
         if (observed)
             projectedResults.push(observed);
-        if (!runPassed) {
+        if (judgeOwnResults && observed?.binding === "aggregate_run") {
+            gaps.push({
+                symbol_id: obligation.symbol_id,
+                target: obligation.target,
+                reason: `run did not pass (outcome: ${artifact.run.outcome}); an aggregate-run result has no result of its own to judge`,
+            });
+            continue;
+        }
+        if (!runPassed && !judgeOwnResults) {
             const attribution = failingMemberSummary(artifact, observed);
             gaps.push({
                 symbol_id: obligation.symbol_id,
@@ -127,7 +143,7 @@ export function evaluateContractAgainstRun(artifact, contract) {
             });
         }
     }
-    if (!runPassed) {
+    if (!runPassed && !judgeOwnResults) {
         return {
             satisfied: false,
             outcome: mapRunOutcome(artifact.run.outcome),

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

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/proof/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAM/B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,yEAAyE;IACzE,mBAAmB,EAAE,SAAS,QAAQ,CAAC;QACrC,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,EAAE,CAAC;IACL,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qEAAqE;IACrE,mBAAmB,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC/D,6EAA6E;IAC7E,gBAAgB,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,eAAe,EAAE,aAAa,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAwIH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAMT;AA2BD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAiHjB"}
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/proof/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAM/B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,yEAAyE;IACzE,mBAAmB,EAAE,SAAS,QAAQ,CAAC;QACrC,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,EAAE,CAAC;IACL,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qEAAqE;IACrE,mBAAmB,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC/D,6EAA6E;IAC7E,gBAAgB,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,eAAe,EAAE,aAAa,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AA0LH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAMT;AA2BD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA0HjB"}

package/dist/proof/inspect.js

@@ -108,6 +108,56 @@ const PACKAGE_RUNNERS = [
         producer: "command",
     },
 ];
+/**
+ * Runners recognised inside package.json scripts. Projects that run the
+ * built-in Node or Bun test runners have no config file to detect.
+ */
+const SCRIPT_RUNNERS = [
+    { runner: "node --test", pattern: /\bnode\b[^&|;]*\s--test\b/ },
+    { runner: "bun test", pattern: /\bbun\s+test\b/ },
+    { runner: "vitest", pattern: /\bvitest\b/ },
+    { runner: "jest", pattern: /\bjest\b/ },
+    { runner: "playwright", pattern: /\bplaywright\s+test\b/ },
+];
+/** package.json script bodies of the root and its declared workspaces. */
+function workspaceScripts(root, pkg) {
+    const bodies = [];
+    const collect = (manifest) => {
+        const scripts = manifest?.scripts;
+        if (scripts === null || typeof scripts !== "object")
+            return;
+        for (const body of Object.values(scripts))
+            if (typeof body === "string")
+                bodies.push(body);
+    };
+    collect(pkg);
+    const declared = Array.isArray(pkg?.workspaces)
+        ? pkg.workspaces
+        : Array.isArray(pkg?.workspaces?.packages)
+            ? (pkg?.workspaces).packages
+            : [];
+    for (const pattern of declared) {
+        if (typeof pattern !== "string" || pattern.startsWith("!"))
+            continue;
+        // Only `dir` and `dir/*` workspace globs are expanded.
+        const directories = pattern.endsWith("/*")
+            ? (() => {
+                const parent = path.join(root, pattern.slice(0, -2));
+                try {
+                    return readdirSync(parent).map((entry) => path.join(parent, entry));
+                }
+                catch {
+                    return [];
+                }
+            })()
+            : pattern.includes("*")
+                ? []
+                : [path.join(root, pattern)];
+        for (const directory of directories)
+            collect(packageJson(directory));
+    }
+    return bodies;
+}
 function packageJson(root) {
     const filePath = path.join(root, "package.json");
     if (!existsSync(filePath))
@@ -182,6 +232,14 @@ export function inspectProofEnvironment(root, options = {}) {
                     runners.push(entry.runner);
             }
         }
+        const bodies = workspaceScripts(root, pkg);
+        for (const entry of SCRIPT_RUNNERS) {
+            if (bodies.some((body) => entry.pattern.test(body)) &&
+                !runners.includes(entry.runner))
+                runners.push(entry.runner);
+        }
+        if (existsSync(path.join(root, "bunfig.toml")))
+            buildSystems.add("bun");
     }
     if (existsSync(path.join(root, "Cargo.toml")))
         buildSystems.add("cargo");

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

@@ -18,9 +18,12 @@ export declare class KibiPlaywrightProducer {
     private readonly options;
     private readonly results;
     private startedAt;
+    private globalErrors;
     constructor(options?: KibiPlaywrightProducerOptions);
     onBegin(): void;
     onTestEnd(test: unknown, result: unknown): void;
+    /** Errors outside any test case (config, global setup, collection). */
+    onError(): void;
     onEnd(result?: unknown): Promise<void>;
 }
 export default KibiPlaywrightProducer;

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

@@ -1 +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"}
+{"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;AA2DH;;;;;GAKG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAK;gBAEb,OAAO,GAAE,6BAAkC;IAMvD,OAAO,IAAI,IAAI;IAKf,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAmD/C,uEAAuE;IAEvE,OAAO,IAAI,IAAI;IAKT,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAkC7C;AAED,eAAe,sBAAsB,CAAC"}

package/dist/proof/producers/playwright-reporter.js

@@ -39,6 +39,23 @@ function environment() {
         runtime: { name: "node", version: process.version },
     };
 }
+/**
+ * Map Playwright's final status to a run outcome. A plain `failed` run with
+ * no error outside the test cases failed in execution, so a contract under
+ * `own_results_first_attempt` can still judge each obligation's own case;
+ * global errors, a global timeout and interruptions refuse every obligation.
+ */
+function runOutcome(status, globalErrors) {
+    if (status === "passed" && globalErrors === 0)
+        return { outcome: "passed" };
+    if (status === "interrupted")
+        return { outcome: "interrupted" };
+    if (status === "timedout")
+        return { outcome: "timed_out", failure_phase: "infrastructure" };
+    return globalErrors > 0
+        ? { outcome: "failed", failure_phase: "setup" }
+        : { outcome: "failed", failure_phase: "execution" };
+}
 /**
  * First-party Playwright producer. It reports what happened as a
  * kibi.proof-run.v1 artifact with complete attempt history; Kibi evaluates
@@ -49,6 +66,7 @@ export class KibiPlaywrightProducer {
     options;
     results = new Map();
     startedAt;
+    globalErrors = 0;
     constructor(options = {}) {
         this.options = options;
         this.startedAt = (options.now ?? (() => new Date()))().toISOString();
@@ -101,6 +119,11 @@ export class KibiPlaywrightProducer {
             attempts: { status: "complete", entries: [attempt] },
         });
     }
+    /** Errors outside any test case (config, global setup, collection). */
+    // implements REQ-kibi-verification-evidence-contract
+    onError() {
+        this.globalErrors += 1;
+    }
     // implements REQ-kibi-verification-evidence-contract
     async onEnd(result) {
         const now = this.options.now ?? (() => new Date());
@@ -123,8 +146,8 @@ export class KibiPlaywrightProducer {
             code_snapshot: this.options.codeSnapshot ?? process.env.KIBI_PROOF_SNAPSHOT ?? "",
             environment: environment(),
             run: {
-                outcome: status === "passed" ? "passed" : "failed",
-                exit_code: status === "passed" ? 0 : 1,
+                ...runOutcome(status, this.globalErrors),
+                exit_code: status === "passed" && this.globalErrors === 0 ? 0 : 1,
                 started_at: this.startedAt,
                 finished_at: now().toISOString(),
             },

package/dist/proof/step-runner.d.ts

@@ -0,0 +1,36 @@
+import { PROOF_TEST_REPORT_VERSION } from "./command-test-report.js";
+/** Where `kibi proof run-steps` reads steps when no file is given. */
+export declare const DEFAULT_PROOF_STEPS_PATH = "proof/steps.json";
+export type ProofStepEntry = Readonly<{
+    test_id: string;
+    steps: readonly (readonly string[])[];
+}>;
+export type ProofStepAttempt = Readonly<{
+    outcome: "passed" | "failed" | "timed_out";
+    exit_code: number | null;
+}>;
+/** Validate a steps file: unique test ids, each with non-empty argv steps. */
+export declare function validateProofSteps(value: unknown): ProofStepEntry[];
+/** The selected tests' entries, in request order; a missing id is an error. */
+export declare function selectProofSteps(entries: readonly ProofStepEntry[], testIds: readonly string[]): ProofStepEntry[];
+/** Build the per-test report from each step's attempt (keyed by argv). */
+export declare function buildStepReport(selected: readonly ProofStepEntry[], attempts: ReadonlyMap<string, ProofStepAttempt>): Readonly<{
+    version: typeof PROOF_TEST_REPORT_VERSION;
+    tests: readonly Record<string, unknown>[];
+}>;
+/**
+ * Run the selected tests' steps (each distinct argv once, in declaration
+ * order), write the per-test report when KIBI_PROOF_TEST_REPORT names a
+ * path, and return the exit code: 0 only when every step passed. A step
+ * never sees the outer report path, so a nested kibi prove cannot overwrite
+ * the report this run writes. SIGINT and SIGTERM stop the running step's
+ * whole process group before the runner exits.
+ */
+export declare function runProofSteps(options: {
+    workspaceRoot: string;
+    stepsPath?: string;
+    testIds?: readonly string[];
+    env?: NodeJS.ProcessEnv;
+    write?: (line: string) => void;
+}): Promise<number>;
+//# sourceMappingURL=step-runner.d.ts.map

package/dist/proof/step-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-runner.d.ts","sourceRoot":"","sources":["../../src/proof/step-runner.ts"],"names":[],"mappings":"AAgCA,OAAO,EAEL,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAElC,sEAAsE;AAEtE,eAAO,MAAM,wBAAwB,qBAAqB,CAAC;AAM3D,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;CACvC,CAAC,CAAC;AAGH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;IAC3C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC,CAAC;AAMH,8EAA8E;AAE9E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,EAAE,CA0BnE;AAED,+EAA+E;AAE/E,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,cAAc,EAAE,CAMlB;AAED,0EAA0E;AAE1E,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC9C,QAAQ,CAAC;IACV,OAAO,EAAE,OAAO,yBAAyB,CAAC;IAC1C,KAAK,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CAC3C,CAAC,CAwBD;AAkED;;;;;;;GAOG;AAEH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC,GAAG,OAAO,CAAC,MAAM,CAAC,CAuElB"}

package/dist/proof/step-runner.js

@@ -0,0 +1,234 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * A shipped step runner for `command` proof integrations.
+ *
+ * A project declares each proof-bearing test's steps (argv arrays) in a
+ * steps file; `kibi proof run-steps` is the integration's command. It runs
+ * the steps of the tests kibi prove selected (KIBI_PROOF_TEST_IDS), each
+ * distinct argv once, and writes a kibi.proof-test-report.v1 to
+ * KIBI_PROOF_TEST_REPORT so every test keeps its own receipt: one failing
+ * step fails only the tests that declare it.
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { PROOF_TEST_REPORT_ENV, PROOF_TEST_REPORT_VERSION, } from "./command-test-report.js";
+/** Where `kibi proof run-steps` reads steps when no file is given. */
+// implements REQ-kibi-fresh-verification-receipts-v2
+export const DEFAULT_PROOF_STEPS_PATH = "proof/steps.json";
+const DEFAULT_STEP_TIMEOUT_MS = 15 * 60_000;
+const TERM_GRACE_MS = 2_000;
+function fail(message) {
+    throw new Error(`kibi proof run-steps: ${message}`);
+}
+/** Validate a steps file: unique test ids, each with non-empty argv steps. */
+// implements REQ-kibi-fresh-verification-receipts-v2
+export function validateProofSteps(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        fail("the steps file must be a non-empty JSON array of {test_id, steps}");
+    const ids = new Set();
+    return value.map((entry, index) => {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+            fail(`entry ${index} must be an object`);
+        const row = entry;
+        const testId = typeof row.test_id === "string" ? row.test_id.trim() : "";
+        if (testId === "")
+            fail(`entry ${index} has an empty test_id`);
+        if (ids.has(testId))
+            fail(`duplicate test_id ${JSON.stringify(testId)}`);
+        ids.add(testId);
+        if (!Array.isArray(row.steps) || row.steps.length === 0)
+            fail(`${testId} must declare at least one step`);
+        const steps = row.steps.map((argv, stepIndex) => {
+            if (!Array.isArray(argv) ||
+                argv.length === 0 ||
+                argv.some((part) => typeof part !== "string") ||
+                argv[0].trim() === "")
+                fail(`${testId} step ${stepIndex + 1} must be a non-empty string argv array`);
+            return [...argv];
+        });
+        return { test_id: testId, steps };
+    });
+}
+/** The selected tests' entries, in request order; a missing id is an error. */
+// implements REQ-kibi-fresh-verification-receipts-v2
+export function selectProofSteps(entries, testIds) {
+    const byId = new Map(entries.map((entry) => [entry.test_id, entry]));
+    const missing = testIds.filter((id) => !byId.has(id));
+    if (missing.length > 0)
+        fail(`no steps declared for ${missing.join(", ")}`);
+    return testIds.map((id) => byId.get(id));
+}
+/** Build the per-test report from each step's attempt (keyed by argv). */
+// implements REQ-kibi-fresh-verification-receipts-v2
+export function buildStepReport(selected, attempts) {
+    return {
+        version: PROOF_TEST_REPORT_VERSION,
+        tests: selected.map((entry) => {
+            const steps = entry.steps.map((argv, index) => {
+                const attempt = attempts.get(JSON.stringify(argv)) ?? {
+                    outcome: "failed",
+                    exit_code: null,
+                };
+                return {
+                    step_index: index + 1,
+                    command: [...argv],
+                    outcome: attempt.outcome,
+                    exit_code: attempt.exit_code,
+                };
+            });
+            const failure = steps.find((step) => step.outcome !== "passed");
+            return {
+                test_id: entry.test_id,
+                outcome: failure === undefined ? "passed" : failure.outcome,
+                steps,
+            };
+        }),
+    };
+}
+const running = new Set();
+function signalGroup(child, signal) {
+    const pid = child.pid;
+    if (process.platform !== "win32" && pid !== undefined) {
+        try {
+            process.kill(-pid, signal);
+            return;
+        }
+        catch {
+            // The group may already be gone.
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // Already exited.
+    }
+}
+/** Run one step once, in its own process group, with a timeout. */
+function runStep(argv, cwd, env, timeoutMs) {
+    const [command, ...args] = argv;
+    return new Promise((resolve) => {
+        let timedOut = false;
+        let child;
+        try {
+            child = spawn(command, args, {
+                cwd,
+                env,
+                shell: false,
+                stdio: "inherit",
+                detached: process.platform !== "win32",
+            });
+        }
+        catch {
+            resolve({ outcome: "failed", exit_code: null });
+            return;
+        }
+        running.add(child);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            signalGroup(child, "SIGTERM");
+            setTimeout(() => signalGroup(child, "SIGKILL"), TERM_GRACE_MS).unref();
+        }, timeoutMs);
+        const done = (code) => {
+            clearTimeout(timer);
+            running.delete(child);
+            resolve({
+                outcome: timedOut ? "timed_out" : code === 0 ? "passed" : "failed",
+                exit_code: code,
+            });
+        };
+        child.once("error", () => done(null));
+        child.once("close", (code) => done(code));
+    });
+}
+/**
+ * Run the selected tests' steps (each distinct argv once, in declaration
+ * order), write the per-test report when KIBI_PROOF_TEST_REPORT names a
+ * path, and return the exit code: 0 only when every step passed. A step
+ * never sees the outer report path, so a nested kibi prove cannot overwrite
+ * the report this run writes. SIGINT and SIGTERM stop the running step's
+ * whole process group before the runner exits.
+ */
+// implements REQ-kibi-fresh-verification-receipts-v2
+export async function runProofSteps(options) {
+    const env = options.env ?? process.env;
+    const write = options.write ?? ((line) => console.error(line));
+    const stepsPath = path.resolve(options.workspaceRoot, options.stepsPath ?? DEFAULT_PROOF_STEPS_PATH);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(stepsPath, "utf8"));
+    }
+    catch (error) {
+        fail(`cannot read ${stepsPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const entries = validateProofSteps(parsed);
+    let testIds = options.testIds;
+    if (testIds === undefined) {
+        const raw = env.KIBI_PROOF_TEST_IDS;
+        testIds =
+            raw === undefined || raw.trim() === ""
+                ? entries.map((entry) => entry.test_id)
+                : JSON.parse(raw);
+    }
+    const selected = selectProofSteps(entries, testIds);
+    const timeoutMs = (() => {
+        const value = Number(env.KIBI_PROOF_STEP_TIMEOUT_MS);
+        return Number.isFinite(value) && value > 0 ? value : DEFAULT_STEP_TIMEOUT_MS;
+    })();
+    const stepEnv = { ...env };
+    delete stepEnv[PROOF_TEST_REPORT_ENV];
+    const stop = (signal) => {
+        for (const child of running)
+            signalGroup(child, signal);
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    const onInt = () => stop("SIGINT");
+    const onTerm = () => stop("SIGTERM");
+    process.once("SIGINT", onInt);
+    process.once("SIGTERM", onTerm);
+    const attempts = new Map();
+    try {
+        for (const entry of selected)
+            for (const [index, argv] of entry.steps.entries()) {
+                const key = JSON.stringify(argv);
+                if (attempts.has(key))
+                    continue;
+                write(`[proof] ${entry.test_id} step ${index + 1}: ${argv.join(" ")}`);
+                attempts.set(key, await runStep(argv, options.workspaceRoot, stepEnv, timeoutMs));
+            }
+    }
+    finally {
+        process.removeListener("SIGINT", onInt);
+        process.removeListener("SIGTERM", onTerm);
+    }
+    const report = buildStepReport(selected, attempts);
+    const reportPath = env[PROOF_TEST_REPORT_ENV];
+    if (typeof reportPath === "string" && reportPath.trim() !== "") {
+        mkdirSync(path.dirname(reportPath), { recursive: true });
+        const temporary = `${reportPath}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+        renameSync(temporary, reportPath);
+    }
+    const failing = report.tests.filter((test) => test.outcome !== "passed");
+    write(failing.length === 0
+        ? `[proof] every step passed for ${selected.length} test(s)`
+        : `[proof] ${failing.length} of ${selected.length} test(s) have a failing step: ${failing.map((test) => test.test_id).join(", ")}`);
+    return failing.length === 0 ? 0 : 1;
+}

package/dist/public/evidence-levels.d.ts

@@ -0,0 +1,12 @@
+/**
+ * How strong the evidence behind a requirement is, strongest first. proved: a
+ * re-checkable certificate covers every case. tested: fresh passing E2E
+ * receipts cover every linked scenario. asserted: a person stands behind it.
+ * unverified: an agent wrote it and no person approved it. The same list is
+ * the vocabulary of required_evidence, a requirement's evidence floor.
+ */
+export declare const EVIDENCE_LEVELS: readonly ["proved", "tested", "asserted", "unverified"];
+export type EvidenceLevel = (typeof EVIDENCE_LEVELS)[number];
+/** Higher is stronger: unverified 0 through proved 3. */
+export declare function evidenceRank(level: EvidenceLevel): number;
+//# sourceMappingURL=evidence-levels.d.ts.map

package/dist/public/evidence-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-levels.d.ts","sourceRoot":"","sources":["../../src/public/evidence-levels.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,eAAe,yDAKlB,CAAC;AAGX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,yDAAyD;AAEzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAEzD"}

package/dist/public/evidence-levels.js

@@ -0,0 +1,19 @@
+/**
+ * How strong the evidence behind a requirement is, strongest first. proved: a
+ * re-checkable certificate covers every case. tested: fresh passing E2E
+ * receipts cover every linked scenario. asserted: a person stands behind it.
+ * unverified: an agent wrote it and no person approved it. The same list is
+ * the vocabulary of required_evidence, a requirement's evidence floor.
+ */
+// implements REQ-kibi-evidence-levels, REQ-kibi-evidence-floors
+export const EVIDENCE_LEVELS = [
+    "proved",
+    "tested",
+    "asserted",
+    "unverified",
+];
+/** Higher is stronger: unverified 0 through proved 3. */
+// implements REQ-kibi-evidence-floors
+export function evidenceRank(level) {
+    return EVIDENCE_LEVELS.length - 1 - EVIDENCE_LEVELS.indexOf(level);
+}

package/dist/public/impact/coverage-depth-quality.d.ts

@@ -7,4 +7,11 @@ export declare function createCoverageDepthQualityDiagnostics(manifestResults: r
     readonly passingE2eTests?: readonly string[];
     readonly receiptGapCodes?: readonly string[];
 }>>): readonly QualityDiagnostic[];
+/**
+ * Requirements whose every implementing production symbol is a whole-file
+ * anchor (a coarse granularity_reason). Coverage then only says some test
+ * touches the file, so `tested` evidence is cheap; narrower behavioral
+ * symbols would tie it to the code that implements the claim.
+ */
+export declare function createCoarseAnchorQualityDiagnostics(manifestResults: readonly ExtractionResult[]): readonly QualityDiagnostic[];
 //# sourceMappingURL=coverage-depth-quality.d.ts.map

package/dist/public/impact/coverage-depth-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage-depth-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/coverage-depth-quality.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsIpD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAI1E;AAgLD,wBAAgB,qCAAqC,CACnD,eAAe,EAAE,SAAS,gBAAgB,EAAE,EAC5C,kBAAkB,GAAE,WAAW,CAC7B,MAAM,EACN,QAAQ,CAAC;IACP,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C,CAAC,CACS,GACZ,SAAS,iBAAiB,EAAE,CAmB9B"}
+{"version":3,"file":"coverage-depth-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/coverage-depth-quality.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsIpD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAI1E;AAgLD,wBAAgB,qCAAqC,CACnD,eAAe,EAAE,SAAS,gBAAgB,EAAE,EAC5C,kBAAkB,GAAE,WAAW,CAC7B,MAAM,EACN,QAAQ,CAAC;IACP,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C,CAAC,CACS,GACZ,SAAS,iBAAiB,EAAE,CAmB9B;AAID;;;;;GAKG;AAEH,wBAAgB,oCAAoC,CAClD,eAAe,EAAE,SAAS,gBAAgB,EAAE,GAC3C,SAAS,iBAAiB,EAAE,CA2D9B"}

package/dist/public/impact/coverage-depth-quality.js

@@ -1,3 +1,4 @@
+import { COARSE_GRANULARITY_REASONS } from "../symbol-granularity.generated.js";
 function entitiesById(manifestResults) {
     return new Map(manifestResults.map((result) => [result.entity.id, result.entity]));
 }
@@ -223,3 +224,61 @@ export function createCoverageDepthQualityDiagnostics(manifestResults, proofByRe
     })
         .toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
 }
+const COARSE_REASONS = new Set(COARSE_GRANULARITY_REASONS);
+/**
+ * Requirements whose every implementing production symbol is a whole-file
+ * anchor (a coarse granularity_reason). Coverage then only says some test
+ * touches the file, so `tested` evidence is cheap; narrower behavioral
+ * symbols would tie it to the code that implements the claim.
+ */
+// implements REQ-audit-quality-diagnostics-v1
+export function createCoarseAnchorQualityDiagnostics(manifestResults) {
+    const superseded = supersededRequirementIds(manifestResults);
+    const anchorsByRequirement = new Map();
+    for (const result of manifestResults) {
+        if (result.entity.type !== "symbol")
+            continue;
+        // Executable test code is not a production symbol.
+        if (result.relationships.some((rel) => rel.type === "executable_for"))
+            continue;
+        for (const relationship of result.relationships) {
+            if (relationship.type !== "implements")
+                continue;
+            const list = anchorsByRequirement.get(relationship.to) ?? [];
+            list.push(result.entity);
+            anchorsByRequirement.set(relationship.to, list);
+        }
+    }
+    return manifestResults
+        .filter((result) => result.entity.type === "req" &&
+        isReviewableRequirement(result.entity, superseded))
+        .flatMap((result) => {
+        const symbols = uniqueEntities(anchorsByRequirement.get(result.entity.id) ?? []);
+        if (symbols.length === 0 ||
+            !symbols.every((symbol) => COARSE_REASONS.has(symbol.granularity_reason ?? "")))
+            return [];
+        const requirement = result.entity;
+        return [
+            {
+                id: "coarse_anchor_only_review",
+                severity: "review",
+                blocking: false,
+                category: "coverage",
+                entityId: requirement.id,
+                source: requirement.source,
+                files: [requirement.source],
+                message: `Requirement ${requirement.id} (${requirement.title}) is implemented only by whole-file anchors, so its coverage says a test touches those files, not the code behind the claim.`,
+                suggestion: "Link the functions, methods or types that implement the requirement with implements (and covered_by to their tests); keep the file anchor only for genuinely module-level behavior.",
+                evidence: {
+                    requirementId: requirement.id,
+                    title: requirement.title,
+                    symbols: symbols.map((symbol) => ({
+                        id: symbol.id,
+                        granularityReason: symbol.granularity_reason ?? "",
+                    })),
+                },
+            },
+        ];
+    })
+        .toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
+}

package/dist/public/impact/full-kb-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAWjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAogBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,OAAO,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAM/C;AA2ID,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAkCvC"}
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAcjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAqgBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,OAAO,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAM/C;AA2ID,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAmCvC"}

package/dist/public/impact/full-kb-quality.js

@@ -5,7 +5,7 @@ import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../operation
 import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../proof-receipt.js";
 import relationshipSchema from "../schemas/relationship.js";
 import { analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "../telemetry-acceptance.js";
-import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
+import { createCoarseAnchorQualityDiagnostics, createCoverageDepthQualityDiagnostics, } from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
 const RELATIONSHIP_TYPES = relationshipSchema.properties.type.enum;
@@ -225,6 +225,7 @@ function toExtractedEntity(entity) {
         "aliases",
         "examples",
         "predicate_args",
+        "value_set",
     ]) {
         const values = optionalStringArrayField(entity, field);
         if (values !== undefined)
@@ -552,6 +553,7 @@ export async function collectFullKbQualityDiagnostics(options) {
                 : {}),
         }),
         ...coverageDepthDiagnostics,
+        ...createCoarseAnchorQualityDiagnostics(manifestResults),
         ...createSymbolQualityDiagnostics({
             manifestResults,
             symbolsByFile: new Map(),