@enwithai/product-check 0.1.0 → 0.3.0

package/ATTRIBUTION.md

@@ -15,8 +15,8 @@
 ## Development provenance
 
 Product Check was written for this repository with substantial AI assistance (Claude Code), directed and reviewed by
-the project's human sponsor. Commits carry a `Co-Authored-By` trailer. It has **no runtime dependencies** and contains
-no vendored third-party code. Test fixtures and the demo application are synthetic; credential-like strings in them
+the project's human sponsor. Commits carry a `Co-Authored-By` trailer. It has **one runtime dependency**, `yaml` (ISC,
+by Eemeli Aro), and contains no vendored third-party code. Test fixtures and the demo application are synthetic; credential-like strings in them
 are generated at run time and are not real.
 
 ## Built on
@@ -33,10 +33,10 @@ references are in [REFERENCES.md](REFERENCES.md). Listing a project does not mea
 
 ## Frameworks
 
-| Framework        | Owner                  | Relationship   | Note                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ---------------- | ---------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| CLEAR (CLEAR CT) | NetworkGain Consulting | `inspired`     | The design of the assessment model — separate Customer, Technology and Trust pillars, CT-T0…T6 lifecycle tiers, points of presence, evidence statuses, the rule that strong pillars never hide weak ones, and hard gates overriding scores — was inspired by NetworkGain's CLEAR CT method (v3.1, internal and unpublished). No text, catalog, prompt or scoring table from it is reproduced, and there is no structural relationship. Wording approved for publication on 2026-10-12. |
-| TRACE            | EnWithAI Technologies  | `not-assessed` | Each finding carries an intent → evidence → remediation → retest chain, which may match TRACE's intent; alignment cannot be stated until the TRACE specification is available.                                                                                                                                                                                                                                                                                                         |
+| Framework        | Owner                  | Relationship   | Note                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ---------------- | ---------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CLEAR (CLEAR CT) | NetworkGain Consulting | `inspired`     | The design of the assessment model — separate Customer, Technology and Trust pillars, CT-T0…T6 lifecycle tiers, points of presence, evidence statuses, the rule that strong pillars never hide weak ones, and hard gates overriding scores — was inspired by NetworkGain's CLEAR CT method (v3.1, internal and unpublished). No text, catalog, prompt or scoring table from it is reproduced, and there is no structural relationship. Wording approved for publication on 2026-10-12. The v3.2 layer added in 0.3.0 (execution phases, finding verification states, closure state machine, release conditions) was likewise inspired by CLEAR CT v3.2 (internal and unpublished); that wording was approved for publication on 2026-11-09. |
+| TRACE            | EnWithAI Technologies  | `not-assessed` | Each finding carries an intent → evidence → remediation → retest chain, which may match TRACE's intent; alignment cannot be stated until the TRACE specification is available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 
 ## Ecosystem
 

package/CHANGELOG.md

@@ -6,6 +6,72 @@ versions may break the results schema, which carries its own `schema_version`, a
 
 ## Unreleased
 
