@cejel/cejel 0.1.5 → 0.1.7

package/README.md

@@ -31,9 +31,15 @@ No account, no key, no signup.
 **Single-file binary.** One file. No Node, no npm, no `node_modules`, nothing installed.
 
 ```bash
+set -eu
 asset="cejel-$(uname -s)-$(uname -m)"
 curl -fsSL "https://github.com/BargLabs/cejel/releases/latest/download/$asset" -o "$asset"
 curl -fsSL https://github.com/BargLabs/cejel/releases/latest/download/SHA256SUMS -o SHA256SUMS
+checksum_entry_count="$(awk -v asset="$asset" '$2 == asset { count++ } END { print count + 0 }' SHA256SUMS)"
+if [ "$checksum_entry_count" -ne 1 ]; then
+  echo "Expected exactly one SHA256SUMS entry for $asset; found $checksum_entry_count" >&2
+  exit 1
+fi
 if command -v sha256sum >/dev/null; then
   grep "  $asset$" SHA256SUMS | sha256sum -c -
 else
@@ -64,7 +70,7 @@ The npm package is scoped as `@cejel/cejel`; its executable remains the short co
 **GitHub Action** — score every PR and publish the badge:
 
 ```yaml
-- uses: BargLabs/cejel/action@v1
+- uses: BargLabs/cejel/action@v0.1.6
   with:
     min-score: "2.5"   # optional: fail the build below this
 ```
@@ -79,27 +85,62 @@ node dist/index.js .
 
 Released binaries: `cejel-Darwin-arm64`, `cejel-Darwin-x86_64`, `cejel-Linux-aarch64`, and
 `cejel-Linux-x86_64`. The release also carries `SHA256SUMS`; each binary is executed against
-the source build and with networking denied before attachment.
+the source build and with networking denied before attachment. Releases from v0.1.6 also
+carry a Sigstore bundle containing GitHub's signed build-provenance attestation for all four
+binaries. Verify a downloaded binary with:
+
+```bash
+gh attestation verify ./cejel-Darwin-arm64 -R BargLabs/cejel
+```
+
+This is cryptographically signed provenance. It is distinct from Apple Developer ID or
+Microsoft Authenticode code-signing.
+
+**Docker / OCI.** The same MCP server is published as a non-root, multi-platform image:
+
+```bash
+docker run --rm -i -v "$PWD:/workspace:ro" ghcr.io/barglabs/cejel:0.1.6
+```
+
+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.1.6 .
+```
+
+Beginning with v0.1.7, the standard CLI identity flags are also available directly, while an
+invocation without arguments continues to start the MCP server:
+
+```bash
+docker run --rm ghcr.io/barglabs/cejel:0.1.7 --version
+docker run --rm ghcr.io/barglabs/cejel:0.1.7 --help
+```
+
+The OCI image carries an SBOM, maximum-mode build provenance, and a signed registry
+attestation. It is also the package referenced by [`server.json`](./server.json) for the
+Official MCP Registry.
 
 ## Leaderboard
 
-This repo ships the [Cejel OSS trust leaderboard](./leaderboard/leaderboard.md): the whole
-corpus scored and published in the open — elite OSS projects, Cejel itself, and the private
-studio monorepo Cejel was built inside — 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 on this board is produced by the same sealed
-public scorer used by `npx @cejel/cejel .` — check out the source commit printed in the
-report, run the tool, and you will get this number. A required guard does exactly that for
-every corpus row and compares score, verdict, measured coverage, and evidence. No private
-domain collector contributes to any published score, ours included; nobody is exempt.
+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 .`; 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.
 
 ### Redaction policy
 
 A path is published exactly when the reader can check it. Every public repository on the
 board cites full evidence paths and line numbers, everywhere, in every artifact — a
-certificate whose evidence you cannot open is not evidence. The two private-repository
-entries (this monorepo's own transparency entry, and Cejel's own source sub-package inside
-it) never cite a source path, anywhere, in any field or format — but the finding itself, its
+certificate whose evidence you cannot open is not evidence. The private-repository entry
+(the studio monorepo's transparency snapshot) never cites a source path, anywhere, in any
+field or format — but the finding itself, its
 dimension, status, score, and content hash always survive; only the location is withheld,
 marked uniformly as "path withheld — private repository". Redaction removes a location, never
 a fact: a private repository failing its own check still shows up on its certificate, by
@@ -127,10 +168,11 @@ better-evidenced rows.
 ## Usage
 
 ```bash
