@cejel/cejel 0.4.7 → 0.4.9

package/README.md

@@ -20,12 +20,8 @@ portable, offline trust certificate that aggregates them. Pipe in SARIF-compatib
 (MunaTrust, Snyk, Semgrep, CodeQL, Codex) plus OpenSSF Scorecard, and get one shareable
 certificate + badge over all of them. See "Aggregate your scanners" below.
 
-> Dogfooded in production. Cejel is run continuously on Barg Labs' own multi-product
-> monorepo — the ten-product studio it was built inside — which it currently scores
-> 3.3/4.0 on its rubric-native certificate. That transparency snapshot opts into prospective
-> v18; the public CLI default remains calibrated v17. On the comparative board, our code sits
-> outside the ranked population and receives no verdict band. We score ourselves before
-> asking you to score yourself.
+> Cejel is used on Barg Labs’ own code. The [public board](https://cejel.dev/leaderboard/)
+> labels publisher-owned snapshots separately from the ranked public repositories.
 
 ### Rubric calibration policy
 
@@ -93,7 +89,7 @@ if (-not $expected -or $actual -ne $expected.ToLowerInvariant()) {
 ```
 
 > **Windows signing status:** `cejel-Windows-x86_64.exe` is intentionally unsigned in
-> 0.4.7 and may trigger Microsoft SmartScreen. The release build removes Node's inherited
+> 0.4.9 and may trigger Microsoft SmartScreen. The release build removes Node's inherited
 > signature before SEA injection and fails unless Windows reports the result as `NotSigned`;
 > it does not ship an invalid signature. Before running it, verify `SHA256SUMS` and the
 > GitHub build-provenance attestation. Each binary also has an attached SPDX SBOM and an
@@ -116,7 +112,7 @@ docker run --rm --network=none -v "$PWD:/w" -w /w -v "$PWD/cejel:/cejel:ro" debi
 npx @cejel/cejel@latest .
 ```
 
-> **Distribution note:** Cejel `0.4.7` is the coordinated release version for npm,
+> **Distribution note:** Cejel `0.4.9` is the coordinated release version for npm,
 > standalone binaries, Docker/OCI, GitHub Action, Homebrew, and MCP Registry.
 
 `npx` can reuse a stale cached package. Force the current npm release with the `@latest`
@@ -178,16 +174,16 @@ gh attestation verify ./cejel-Windows-x86_64.exe -R BargLabs/cejel
 This is cryptographically signed provenance. It is distinct from Apple Developer ID or
 Microsoft Authenticode code-signing.
 
-**Docker / OCI.** The current container release is `0.4.7`:
+**Docker / OCI.** The current container release is `0.4.9`:
 
 ```bash
-docker run --rm -i -v "$PWD:/workspace:ro" ghcr.io/barglabs/cejel:0.4.7
+docker run --rm -i -v "$PWD:/workspace:ro" ghcr.io/barglabs/cejel:0.4.9
 ```
 
 The image defaults to `cejel-mcp` over stdio. To use the CLI instead:
 
 ```bash
-docker run --rm -v "$PWD:/workspace:ro" --entrypoint cejel ghcr.io/barglabs/cejel:0.4.7 .
+docker run --rm -v "$PWD:/workspace:ro" --entrypoint cejel ghcr.io/barglabs/cejel:0.4.9 .
 ```
 
 The OCI image carries an SBOM, maximum-mode build provenance, and a signed registry
@@ -195,17 +191,15 @@ attestation.
 
 ## Leaderboard
 
-This repo ships the [Cejel OSS trust leaderboard](./leaderboard/leaderboard.md): elite OSS
-projects, the public Cejel repository itself, and one explicitly labeled transparency
-snapshot from the private studio monorepo where Cejel was built, with a per-repository
-evidence report for every row under [`leaderboard/reports/`](./leaderboard/reports/). The
-board is also hosted at [cejel.dev](https://cejel.dev). Every score is produced by the same
-sealed public scorer used by `npx @cejel/cejel@latest .`; no private domain collector contributes.
-For each public-repository row, check out the immutable source commit printed in its report
-and run the public scorer to reproduce the score, verdict, measured coverage, and evidence.
-The private Alfred snapshot discloses its limitation instead: its source commit and withheld
-locations are not publicly available, so that row is not independently reproducible and is
-not presented as a public-repository self-score.
+The [Cejel OSS trust leaderboard](https://cejel.dev/leaderboard/) is hosted on cejel.dev,
+which is the single current board. This repository no longer distributes a second copy of
+its scores or certificates. The board records its producing package version, rubric,
+run date, pinned public revisions, and reproduction instructions for that particular run.
+The private Alfred transparency snapshot is not independently reproducible.
+
+The site's History section preserves the **2026-08-18 withdrawal**: the earlier
+sealed-public-scorer reproducibility claim was false. The stale prospective-rubric copy
+previously linked here has been removed; it must not be treated as current evidence.
 
 ### Redaction policy
 
@@ -519,7 +513,7 @@ The OCI image is an alternative when Docker is the preferred execution boundary.
 the host path with the repository OpenClaw should allow Cejel to read:
 
 ```bash
-npx -y openclaw@latest mcp set cejel-oci '{"command":"docker","args":["run","--rm","-i","-v","/absolute/path/to/repo:/workspace:ro","ghcr.io/barglabs/cejel:0.4.7"]}'
+npx -y openclaw@latest mcp set cejel-oci '{"command":"docker","args":["run","--rm","-i","-v","/absolute/path/to/repo:/workspace:ro","ghcr.io/barglabs/cejel:0.4.9"]}'
 npx -y openclaw@latest mcp doctor cejel-oci --probe
 ```
 
@@ -546,6 +540,47 @@ part of the scoring guarantee. If the tracked-file inventory fails unexpectedly,
 HTML, and markdown certificates declare that the scanner used its bounded directory fallback
 instead of silently presenting the two inventories as equivalent.
 
+## What a certificate's scope means
+
+A certificate scores the repository tree at one pinned revision, and only that tree. That
+boundary is deliberate: a certificate that reached outside the pinned tree could not be
+reproduced by whoever receives it, and reproducibility is the entire product. Scoring only the
+pinned tree is correct — the gap was that nothing on the certificate itself told a reader which
+kind of statement they were holding. A repository whose regression suite lives in a separate
+repository, checked out and run by its own CI, is correctly reported as having zero test files
+against its source files. That statement is true about the tree and false about the system, and a
+reader with no other context cannot tell the difference.
+
+Every certificate now carries a standing scope line, in the "How to read this certificate"
+section on every surface (HTML, Markdown, terminal), regardless of verdict: the certificate is a
+statement about the repository tree at the pinned revision, not about the system that tree
+belongs to, and evidence outside that tree is neither seen nor claimed to be absent. This is
+additive, not a hedge — a finding that says evidence was not found in this tree stays exactly as
+stated.
+
+Four specific situations can make the tree's own conclusion misleading about the system it
+belongs to:
+
+- **A test suite kept in a separate repository.** Not detectable from inside the pinned tree —
+  there is no reliable signal that a sibling repository exists. Covered by the standing scope
+  line above, not a conditional disclosure.
+- **CI configuration that changes into a different working directory before running its checks.**
+  Also not detectable without executing the CI job itself, which the offline scanner does not do.
+  Covered by the standing scope line above.
+- **A large implementation file that exceeds the read limit.** This one is detectable, and
+  disclosed conditionally when it happens: when a file above the size ceiling is the reason a
+  specific signal has nothing to measure, the certificate's scan-limitations section names it —
+  "declined a large implementation file that exceeded the repository content size limit" — rather
+  than folding it into the generic coverage-limit sentence used for an extension exclusion or a
+  non-regular file. Today this fires for two A3 signals (health/readiness route detection and
+  observability-marker counting); it extends to more signals as they adopt the same per-signal
+  attribution.
+- **A recognized-but-nonfunctional package script**, such as npm's auto-generated
+  `"test": "echo \"Error: no test specified\" && exit 1"` placeholder being credited the same as a
+  real test runner. This was a detector defect, not a scope-disclosure gap — Cejel now checks the
+  `test` script's content against known test-runner invocations rather than crediting it by key
+  presence alone, so no separate disclosure line is needed for it.
+
 ## Help validate Cejel
 
 Cejel does not collect telemetry. External validation is therefore opt-in and inspectable:
@@ -680,7 +715,7 @@ published in public.
 
 **No rubric change re-scores you silently.** Every change to scoring behavior requires a
 `WITAN_RUBRIC_VERSION` bump and a corpus-wide before/after delta published in
-[`docs/leaderboard/RUBRIC_CHANGELOG.md`](../../docs/leaderboard/RUBRIC_CHANGELOG.md) — score,
+[`leaderboard/RUBRIC_CHANGELOG.md`](./leaderboard/RUBRIC_CHANGELOG.md) — score,
 verdict, and rank for every repository, "no repository moved" stated explicitly when that is
 the result. A build that changes scoring without both fails; see that file's `v2` entry for
 the home-field fix above as the first rubric change recorded this way.

package/dist/calibration/llm-detector.js

@@ -5,20 +5,20 @@ import {
   deriveProductIdentity,
   runCejelScan,
   serializeWitanReport
-} from "../chunk-QTLLASOO.js";
+} from "../chunk-TUUNJP27.js";
 import {
   listCejelLlmPackFiles
-} from "../chunk-EP7YYWEP.js";
-import "../chunk-OIGCYULH.js";
+} from "../chunk-IN2LPGGU.js";
+import "../chunk-IHT7B6L7.js";
 import {
   external_exports
-} from "../chunk-UYJBSQCV.js";
+} from "../chunk-GKYTLWQK.js";
 import {
   init_esm_shims,
   readRepoText,
   recordContentSkip,
   recordFilesystemSkip
-} from "../chunk-ZNVILRHK.js";
+} from "../chunk-PTZU6G4E.js";
 
 // src/calibration/llm-detector.ts
 init_esm_shims();