+## 0.3.0 — 2026-11-09
+
+Vibe-code review and verified closure, inspired by CLEAR CT v3.2 (relationship `inspired`; wording approved for publication 2026-11-09). Additive: the results schema stays `0.1.0`, the scan
+pipeline and its outputs are unchanged (the committed demo outputs are byte-identical), and new artifacts carry their
+own assurance schema `0.1.0`. Design: [docs/vibe-code-assurance.md](docs/vibe-code-assurance.md); status:
+[IMPLEMENTATION_AUDIT_v3.2.md](IMPLEMENTATION_AUDIT_v3.2.md).
+
+- New commands: `proof` (VC-P1 author-side proof), `review` (PR_DIFF / PRE_PR_LOCAL layered review), `register`,
+  `transition`, `fix`, `verify` (VC-P5 at the exact fix commit), `keygen`, `approve` (Ed25519-signed), `close`,
+  `accept-risk`, `reject`, `learn`, `fix-packets`, `gate`, `assure`; `blueprint`, `dashboard` and `gate` accept
+  `--from <results.json>`.
+- **Safety-model change (opt-in):** `src/exec/process.ts` is the only module that starts processes: operator-declared
+  commands with `--allow-exec` (argv, no shell, reduced environment, timeout, output cap, digests) and hardened
+  read-only git. The scan pipeline still never executes anything; tests and ESLint enforce the boundary.
+- Six deterministic review lanes, independent verification of findings and external reviewer claims
+  (`--reviewer-findings`), de-duplication, repeat detection and a review-cycle limit with escalation.
+- Risk routing by impacted surface with protected paths, domain owners and an opt-in LOW-risk waiver; approvals bind
+  to the reviewed commit (STALE after a new commit); bots, unsigned names and implementers never count.
+- Closure register with hash-chained transitions and invariant checks on load; signed risk acceptance with expiry;
+  false positives with secondary support for P0/P1; REGRESSED with history; regression corpus.
+- Fix packets, `PRODUCT_CHECK_REVIEW.md`, `PRODUCT_CHECK_BLUEPRINT.md` (Mermaid as-is/to-be),
+  `PRODUCT_CHECK_RELEASE_GATE.md`, `release-gate.json` (GO / CONDITIONAL_GO / NO_GO / UNKNOWN, VC-P0…P7 progress),
+  append-only `review-evidence.jsonl`, and `dashboard/index.html` rendered from those files.
+- Optional versioned adapters: Impact Check 2.0, Spec Check 1.0, Outcome Check 1.0.
+- Ten new JSON Schemas (`assurance-common`, `assurance-policy`, `evidence-record`, `change-review`, `approval`,
+  `verification-run`, `fix-packet`, `closure-register`, `release-gate`, `reviewer-findings`); `validate` checks them.
+- `examples/closure-demo/`: a scripted end-to-end run on a synthetic app.
+
+## 0.2.0 — 2026-10-28
+
+Commons integration and the first CT-T4 controls. Rubric `pc-rubric-0.2` (51 controls; scoring rules unchanged);
+results schema `0.1.0`, additive. Results and baselines written by 0.1.0 still validate and load.
+
+- CT-T4 operational imports ([docs/operational-imports.md](docs/operational-imports.md)): `--openslo` (OpenSLO v1
+  YAML/JSON, repeatable), `--alert-rules` (Prometheus/Mimir rule files, `PrometheusRule`, `/api/v1/rules` JSON,
+  repeatable) and `--service-graph` (Jaeger `/api/dependencies`, `traces_service_graph_request_total` query result).
+  New controls PC-T-18 (SLOs complete), PC-T-19 (every SLO alerted on), PC-T-20 (declared dependencies observed at
+  runtime, with `--architecture-check`); PC-T-14 is now evaluated from these files; the observability PoP is
+  AVAILABLE when they are given.
+- First runtime dependency: `yaml` 2.9.1 (ISC, pinned), used only through `src/parse/yaml.ts` (core schema, unique
+  keys, at most 100 aliases, 10 MiB per file).
+- `--architecture-check <report.json>` (contract `imports.architecture_check`) imports an Architecture Check report
+  (schema 1.0 or 1.1, `analyze`/`check` output). New control **PC-T-17 "Architecture model matches the code"**
+  (technology, CT-T3, weight 1, P2): PASS with no verified drift of medium severity or above, PARTIAL with one
+  `architecture-drift` finding otherwise, NOT_TESTED without a report. Hypotheses and unknowns never count. Rules in
+  `docs/interoperability.md`.
+- Rubric `pc-rubric-0.2` (48 controls; scoring rules unchanged). The scorecard schema accepts `pc-rubric-0.1` and
+  `pc-rubric-0.2`, and integrity recomputation keeps the stored version, so 0.1.0 results still validate and load as
+  retest baselines. Results schema stays `0.1.0`; `imports.architecture_check` is optional in the contract schema.
+- `product-check spec`: reverse-engineers an as-built specification from a repository (pages, endpoints, data
+  entities, integrations, configuration names, auth boundaries, test titles) with evidence for every item. It writes
+  `as-built-spec.json` (new schema `as-built-spec.schema.json`) and a Spec Kit `specs/000-as-built/spec.md` that Spec
+  Check can lint. Intent that code cannot show is left as `[NEEDS CLARIFICATION]`. Source only; nothing executed.
+- `run`/`retest` derive the as-built spec from the same snapshot. The blueprint embeds it as the new optional field
+  `as_is.as_built`, and `as-built-spec.json` plus `specs/000-as-built/spec.md` are written next to the report
+  (`blueprint --out-dir` re-renders them). Traceability now names the as-built requirement a finding touches
+  (`As-built FR-002; requirement PC-…`): pages, endpoints and entities match by file, integrations and configuration
+  only by exact line, and application URLs by path. Scores, verdicts and findings are unchanged.
+- Schema: additive, still `0.1.0`. Existing contracts, observations and baselines remain valid. Results that carry
+  `as_is.as_built` do not validate with the schemas bundled in 0.1.0 and earlier.
+- Dashboard: a sixth view, **As-built spec**, shows the discovered surface, the questions only a person can answer,
+  user stories, and every FR/NFR/SC/EC item with its certainty, source, evidence and linked findings (open or fixed),
+  with type, certainty and text filters. It is rendered from the results JSON like every other view.
+- Demo: the baseline, retest and repository-only examples include the as-built spec, and
+  `examples/vibe-app-demo/output/as-built/` holds the standalone `spec` output. Both are checked against a fresh run.
+
 ## 0.1.0 — 2026-10-12
 
 First release without a pre-release suffix, so `npm install @enwithai/product-check` and `npx @enwithai/product-check` work without a