-./cejel .
+./cejel scan .
 ```
 
-Scores the current directory with sensible defaults: no flags, no signup, fully offline.
+`scan` scores the current directory with sensible defaults: no signup, fully offline. The
+original `./cejel .` form remains supported as a compatibility shorthand.
 Prints a concise terminal certificate and writes to `.cejel/`:
 
 - `report.json` — the full structured report; scored runs carry numeric headline scores and a
@@ -147,6 +189,16 @@ statement, but it does not pretend to be an independent signer. Until a customer
 or provenance system signs it, `assurance.status` is `unsigned` and `issuer` is
 `self-generated`. An abstained scan carries only the refusal reason, never a numeric score.
 
+Verify that an emitted report still matches its attestation:
+
+```bash
+./cejel verify .cejel/report.json .cejel/attestation.json
+```
+
+This verifies the report schema and the report-to-attestation digest, repository, rubric,
+timestamp, and outcome binding. It does not verify a signature or signer identity; the command
+prints that boundary on every successful verification.
+
 ### Flags
 
 - `<path>` — repo to score (default: current directory)
@@ -272,7 +324,7 @@ a configurable `min-score` threshold. The scoring step makes no network calls an
 secrets.
 
 ```yaml
-- uses: BargLabs/cejel/action@v1
+- uses: BargLabs/cejel/action@v0.1.6
   with:
     min-score: '2.5' # optional; omit to never fail the check
 ```
@@ -284,6 +336,10 @@ server over stdio, so any MCP client (Claude Code, Cowork, Cursor, Codex) can re
 trust certificate as a tool call. It wraps the exact same scan the CLI runs — same scores,
 same verdict — and is listed on Smithery via the repo's `smithery.yaml`.
 
+The canonical discovery manifest is [`server.json`](./server.json), published under
+`io.github.BargLabs/cejel` in the Official MCP Registry. Its npm ownership metadata,
+OCI ownership label, image version, and registry version are checked together before release.
+
 Add it to an MCP client config:
 
 ```json
@@ -311,7 +367,7 @@ and the server writes no files.
 
 ## What "offline" means here
 