package/dist/{chunk-UYJBSQCV.js → chunk-GKYTLWQK.js}

@@ -4,7 +4,7 @@ const require = __cejelCreateRequire(import.meta.url);
 import {
   __export,
   init_esm_shims
-} from "./chunk-ZNVILRHK.js";
+} from "./chunk-PTZU6G4E.js";
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};

package/dist/{chunk-OIGCYULH.js → chunk-IHT7B6L7.js}

@@ -3,7 +3,7 @@ import { createRequire as __cejelCreateRequire } from 'node:module';
 const require = __cejelCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-ZNVILRHK.js";
+} from "./chunk-PTZU6G4E.js";
 
 // src/witan/git-exec.ts
 init_esm_shims();

package/dist/{chunk-EP7YYWEP.js → chunk-IN2LPGGU.js}

@@ -5,10 +5,10 @@ import {
   describeGitFailure,
   execGit,
   isExpectedGitAbsence
-} from "./chunk-OIGCYULH.js";
+} from "./chunk-IHT7B6L7.js";
 import {
   init_esm_shims
-} from "./chunk-ZNVILRHK.js";
+} from "./chunk-PTZU6G4E.js";
 
 // src/packs/llm/files.ts
 init_esm_shims();

package/dist/{chunk-XHAETB7N.js → chunk-IQ42TE5H.js}