package/NOTICE.md

@@ -8,9 +8,11 @@ license.
 
 ## Third-party material
 
-Product Check has **no runtime dependencies** and contains no vendored source code. It reads formats defined by others
-(JSON Schema, JUnit XML, HAR, `npm audit` JSON, and the report schemas of Spec Check, Impact Check and Outcome Check);
-no code from those projects is included.
+Product Check has **one runtime dependency**, [`yaml`](https://github.com/eemeli/yaml) 2.9.1 (ISC License, Copyright
+Eemeli Aro), installed from npm and not vendored. It reads formats defined by others (JSON Schema, JUnit XML, HAR,
+`npm audit` JSON, the report schemas of Spec Check, Impact Check, Outcome Check and Architecture Check, OpenSLO,
+Prometheus rule files, Jaeger dependencies and the OpenTelemetry service-graph metrics); no code from those projects
+is included.
 
 ## Trademarks
 

package/README.md

@@ -12,23 +12,30 @@ Customer, Technology and Trust controls, and gives you:
   and that states exactly what it does and does not cover;
 - an **engineering blueprint**: prioritized fixes, acceptance criteria, regression-test candidates and one
   **work packet** per fix that you (or any coding agent) can act on;
-- a **local dashboard** and a **retest** loop that shows verified fixes, regressions and trends.
+- a **local dashboard** and a **retest** loop that shows verified fixes, regressions and trends;
+- **vibe-code review and verified closure** (new in 0.3.0; design inspired by CLEAR CT v3.2): layered change review with independent
+  verification of findings, risk-routed signed human approvals, agent-ready fix packets, a closure state machine in
+  which a finding is only `VERIFIED_FIXED` after executed proof at the exact fix commit and only `CLOSED` with
+  accountable human sign-off, and an explicit `GO / CONDITIONAL_GO / NO_GO / UNKNOWN` release gate
+  ([docs/vibe-code-assurance.md](docs/vibe-code-assurance.md)).
 
 Everything is written to one versioned JSON file. The report, blueprint and dashboard are renderings of it.
 
-> Status: **early release** (`0.1.0`, pre-1.0, results schema `0.1.0`). Install with
+> Status: **early release** (`0.3.0`, pre-1.0, results schema `0.1.0`, rubric `pc-rubric-0.2`). Install with
 > `npm install --global @enwithai/product-check`, or build from source as in the demo below.
 
 ## What it will not pretend
 
 Untested is never passed. Product Check reports `BLOCKED` or `NOT_TESTED` (with the reason) for anything it could not
 check, lowers coverage accordingly, and withholds a score when evidence is thin. It is **not** a penetration test, a
-compliance certification or a guarantee of production readiness. It never runs your repository's code, never logs in,
-never submits forms and never sends anything anywhere except passive GET requests to an origin you authorize.
+compliance certification or a guarantee of production readiness. The scan never runs your repository's code, never
+logs in, never submits forms and never sends anything anywhere except passive GET requests to an origin you authorize.
+Only the opt-in `proof` and `verify` commands run commands, and only those you declare in a policy, with
+`--allow-exec` on that invocation.
 
 ## Two-minute demo
 
-Requires Node.js 22, 24 or ≥ 26, and git. No account, no network, no runtime dependencies.
+Requires Node.js 22, 24 or ≥ 26, and git. No account, no network, one runtime dependency (`yaml`, for OpenSLO and alert-rule files).
 
 ```bash
 git clone https://github.com/enwithai/product-check.git && cd product-check
@@ -64,7 +71,7 @@ Verdict: READY_WITH_CONDITIONS at CT-T2 ("CONDITIONAL")
 Customer   100/100 (coverage 92%, confidence HIGH)
 Technology 94/100 (coverage 100%, confidence MEDIUM)
 Trust      97/100 (coverage 83%, confidence HIGH)
-Retest vs PCR-20261014T100000Z-7386B1: 35 verified fixed, 0 new, 0 reopened, 0 regressed control(s)
+Retest vs PCR-20261014T100000Z-D74DF2: 35 verified fixed, 0 new, 0 reopened, 0 regressed control(s)
 ```
 
 The two remaining P2s (no error monitoring, no AI evaluation suite) are real gaps in the fixed demo app. A