-Scoring a repo — `cejel .` itself, and the Action's scoring step — makes zero network
+Scoring a repo — `cejel scan .` itself, and the Action's scoring step — makes zero network
 calls: no telemetry, no signup, no model call. Fetching the `@cejel/cejel` package the
 first time (like any npm-distributed CLI, including this Action's own dependency install)
 does need network; that's a one-time install cost, not part of the scoring guarantee.
@@ -347,7 +403,7 @@ enforced structurally — the public artifacts are built from filtered data rath
 rendered and then scrubbed — and a build that would emit a private path fails rather than
 publishes.
 
-**What we exclude from ranking.** The v3 repository scanner does not evaluate B1 (dispatch
+**What we exclude from ranking.** The v5 repository scanner does not evaluate B1 (dispatch
 trace completeness) or B5 (verified learning trace) for repository inputs, including ours:
 both are always *not applicable* in a repository certificate. They remain defined in the
 rubric for structured substrate evidence, but that evidence is not accepted by this scanner.
@@ -392,6 +448,18 @@ scoring tool that has not been checked:
   and a required guard re-scores every row and compares score, verdict, coverage, and
   evidence. The honest correction moved Alfred's Code score from 2.5 to 2.4 and A5 from 2.9
   to 2.4. It is less flattering and more trustworthy.
+- **A tracked symlink could make evidence depend on files outside the checkout.** Repository
+  discovery used a regular-file check that followed symlinks, so a tracked link could escape
+  the immutable source snapshot. Rubric v4 accepts only tracked regular files. On the pinned
+  corpus this removes a duplicate claim source from Zod: A5 moves from 2.2 to 2.0 while its
+  rounded Code score, Overall, verdict, and rank stay unchanged. The full 24-row delta is in
+  the rubric changelog.
+- **A pinned commit could score differently depending on unrelated Git refs in the clone.**
+  History evidence traversed every local and remote-tracking ref, including branches that were
+  not ancestors of the revision being certified. The required clean-clone reproduction job
+  caught the mismatch. Rubric v5 scans only `HEAD` ancestry, so ambient branch state can no
+  longer add evidence or change coverage. The complete v4-to-v5 delta is published in the
+  rubric changelog.
 - **Version 0.1.1 rejected `--help` and `--version` as unknown flags, and read `-h` as a
   directory path.** Version 0.1.2 handles both aliases before positional-path parsing and
   derives its printed version from the package manifest.

package/dist/{chunk-A7NZKJ5H.js → chunk-OMIRVZSF.js}

@@ -4074,7 +4074,9 @@ var NEVER = INVALID;
 var WITAN_RUBRIC_VERSION_V1 = "witan-rubric-v1-2026-06-24";
 var WITAN_RUBRIC_VERSION_V2 = "witan-rubric-v2-2026-07-12";
 var WITAN_RUBRIC_VERSION_V3 = "witan-rubric-v3-2026-07-13";
-var WITAN_RUBRIC_VERSION = WITAN_RUBRIC_VERSION_V3;
+var WITAN_RUBRIC_VERSION_V4 = "witan-rubric-v4-2026-07-18";
+var WITAN_RUBRIC_VERSION_V5 = "witan-rubric-v5-2026-07-18";
+var WITAN_RUBRIC_VERSION = WITAN_RUBRIC_VERSION_V5;
 var WITAN_TRADING_RUBRIC_VERSION_V0 = "witan-trading-rubric-v0-2026-07-01";
 var WITAN_CRITERION_IDS = [
   "A1",
@@ -4509,12 +4511,13 @@ function criteriaByCategory(report, category) {
 function renderCriterionColumn(title, criteria) {
   const applicable = criteria.filter((criterion) => criterion.status !== "not_applicable");
   const notApplicable = criteria.filter((criterion) => criterion.status === "not_applicable");
+  const notApplicableGroup = notApplicable.length > 0 ? `
+        ${renderNotApplicableGroup(notApplicable)}` : "";
   return `<section class="criteria-column">
         <h2>${escapeHtml(title)}</h2>
         <div class="criteria-list">
           ${applicable.map(renderCriterionCard).join("")}
-        </div>
-        ${notApplicable.length > 0 ? renderNotApplicableGroup(notApplicable) : ""}
+        </div>${notApplicableGroup}
       </section>`;
 }
 function renderNotApplicableGroup(criteria) {
@@ -4863,11 +4866,55 @@ function createWitanAttestation(report, options) {
     }
   });
 }
+function verifyWitanAttestationBinding(statement, report, options = {}) {
+  const parsed = WitanAttestationStatementSchema.safeParse(statement);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      errors: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+    };
+  }
+  const errors = [];
+  const expectedReportHash = options.reportSha256 ?? hashWitanReport(report);
+  const subject = parsed.data.subject[0];
+  const subjectHash = subject?.digest.sha256;
+  if (subjectHash !== expectedReportHash) errors.push("subject digest does not match report.json");
+  if (subject?.name !== `${report.productSlug}/report.json`) {
+    errors.push("subject name does not match report repository identity");
+  }
+  if (parsed.data.predicate.report.sha256 !== expectedReportHash) {
+    errors.push("predicate report digest does not match report.json");
+  }
+  if (parsed.data.predicate.rubricVersion !== report.rubricVersion) {
+    errors.push("rubric version does not match report.json");
+  }
+  if (parsed.data.predicate.generatedAt !== report.generatedAt) {
+    errors.push("generated timestamp does not match report.json");
+  }
+  if (parsed.data.predicate.repository.headSha !== report.repo.headSha) {
+    errors.push("repository revision does not match report.json");
+  }
+  if (parsed.data.predicate.repository.productSlug !== report.productSlug) {
+    errors.push("repository product slug does not match report.json");
+  }
+  if (parsed.data.predicate.repository.url !== report.repo.url) {
+    errors.push("repository URL does not match report.json");
+  }
+  const outcome = parsed.data.predicate.outcome;
+  if (report.verdict === "insufficient_source") {
+    if (outcome.status !== "abstained" || outcome.reason !== report.insufficientSourceReason) {
+      errors.push("attestation does not preserve the report abstention");
+    }
+  } else if (outcome.status !== "scored" || outcome.overallScore !== report.overallScore || outcome.codeTrustScore !== report.codeTrustScore || outcome.processTrustScore !== report.processTrustScore) {
+    errors.push("attested scores do not match report.json");
+  }
+  return { valid: errors.length === 0, errors };
+}
 
 // src/witan/repo-signals.ts
 import { execFileSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import { readFileSync, readdirSync, realpathSync, statSync } from "fs";
+import { lstatSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
 import { basename, join, relative, resolve, sep } from "path";
 
 // src/witan/json-safe.ts
@@ -6442,7 +6489,9 @@ function listGitTrackedFiles(repoPath) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!output) return [];
-    return output.split("\n").filter((file) => file.length > 0 && !isHardExcludedPath(file)).sort();
+    return output.split("\n").filter(
+      (file) => file.length > 0 && !isHardExcludedPath(file) && isRegularFile(join(repoPath, file))
+    ).sort();
   } catch {
     return null;
   }