@@ -7,7 +7,7 @@ import {
   __filename,
   __require,
   init_esm_shims
-} from "./chunk-ZNVILRHK.js";
+} from "./chunk-PTZU6G4E.js";
 
 // node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({

package/dist/{chunk-ZNVILRHK.js → chunk-PTZU6G4E.js}

@@ -62,28 +62,58 @@ var MAX_REPOSITORY_CONTENT_BYTES = 512e3;
 init_esm_shims();
 import { closeSync, lstatSync, openSync, readFileSync, readSync } from "fs";
 import { resolve } from "path";
+var READ_FAILURE_REASONS = /* @__PURE__ */ new Set(["unreadable", "denied_path"]);
+function isReadFailureReason(reason) {
+  return READ_FAILURE_REASONS.has(reason);
+}
+function classifyAbstentionReason(reasons) {
+  if (!reasons || reasons.size === 0) return {};
+  for (const reason of reasons) {
+    if (isReadFailureReason(reason)) return {};
+  }
+  const priority = [
+    "too_large",
+    "excluded_by_extension",
+    "non_regular_file"
+  ];
+  const chosen = priority.find((reason) => reasons.has(reason));
+  return chosen ? { insufficientDataReason: chosen } : {};
+}
 function contentReadSignalKey(criterionId, signalId) {
   return [criterionId, signalId].join(":");
 }
 var activeSession;
+function addSkipReason(map, key, reason) {
+  const existing = map.get(key);
+  if (existing) {
+    existing.add(reason);
+  } else {
+    map.set(key, /* @__PURE__ */ new Set([reason]));
+  }
+}
 function errnoClass(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return null;
   const code = error.code;
   return typeof code === "string" && /^E[A-Z0-9_]+$/.test(code) ? code : null;
 }