@@ -94,8 +101,9 @@ npm audit --json > npm-audit.json
 product-check run --repo . --test-results junit.xml --npm-audit npm-audit.json --stage PRE_LAUNCH
 ```
 
-Results go to `.product-check/`: `product-check-results.json`, `report.md`, `blueprint.md`, `work-packets/*.md` and
-`dashboard.html` (open it directly; no server). After changing things, run
+Results go to `.product-check/`: `product-check-results.json`, `report.md`, `blueprint.md`, `work-packets/*.md`,
+`dashboard.html` (open it directly; no server) and, when the repository was read, an as-built spec
+(`specs/000-as-built/spec.md`, `as-built-spec.json`) reverse-engineered from its structure. After changing things, run
 `product-check retest --baseline .product-check/product-check-results.json …` with the same inputs.
 
 No deployed URL you can scan? Export a HAR file from your browser's DevTools on your app and pass `--har app.har`.
@@ -107,15 +115,20 @@ authorization or tenant-isolation tests) to the controls Product Check cannot te
 
 ## Commands
 
-| Command                            | What it does                                                                                      |
-| ---------------------------------- | ------------------------------------------------------------------------------------------------- |
-| `run`                              | Scan → Test → Validate → Blueprint; writes results and renderings                                 |
-| `retest --baseline <file>`         | `run` plus comparison: verified fixes, reopened and new findings, regressions, trends             |
-| `scan`                             | Discovery only: which points of presence exist and what could be checked (no requests, no checks) |
-| `init`                             | Writes an editable scan contract                                                                  |
-| `validate <file>…`                 | Schema validation; for results also referential integrity and recomputation of scores and verdict |
-| `report`, `blueprint`, `dashboard` | Re-render from a results file                                                                     |
-| `controls`, `schema [name]`        | The control catalog and the JSON Schemas                                                          |
+| Command                             | What it does                                                                                      |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `run`                               | Scan → Test → Validate → Blueprint; writes results and renderings                                 |
+| `retest --baseline <file>`          | `run` plus comparison: verified fixes, reopened and new findings, regressions, trends             |
+| `scan`                              | Discovery only: which points of presence exist and what could be checked (no requests, no checks) |
+| `spec`                              | Reverse-engineers an as-built spec (Spec Kit `spec.md` + JSON) from the repository's structure    |
+| `init`                              | Writes an editable scan contract                                                                  |
+| `validate <file>…`                  | Schema validation; for results also referential integrity and recomputation of scores and verdict |
+| `report`, `blueprint`, `dashboard`  | Re-render from a results file                                                                     |
+| `controls`, `schema [name]`         | The control catalog and the JSON Schemas                                                          |
+| `register`, `review`, `proof`       | Closure register; layered change review (PR diff); author-side proof (runs declared checks)       |
+| `fix`, `verify`, `approve`, `close` | Record a fix; verify it at the exact commit; signed human approval; verified closure              |
+| `accept-risk`, `reject`, `learn`    | Accepted risk with expiry; false positive; regression corpus                                      |
+| `fix-packets`, `gate`, `assure`     | Agent-ready fix packets; release gate; all assurance reports and `dashboard/index.html`           |
 
 Exit codes: `0` ok · `1` internal error · `2` usage · `3` input · `4` safety refusal · `5` invalid artifact ·
 `6` `--fail-on` matched (for CI gating, for example `--fail-on NOT_READY`). Full reference: [docs/cli.md](docs/cli.md).
@@ -134,7 +147,8 @@ Exit codes: `0` ok · `1` internal error · `2` usage · `3` input · `4` safety
 
 ## Privacy and security
 
-No telemetry, account, model call or child process. The repository is read, never executed; git-ignored files (such
+No telemetry, account or model call. The scan starts no process: the repository is read, never executed (the opt-in
+`proof`/`verify` commands are the exception, see [vibe-code assurance](docs/vibe-code-assurance.md#execution-model-a-deliberate-change-opt-in-only)); git-ignored files (such
 as your local `.env`) are listed but never read. Evidence keeps short redacted excerpts, never file or response
 contents; response headers are filtered to a security-relevant allowlist with cookie values removed. The dashboard is
 a single file with a hash-pinned script and a `default-src 'none'` Content-Security-Policy. See
@@ -145,7 +159,8 @@ a single file with a hash-pinned script and a `default-src 'none'` Content-Secur
 [Philosophy](docs/philosophy.md) · [Architecture](docs/architecture.md) ·
 [Assessment model](docs/assessment-model.md) · [Scoring and gates](docs/scoring-and-gates.md) ·
 [Lifecycle tiers](docs/lifecycle-tiers.md) · [Safety and authorization](docs/safety-and-authorization.md) ·
-[Interoperability](docs/interoperability.md) · [CLI](docs/cli.md) · [Threat model](docs/threat-model.md) ·
+[Interoperability](docs/interoperability.md) · [Vibe-code assurance](docs/vibe-code-assurance.md) ·
+[v3.2 implementation audit](IMPLEMENTATION_AUDIT_v3.2.md) · [CLI](docs/cli.md) · [Threat model](docs/threat-model.md) ·
 [Branding and attribution](docs/branding-and-attribution.md) · [Implementation status](IMPLEMENTATION_STATUS.md) ·
 [Changelog](CHANGELOG.md) · [Contributing](CONTRIBUTING.md) · [Governance](GOVERNANCE.md)
 

package/SECURITY.md

@@ -12,7 +12,11 @@ minimal **synthetic** reproduction. Never send real results, HAR files or reposi
 
 ## Security properties Product Check is designed to keep
 
-- It never executes repository code, starts processes or uses `eval`/dynamic imports.
+- The scan (`run`, `retest`, `scan`, `spec`) never executes repository code or starts processes, and nothing uses
+  `eval`/dynamic imports. Only `proof` and `verify` (CT3 v3.2) can run commands: those the operator declares in a
+  policy, fix record or regression corpus, as argv without a shell, and only with `--allow-exec` on that invocation;
+  they then run with your permissions (see docs/safety-and-authorization.md). Read-only git plumbing runs with hooks,
+  fsmonitor, external diff/textconv drivers, pagers and system config disabled.
 - It never reads git-ignored files, and stores only short redacted excerpts and checksums as evidence.
 - It sends network requests only when explicitly authorized, only passive GETs to fixed paths on one origin, with no
   cookies, credentials or bodies, a request budget and timeouts. It never follows redirects to other origins.

package/dashboard/assurance.css

@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: MIT */
+/* SPDX-FileCopyrightText: 2026 EnWithAI Technologies */
+/* Assurance dashboard additions (closure funnel, phase strip, decision hero). Inlined after dashboard.css. */
+.funnel {
+  display: grid;
+  gap: 6px;
+}
+.funnel .step {
+  display: grid;
+  grid-template-columns: minmax(110px, 180px) 1fr 48px;
+  gap: 8px;
+  align-items: center;
+}
+.funnel .bar {
+  height: 18px;
+  border-radius: 4px;
+  background: var(--grid);
+  overflow: hidden;
+}
+.funnel .bar > span {
+  display: block;
+  height: 100%;
+  background: var(--s-customer);
+}
+.funnel .step.done .bar > span {
+  background: var(--good);
+}
+.funnel .step.side .bar > span {
+  background: var(--unknown);
+}
+.phases {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 8px;
+}
+.phases .card h4 {
+  margin: 0 0 4px;
+  font-size: 0.9rem;
+}
+.decision {
+  font-size: 2.2rem;
+  font-weight: 700;
+  line-height: 1.1;
+}
+.insufficient {
+  border: 2px dashed var(--unknown);
+  padding: 8px 12px;
+  border-radius: 8px;
+  margin: 8px 0;
+}
+pre.export {
+  max-height: 360px;
+  overflow: auto;
+  white-space: pre;
+}
+button.copy {
+  margin: 4px 0;
+}
+.decision.tone-good {
+  color: var(--good);
+}
+.decision.tone-warning {
+  color: var(--ink);
+  text-decoration: underline wavy var(--warning);
+}
+.decision.tone-critical {
+  color: var(--critical);
+}
+.decision.tone-unknown {
+  color: var(--unknown);
+}