@@ -6960,7 +7009,7 @@ function findRootPackageJson(repoFiles) {
 }
 function isRegularFile(path) {
   try {
-    return statSync(path).isFile();
+    return lstatSync(path).isFile();
   } catch {
     return false;
   }
@@ -7030,7 +7079,7 @@ function readCredentialHistoryEntries(repoPath) {
     entries.push(entry);
   };
   try {
-    const commits = execFileSync("git", ["rev-list", "--all"], {
+    const commits = execFileSync("git", ["rev-list", "HEAD"], {
       cwd: repoPath,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -7089,7 +7138,7 @@ function readDeletedCredentialHistoryPaths(repoPath) {
   try {
     const output = execFileSync(
       "git",
-      ["log", "--all", "--diff-filter=D", "--name-status", "--format=commit:%H"],
+      ["log", "HEAD", "--diff-filter=D", "--name-status", "--format=commit:%H"],
       {
         cwd: repoPath,
         encoding: "utf8",
@@ -7115,7 +7164,7 @@ function readHistoryCommitsForPath(repoPath, path) {
   try {
     const output = execFileSync(
       "git",
-      ["log", "--all", "--diff-filter=AM", "--format=%H", "--", path],
+      ["log", "HEAD", "--diff-filter=AM", "--format=%H", "--", path],
       {
         cwd: repoPath,
         encoding: "utf8",
@@ -7273,7 +7322,7 @@ function hasEnvPathInGitHistory(repoPath) {
   try {
     const output = execFileSync(
       "git",
-      ["log", "--all", "--diff-filter=AM", "--name-only", "--format="],
+      ["log", "HEAD", "--diff-filter=AM", "--name-only", "--format="],
       {
         cwd: repoPath,
         encoding: "utf8",
@@ -7615,7 +7664,7 @@ function rawToolName(raw) {
   if (typeof obj.tool === "string" && obj.tool.length > 0) return obj.tool;
   return "scorecard";
 }
-function parseIngestFile(filePath) {
+function parseIngestFile(filePath, options = {}) {
   let raw;
   try {
     raw = JSON.parse(stripBom(readFileSync5(filePath, "utf8")));
@@ -7624,7 +7673,7 @@ function parseIngestFile(filePath) {
     throw new Error(`Cejel: could not parse ingest file as JSON: ${filePath} (${message})`);
   }
   let signals;
-  if (looksLikeSarif(raw)) signals = parseSarifJson(raw);
+  if (looksLikeSarif(raw)) signals = parseSarifJson(raw, options.extraSarifDimensionRules);
   else if (looksLikeScorecard(raw)) signals = parseScorecardJson(raw);
   else if (isGenericSignalDocument(raw)) signals = parseGenericJson(raw);
   if (!signals) {
@@ -7888,7 +7937,7 @@ function mergeSignalsByCriterion(signals) {
   return merged;
 }
 function usesMetricScoring(rubricVersion) {
-  return rubricVersion === WITAN_RUBRIC_VERSION_V1 || rubricVersion === WITAN_RUBRIC_VERSION_V2 || rubricVersion === WITAN_RUBRIC_VERSION_V3 || rubricVersion === WITAN_TRADING_RUBRIC_VERSION_V0;
+  return rubricVersion === WITAN_RUBRIC_VERSION_V1 || rubricVersion === WITAN_RUBRIC_VERSION_V2 || rubricVersion === WITAN_RUBRIC_VERSION_V3 || rubricVersion === WITAN_RUBRIC_VERSION_V4 || rubricVersion === WITAN_RUBRIC_VERSION_V5 || rubricVersion === WITAN_TRADING_RUBRIC_VERSION_V0;
 }
 function unmeasuredStatus(rubricVersion) {
   return rubricVersion === WITAN_TRADING_RUBRIC_VERSION_V0 ? "unverified" : "insufficient_data";
@@ -8186,11 +8235,13 @@ export {
   ZodFirstPartyTypeKind,
   objectType,
   external_exports,
+  WitanReportSchema,
   formatExternalSourceLine,
   renderWitanHtmlReport,
   renderWitanBadgeEndpoint,
   renderWitanBadgeSvg,
   serializeWitanReport,
   createWitanAttestation,
+  verifyWitanAttestationBinding,
   runCejelScan
 };

package/dist/index.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import {
+  WitanReportSchema,
   createWitanAttestation,
   formatExternalSourceLine,
   renderWitanBadgeEndpoint,
   renderWitanBadgeSvg,
   renderWitanHtmlReport,
   runCejelScan,
-  serializeWitanReport
-} from "./chunk-A7NZKJ5H.js";
+  serializeWitanReport,
+  verifyWitanAttestationBinding
+} from "./chunk-OMIRVZSF.js";
 
 // src/index.ts
+import { createHash } from "crypto";
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
 import { pathToFileURL } from "url";
@@ -121,18 +124,31 @@ var CLI_FLAG_TOKENS = CLI_FLAG_SPECS.flatMap(
 var CLI_FLAG_KIND_BY_TOKEN = new Map(
   CLI_FLAG_SPECS.flatMap((spec) => spec.tokens.map((token) => [token, spec.kind]))
 );
+function readCliManifest() {
+  return JSON.parse(
+    readFileSync(new URL("../package.json", import.meta.url), "utf8")
+  );
+}
 function cliVersion() {
   if (typeof __CEJEL_SEA_VERSION__ === "string" && __CEJEL_SEA_VERSION__.length > 0) {
     return __CEJEL_SEA_VERSION__;
   }
-  const manifest = JSON.parse(
-    readFileSync(new URL("../package.json", import.meta.url), "utf8")
-  );
+  const manifest = readCliManifest();
   if (typeof manifest.version !== "string" || manifest.version.length === 0) {
     throw new Error("Cejel package manifest has no version.");
   }
   return manifest.version;
 }
+function cliPackageName() {
+  if (typeof __CEJEL_SEA_PACKAGE_NAME__ === "string" && __CEJEL_SEA_PACKAGE_NAME__.length > 0) {
+    return __CEJEL_SEA_PACKAGE_NAME__;
+  }
+  const manifest = readCliManifest();
+  if (typeof manifest.name !== "string" || manifest.name.length === 0) {
+    throw new Error("Cejel package manifest has no name.");
+  }
+  return manifest.name;
+}
 var usageOptionLabels = CLI_FLAG_SPECS.map(
   (spec) => `${spec.tokens.join(", ")}${"value" in spec && spec.value ? ` ${spec.value}` : ""}`
 );
@@ -140,11 +156,19 @@ var usageOptionLabelWidth = Math.max(...usageOptionLabels.map((label) => label.l
 var usageOptions = CLI_FLAG_SPECS.map(
   (spec, index) => `  ${usageOptionLabels[index]?.padEnd(usageOptionLabelWidth)}  ${spec.description}`
 ).join("\n");
+var NPX_PACKAGE_NAME = cliPackageName();
 var USAGE = `cejel \u2014 a trust certificate for your codebase
 
-Usage:  npx cejel [path] [options]
+Usage:
+  npx ${NPX_PACKAGE_NAME} [path] [options]
+  npx ${NPX_PACKAGE_NAME} scan [path] [options]
+  npx ${NPX_PACKAGE_NAME} verify <report.json> <attestation.json>
+
+Commands:
+  scan    score a repository (default when the command is omitted)
+  verify  verify report/attestation binding only; no signature or signer identity check
 
-Options:
+Scan options:
 ${usageOptions}
 
 Runs entirely offline. No code leaves your machine.
@@ -155,7 +179,11 @@ async function main() {
   process.exitCode = exitCode;
 }
 async function runWitanFreeCli(args) {
-  const options = parseArgs(args);
+  const invocation = parseCliInvocation(args);
+  if (invocation.command === "verify") {
+    return runVerifyBinding(invocation.reportPath, invocation.attestationPath);
+  }
+  const options = invocation.options;
   if (options.showVersion) {
     process.stdout.write(`${cliVersion()}
 `);
@@ -217,6 +245,80 @@ Wrote:
   }
   return 0;
 }
+function parseCliInvocation(args) {
+  const command = args[0];
+  if (command === "scan") {
+    return { command: "scan", options: parseArgs(args.slice(1)) };
+  }
+  if (command === "verify") {
+    const verifyArgs = args.slice(1);
+    if (verifyArgs.some((arg) => arg === "-h" || arg === "--help")) {
+      return { command: "scan", options: parseArgs(["--help"]) };
+    }
+    if (verifyArgs.some((arg) => arg === "-v" || arg === "--version")) {
+      return { command: "scan", options: parseArgs(["--version"]) };
+    }
+    if (verifyArgs.length !== 2) {
+      throw new Error(`Usage: npx ${NPX_PACKAGE_NAME} verify <report.json> <attestation.json>`);
+    }
+    const [reportPath, attestationPath] = verifyArgs;
+    if (!reportPath || !attestationPath) {
+      throw new Error(`Usage: npx ${NPX_PACKAGE_NAME} verify <report.json> <attestation.json>`);
+    }
+    return {
+      command: "verify",
+      reportPath: resolve(reportPath),
+      attestationPath: resolve(attestationPath)
+    };
+  }
+  return { command: "scan", options: parseArgs(args) };
+}
+function runVerifyBinding(reportPath, attestationPath) {
+  const reportArtifact = readJsonArtifact(reportPath, "report");
+  const reportResult = WitanReportSchema.safeParse(reportArtifact.value);
+  if (!reportResult.success) {
+    const members = reportResult.error.issues.map(
+      (issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`
+    );
+    process.stderr.write(
+      `Cejel: report validation failed:
+${members.map((member) => `  - ${member}`).join("\n")}
+`
+    );
+    return 1;
+  }
+  const statement = readJsonArtifact(attestationPath, "attestation");
+  const reportSha256 = createHash("sha256").update(reportArtifact.contents).digest("hex");
+  const result = verifyWitanAttestationBinding(statement.value, reportResult.data, {
+    reportSha256
+  });
+  if (!result.valid) {
+    process.stderr.write(
+      `Cejel: report/attestation binding verification failed:
+${result.errors.map((error) => `  - ${error}`).join("\n")}
+`
+    );
+    return 1;
+  }
+  process.stdout.write("Cejel: report/attestation binding verified.\n");
+  process.stdout.write("Cejel: signature and signer identity were not verified.\n");
+  return 0;
+}
+function readJsonArtifact(path, label) {
+  let contents;
+  try {
+    contents = readFileSync(path);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cejel: could not read ${label} file ${path}: ${message}`);
+  }
+  try {
+    return { contents, value: JSON.parse(contents.toString("utf8")) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cejel: invalid JSON in ${label} file ${path}: ${message}`);
+  }
+}
 function parseArgs(args) {
   let repoPath;
   let outDir = DEFAULT_OUT_DIR;
@@ -271,7 +373,11 @@ function parseArgs(args) {
       }
       continue;
     }
-    if (repoPath === void 0) repoPath = arg;
+    if (repoPath === void 0) {
+      repoPath = arg;
+    } else {
+      throw new Error(`Unexpected positional argument: ${arg}`);
+    }
   }
   return {
     repoPath: resolve(repoPath ?? "."),
@@ -307,5 +413,6 @@ export {
   CLI_FLAG_TOKENS,
   USAGE,
   parseArgs,
+  parseCliInvocation,
   runWitanFreeCli
 };

package/dist/mcp/index.js

@@ -10,7 +10,7 @@ import {
   renderWitanBadgeSvg,
   renderWitanHtmlReport,
   runCejelScan
-} from "../chunk-A7NZKJ5H.js";
+} from "../chunk-OMIRVZSF.js";
 
 // node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@cejel/cejel",
-  "version": "0.1.5",
+  "version": "0.1.7",
+  "mcpName": "io.github.BargLabs/cejel",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -46,6 +47,7 @@
   "scripts": {
     "build": "tsup",
     "build:sea-js": "tsup --config tsup.public-sea.config.ts",
+    "validate:distribution": "node scripts/validate-distribution-metadata.mjs",
     "prepublishOnly": "pnpm run build",
     "prepack": "pnpm run build",
     "dev": "tsx src/index.ts",