+function attributeSkip(session, criterion, signals, reason) {
+  session.affectedCriteria.add(criterion);
+  if (signals && signals.length > 0) {
+    for (const signal of signals) {
+      const key = contentReadSignalKey(criterion, signal);
+      session.affectedSignals.add(key);
+      addSkipReason(session.signalSkipReasons, key, reason);
+    }
+  } else {
+    session.unattributedCriteria.add(criterion);
+    addSkipReason(session.criterionSkipReasons, criterion, reason);
+  }
+}
 function recordSkip(path2, reason, errno, affectsCurrentCriterion = false, deduplicate = false) {
   const session = activeSession;
   if (!session) return;
   if (affectsCurrentCriterion && session.criterion) {
-    session.affectedCriteria.add(session.criterion);
-    const signals = session.signals;
-    if (signals && signals.length > 0) {
-      for (const signal of signals) {
-        session.affectedSignals.add(contentReadSignalKey(session.criterion, signal));
-      }
-    } else {
-      session.unattributedCriteria.add(session.criterion);
-    }
+    attributeSkip(session, session.criterion, session.signals, reason);
   }
   if (deduplicate) {
     const key = `${resolve(path2)}\0${reason}\0${errno ?? ""}`;
@@ -121,7 +151,9 @@ function trackContentReads(_repoPath, collect) {
       summary: summaryFor(existing),
       affectedCriteria: existing.affectedCriteria,
       affectedSignals: existing.affectedSignals,
-      unattributedCriteria: existing.unattributedCriteria
+      unattributedCriteria: existing.unattributedCriteria,
+      criterionSkipReasons: existing.criterionSkipReasons,
+      signalSkipReasons: existing.signalSkipReasons
     };
   }
   const session = {
@@ -136,7 +168,10 @@ function trackContentReads(_repoPath, collect) {
     deduplicatedSkips: /* @__PURE__ */ new Set(),
     affectedCriteria: /* @__PURE__ */ new Set(),
     affectedSignals: /* @__PURE__ */ new Set(),
-    unattributedCriteria: /* @__PURE__ */ new Set()
+    unattributedCriteria: /* @__PURE__ */ new Set(),
+    criterionSkipReasons: /* @__PURE__ */ new Map(),
+    signalSkipReasons: /* @__PURE__ */ new Map(),
+    withheldPaths: /* @__PURE__ */ new Map()
   };
   activeSession = session;
   try {
@@ -146,7 +181,9 @@ function trackContentReads(_repoPath, collect) {
       summary: summaryFor(session),
       affectedCriteria: session.affectedCriteria,
       affectedSignals: session.affectedSignals,
-      unattributedCriteria: session.unattributedCriteria
+      unattributedCriteria: session.unattributedCriteria,
+      criterionSkipReasons: session.criterionSkipReasons,
+      signalSkipReasons: session.signalSkipReasons
     };
   } finally {
     activeSession = void 0;
@@ -183,15 +220,21 @@ function withContentReadSignals(criterionId, signalIds, collect) {
 function recordContentSkip(path2, reason, deduplicate = false) {
   recordSkip(path2, reason, void 0, false, deduplicate);
 }
-function recordContentSkipForCriteria(path2, reason, criteria, deduplicate = false) {
+function registerWithheldRepoPath(relativePath, reason) {
   const session = activeSession;
-  if (session) {
-    for (const criterion of criteria) {
-      session.affectedCriteria.add(criterion);
-      session.unattributedCriteria.add(criterion);
-    }
+  if (!session) return;
+  addSkipReason(session.withheldPaths, relativePath, reason);
+}
+function abstainSignalOnWithheldPaths(criterionId, signalId, wouldHaveRead) {
+  const session = activeSession;
+  if (!session) return false;
+  let abstained = false;
+  for (const [path2, reasons] of session.withheldPaths) {
+    if (!wouldHaveRead(path2)) continue;
+    abstained = true;
+    for (const reason of reasons) attributeSkip(session, criterionId, [signalId], reason);
   }
-  recordSkip(path2, reason, void 0, false, deduplicate);
+  return abstained;
 }
 function recordFilesystemSkip(path2, error, deniedContext = false, deduplicate = true) {
   const errno = errnoClass(error);
@@ -264,13 +307,15 @@ export {
   __filename,
   init_esm_shims,
   MAX_REPOSITORY_CONTENT_BYTES,
+  classifyAbstentionReason,
   contentReadSignalKey,
   trackContentReads,
   withContentReadCriterion,
   withContentReadSignal,
   withContentReadSignals,
   recordContentSkip,
-  recordContentSkipForCriteria,
+  registerWithheldRepoPath,
+  abstainSignalOnWithheldPaths,
   recordFilesystemSkip,
   readRepoText,
   readRepoTextPrefix