package/dashboard/assurance.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 EnWithAI Technologies
+// Progressive enhancement for the assurance dashboard: copy buttons for the agent export and Mermaid sources.
+// Every figure is server-rendered from the JSON artifacts; without JavaScript everything is still readable.
+(function () {
+  Array.prototype.slice.call(document.querySelectorAll("[data-copy]")).forEach(function (btn) {
+    var target = document.getElementById(btn.getAttribute("data-copy"));
+    if (!target || !window.navigator || !window.navigator.clipboard) return;
+    btn.hidden = false;
+    btn.addEventListener("click", function () {
+      window.navigator.clipboard.writeText(target.textContent || "").then(
+        function () {
+          btn.textContent = "Copied";
+        },
+        function () {
+          btn.textContent = "Copy failed";
+        }
+      );
+    });
+  });
+})();

package/dashboard/dashboard.css

@@ -331,6 +331,12 @@ th {
   font-weight: 600;
   background: var(--surface);
 }
+td.id {
+  white-space: nowrap;
+}
+td.id code {
+  overflow-wrap: normal;
+}
 td.num,
 th.num {
   text-align: right;

package/dist/assurance/adapters.d.ts

@@ -0,0 +1,32 @@
+import type { ChangeReview } from "./types.js";
+/** Supported report versions, by tool. */
+export declare const ADAPTER_VERSIONS: {
+    readonly "impact-check": readonly ["2.0"];
+    readonly "spec-check": readonly ["1.0"];
+    readonly "outcome-check": readonly ["1.0"];
+};
+/** Impact Check 2.0 → risk input. */
+export declare function impactAdapter(data: unknown, source: string): NonNullable<ChangeReview["risk"]["impact_check"]> & {
+    modules: string[];
+};
+/** Spec Check 1.0 → requirements and gaps. */
+export interface SpecInput {
+    requirements: {
+        id: string;
+        path: string;
+        line: number | null;
+    }[];
+    gaps: {
+        id: string;
+        severity: string;
+        summary: string;
+        path: string | null;
+    }[];
+}
+export declare function specAdapter(data: unknown, source: string): SpecInput;
+/** Outcome Check 1.0 → delivery signal. */
+export interface OutcomeInput {
+    ci_first_pass_rate: number | null;
+    revert_rate: number | null;
+}
+export declare function outcomeAdapter(data: unknown, source: string): OutcomeInput;

package/dist/assurance/adapters.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 EnWithAI Technologies
+/**
+ * Optional, versioned adapters to the sibling Engineering Commons tools. Product Check reads only documented
+ * fields of their JSON reports and never runs or bundles their engines (no dependency in either direction):
+ *
+ *   Impact Check  2.0 → change-risk input (high-severity impact findings raise risk; affected modules)
+ *   Spec Check    1.0 → requirement IDs and acceptance gaps for the spec/outcome lane and fix packets
+ *   Outcome Check 1.0 → intent-to-delivery signal for the spec/outcome lane (never a whole-product score)
+ *
+ * An unsupported version is rejected with a clear message instead of being guessed at.
+ */
+import { inputError } from "../errors.js";
+const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** Supported report versions, by tool. */
+export const ADAPTER_VERSIONS = {
+    "impact-check": ["2.0"],
+    "spec-check": ["1.0"],
+    "outcome-check": ["1.0"],
+};
+/** Impact Check 2.0 → risk input. */
+export function impactAdapter(data, source) {
+    if (!isObj(data) || data["schema_version"] !== "2.0" || !Array.isArray(data["findings"]))
+        throw inputError(`${source} is not an Impact Check report (supported: ${ADAPTER_VERSIONS["impact-check"].join(", ")}).`, "Produce it with `impact-check --format json`.");
+    const findings = data["findings"].filter(isObj);
+    const modules = Array.isArray(data["affected_modules"])
+        ? data["affected_modules"]
+            .filter(isObj)
+            .map((m) => String(m["path"] ?? ""))
+            .filter(Boolean)
+        : [];
+    const rev = isObj(data["repo_revision"]) ? data["repo_revision"] : {};
+    return {
+        schema_version: "2.0",
+        high: findings.filter((f) => f["severity"] === "high" && f["status"] !== "unknown").length,
+        affected_modules: modules.length,
+        commit: typeof rev["commit"] === "string" ? rev["commit"] : null,
+        modules,
+    };
+}
+export function specAdapter(data, source) {
+    if (!isObj(data) ||
+        data["schema_version"] !== "1.0" ||
+        !Array.isArray(data["requirements"]) ||
+        !Array.isArray(data["findings"]))
+        throw inputError(`${source} is not a Spec Check report (supported: ${ADAPTER_VERSIONS["spec-check"].join(", ")}).`, "Produce it with `spec-check check --format json`.");
+    return {
+        requirements: data["requirements"].filter(isObj).map((r) => ({
+            id: String(r["id"] ?? ""),
+            path: String(r["path"] ?? ""),
+            line: typeof r["line_start"] === "number" ? r["line_start"] : null,
+        })),
+        gaps: data["findings"]
+            .filter(isObj)
+            .filter((f) => f["severity"] === "high" || f["severity"] === "medium")
+            .map((f) => {
+            const ev = Array.isArray(f["evidence"]) ? f["evidence"].filter(isObj)[0] : undefined;
+            return {
+                id: String(f["id"] ?? ""),
+                severity: String(f["severity"]),
+                summary: String(f["summary"] ?? ""),
+                path: ev && typeof ev["path"] === "string" ? ev["path"] : null,
+            };
+        }),
+    };
+}
+export function outcomeAdapter(data, source) {
+    if (!isObj(data) || data["schema_version"] !== "1.0" || !Array.isArray(data["metrics"]))
+        throw inputError(`${source} is not an Outcome Check report (supported: ${ADAPTER_VERSIONS["outcome-check"].join(", ")}).`, "Produce it with `outcome-check report --format json`.");
+    const val = (id) => {
+        const m = data["metrics"].find((x) => isObj(x) && x["id"] === id);
+        const all = isObj(m) && isObj(m["segments"]) ? m["segments"]["all"] : null;
+        return isObj(all) && typeof all["value"] === "number" ? all["value"] : null;
+    };
+    return { ci_first_pass_rate: val("ci_first_pass_rate"), revert_rate: val("revert_rate") };
+}

package/dist/assurance/approvals.d.ts

@@ -0,0 +1,34 @@
+import { type Approval, type ApprovalEvaluation, type AssurancePolicy } from "./types.js";
+/** Key ID: first 16 hex chars of SHA-256 over the DER-encoded SPKI public key. */
+export declare function keyId(publicKeyPem: string): string;
+/** Generates an Ed25519 key pair (PEM). */
+export declare function generateApproverKeys(): {
+    privateKey: string;
+    publicKey: string;
+};
+type Unsigned = Omit<Approval, "approval_id" | "signature">;
+/** Creates and signs an approval with a private key (PEM). */
+export declare function signApproval(input: Omit<Unsigned, "schema_version" | "kind">, privateKeyPem: string): Approval;
+/** Records an unsigned claim (e.g. a name typed with --approver). It never counts as approval. */
+export declare function unsignedClaim(input: Omit<Unsigned, "schema_version" | "kind">): Approval;
+/** Evaluates one approval for a required scope and commit. */
+export declare function evaluateApproval(a: Approval, policy: AssurancePolicy, want: {
+    scopeType: Approval["scope"]["type"];
+    ref: string;
+    sha: string | null;
+    excluded: string[];
+}): ApprovalEvaluation;
+/** Evaluates all approvals for a scope; counts distinct valid human approvers and checks domain owners. */
+export declare function tallyApprovals(approvals: Approval[], policy: AssurancePolicy, want: {
+    scopeType: Approval["scope"]["type"];
+    ref: string;
+    sha: string | null;
+    excluded: string[];
+}, required: number, owners?: string[]): {
+    evaluations: ApprovalEvaluation[];
+    validApprovers: string[];
+    satisfied: boolean;
+    missingOwners: string[];
+    stale: number;
+};
+export {};

package/dist/assurance/approvals.js

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 EnWithAI Technologies
+/**
+ * Accountable human approvals. An approval is a signed statement (Ed25519 over canonical JSON) by an approver the
+ * policy lists with a public key. A name passed on the command line proves nothing: only a signature that verifies
+ * against a policy key counts. Bots can sign records but never fill a human approval slot; an approval is bound
+ * to the exact commit it reviewed and becomes STALE when the commit changes; the implementer of a fix cannot
+ * approve its closure.
+ *
+ * Limit: Product Check proves possession of a registered key, not that a person pressed the key. Key custody is the
+ * operator's control (see docs/vibe-code-assurance.md).
+ */
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify, } from "node:crypto";
+import { usageError } from "../errors.js";
+import { stableId } from "../util/hash.js";
+import { ASSURANCE_SCHEMA_VERSION, } from "./types.js";
+import { canonicalJson } from "./util.js";
+/** Key ID: first 16 hex chars of SHA-256 over the DER-encoded SPKI public key. */
+export function keyId(publicKeyPem) {
+    const der = createPublicKey(publicKeyPem).export({ type: "spki", format: "der" });
+    return createHash("sha256").update(der).digest("hex").slice(0, 16);
+}
+/** Generates an Ed25519 key pair (PEM). */
+export function generateApproverKeys() {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return {
+        privateKey: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+        publicKey: publicKey.export({ type: "spki", format: "pem" }).toString(),
+    };
+}
+const payloadOf = (a) => canonicalJson({
+    schema_version: a.schema_version,
+    kind: a.kind,
+    approver: a.approver,
+    scope: a.scope,
+    reviewed_sha: a.reviewed_sha,
+    decision: a.decision,
+    comment: a.comment,
+    created_at: a.created_at,
+});
+/** Creates and signs an approval with a private key (PEM). */
+export function signApproval(input, privateKeyPem) {
+    let key;
+    try {
+        key = createPrivateKey(privateKeyPem);
+    }
+    catch {
+        throw usageError("The approver key is not a readable private key (PKCS#8 PEM).");
+    }
+    if (key.asymmetricKeyType !== "ed25519")
+        throw usageError("Approver keys must be Ed25519.");
+    const unsigned = { schema_version: ASSURANCE_SCHEMA_VERSION, kind: "approval", ...input };
+    const payload = payloadOf(unsigned);
+    const value = sign(null, Buffer.from(payload), key).toString("base64");
+    const pub = createPublicKey(key).export({ type: "spki", format: "pem" }).toString();
+    return {
+        ...unsigned,
+        approval_id: stableId("AP", [payload], 12),
+        signature: { algorithm: "ed25519", key_id: keyId(pub), value },
+    };
+}
+/** Records an unsigned claim (e.g. a name typed with --approver). It never counts as approval. */
+export function unsignedClaim(input) {
+    const unsigned = { schema_version: ASSURANCE_SCHEMA_VERSION, kind: "approval", ...input };
+    return { ...unsigned, approval_id: stableId("AP", [payloadOf(unsigned), "unsigned"], 12), signature: null };
+}
+/** Verifies the approval's signature against the policy; returns null when valid, else the failing status. */
+function signatureStatus(a, policy) {
+    const approver = policy.approvers.find((p) => p.id === a.approver.id);
+    if (!approver)
+        return "UNKNOWN_APPROVER";
+    if (!a.signature)
+        return "UNSIGNED";
+    if (a.signature.key_id !== keyId(approver.public_key))
+        return "INVALID_SIGNATURE";
+    try {
+        const ok = verify(null, Buffer.from(payloadOf(a)), createPublicKey(approver.public_key), Buffer.from(a.signature.value, "base64"));
+        if (!ok)
+            return "INVALID_SIGNATURE";
+    }
+    catch {
+        return "INVALID_SIGNATURE";
+    }
+    if (a.approval_id !== stableId("AP", [payloadOf(a)], 12))
+        return "INVALID_SIGNATURE";
+    if (approver.type !== "human" || a.approver.type !== "human")
+        return "NOT_HUMAN";
+    return null;
+}
+/** Evaluates one approval for a required scope and commit. */
+export function evaluateApproval(a, policy, want) {
+    const res = (status, reason) => ({
+        approval_id: a.approval_id,
+        approver_id: a.approver.id,
+        status,
+        reason,
+    });
+    const sig = signatureStatus(a, policy);
+    if (sig === "UNKNOWN_APPROVER")
+        return res(sig, `${a.approver.id} is not an approver in the policy.`);
+    if (sig === "UNSIGNED")
+        return res(sig, "Unsigned claim: a typed name is not proof of approval.");
+    if (sig === "INVALID_SIGNATURE")
+        return res(sig, "The signature does not verify against the approver's policy key (edited or forged).");
+    if (sig === "NOT_HUMAN")
+        return res(sig, `${a.approver.id} is a bot; automated reviewers cannot fill a human approval slot.`);
+    if (a.scope.type !== want.scopeType || a.scope.ref !== want.ref)
+        return res("WRONG_SCOPE", `Approval covers ${a.scope.type}:${a.scope.ref}, not ${want.scopeType}:${want.ref}.`);
+    if (want.excluded.includes(a.approver.id))
+        return res("SELF_APPROVAL", `${a.approver.id} implemented this change and cannot approve it.`);
+    if (a.decision !== "approve")
+        return res("REJECTED", `${a.approver.id} rejected: ${a.comment || "(no comment)"}`);
+    if (want.sha !== null && a.reviewed_sha !== want.sha)
+        return res("STALE", `Reviewed ${a.reviewed_sha.slice(0, 12)}, but the current commit is ${want.sha.slice(0, 12)}; re-approval required.`);
+    return res("VALID", `Signed by ${a.approver.id} for ${a.reviewed_sha.slice(0, 12)}.`);
+}
+/** Evaluates all approvals for a scope; counts distinct valid human approvers and checks domain owners. */
+export function tallyApprovals(approvals, policy, want, required, owners = []) {
+    const relevant = approvals.filter((a) => a.scope.type === want.scopeType && a.scope.ref === want.ref);
+    const evaluations = relevant.map((a) => evaluateApproval(a, policy, want));
+    const rejected = evaluations.some((e) => e.status === "REJECTED");
+    const validApprovers = [
+        ...new Set(evaluations.filter((e) => e.status === "VALID").map((e) => e.approver_id)),
+    ].sort();
+    const missingOwners = owners.filter((o) => !validApprovers.includes(o));
+    return {
+        evaluations,
+        validApprovers,
+        satisfied: !rejected && validApprovers.length >= required && missingOwners.length === 0,
+        missingOwners,
+        stale: evaluations.filter((e) => e.status === "STALE").length,
+    };
+}