@awak-app/simy-cli 0.5.8 → 0.5.11

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/minimum-completion.md

@@ -0,0 +1,137 @@
+# Minimum functional completion
+
+Every level must prove that the requested work exists, actual operations reach
+the intended result, and necessary persistence/integration works. Speed changes
+adjacent verification breadth, never this floor. The CLI requires this matrix for
+all coding-loop attempts, including legacy v2 resumes/rechecks. No opt-out field
+in an executor result or assurance-level selection disables the gate.
+
+## Collect real observations
+
+Before implementation, reconcile the original request, acceptance criteria and
+planned operations. Preserve every requested outcome; a missing requirement must
+be added through the controller's charter process, not omitted from the matrix.
+The independent auditor compares original-request coverage and checks the oracle
+against raw evidence. Machine mapping checks cannot discover an omitted idea in
+natural language or authenticate what an evidence collector observed.
+
+For each AC-N record implementation_refs (repository-relative file paths), then:
+
+- user/operation: operate the actual UI or CLI/consumer. Expected is true; actual
+  is whether the intended operation really executed, not just whether a click
+  command succeeded. Include screenshots/traces where relevant.
+- user/result: observe the requested visible outcome, including reload and session
+  return for a saving feature. Compare expected and actual values.
+- system/postcondition: independently inspect the final state; for persistence,
+  include the saved values and ownership, not a toast or HTTP status.
+- system/integration: inspect the necessary combined path through APIs, storage,
+  workers or consumers. Job acceptance is not job completion. Use the same input
+  and execution context across layers; cite trace/runtime identities in subject
+  and additional evidence.
+
+For document-only work these mean opening the actual consumer and checking content,
+links and packaged bytes. No DB/API is required if none participates. Both generic
+layers remain required; there is no post-failure waiver. Tests, permissions or
+runtime unavailable means pending/blocked. Never fabricate expected/actual equality.
+
+## Executable contract
+
+`check-minimum-completion.mjs` and `check-acceptance.mjs` ship together under the
+installed skill's scripts directory. The CLI instruction supplies controller input
+JSON; save it as charter.json for the standalone command. It contains id,
+requirement, repository, acceptance_criteria, completion_contract (version 2), and
+thread_state.original_request. For standalone use the controller freezes the same
+fields independently of implementation. The matrix otherwise follows
+[acceptance evidence](acceptance-evidence.md).
+
+To derive the frozen specification/context, import `minimumCharter(charter)` and
+`minimumContext(charter, fullHeadSha)` from the minimum script; import `sha256`
+and `contextDigest` from check-acceptance.mjs. The charter digest is
+`sha256(Buffer.from(JSON.stringify(minimumCharter(charter))))`.
+The context digest is `contextDigest(minimumContext(charter, fullHeadSha))`.
+The CLI derives both itself; it never takes expected digests from executor output.
+
+The current CLI context is one local checkout, its full HEAD, controller charter
+ID and request digest. A clean checkout is required and checked again after
+collection. This is not automatic multi-repository deployment identity discovery.
+For companion services, verify the combined path and record the pinned service
+identities in the evidence; the independent reviewer must validate their current
+identity. Do not claim that this single-checkout gate automatically re-reads a
+companion service's Git HEAD or production environment.
+
+Every matrix row adds `implementation_refs: ["src/example.js"]`. Each required
+user/system cell's **first** evidence file is JSON with this shape (user example):
+
+```json
+{
+  "criterion_id": "AC-1",
+  "context_sha256": "<current context digest>",
+  "checks": {
+    "operation": {"subject": "Save clicked and request observed for fixture run", "expected": true, "actual": true},
+    "result": {"subject": "Note after reload and session return", "expected": "requested text", "actual": "requested text"}
+  }
+}
+```
+
+The system file uses `postcondition` and `integration` instead. Each has `subject`,
+non-null `expected` and actual observed `actual`. Values may be objects/arrays to
+compare saved values and ownership together. The checker compares values exactly;
+missing fields or mismatches fail regardless of a cell's passed flag. Additional
+cell evidence may contain screenshots or logs; all artifact hashes are validated.
+Keep raw evidence local and use synthetic data, never credentials/personal data.
+
+Store matrix and evidence under ui_evidence_root, or under repository `.artifacts`
+when no root was specified. All artifact paths are relative to the matrix directory.
+Return `delivery_evidence_path` in SIMY_RESULT_JSON, absolute under that root or
+relative to it. Source mappings must resolve to files inside the current repository.
+Evidence must be bounded regular files; path escapes/symlinks are rejected.
+
+Standalone invocation, with controller-owned trusted digests:
+
+```text
+node <installed-skill>/scripts/check-minimum-completion.mjs charter.json matrix.json context.json <trusted-charter-sha256> <trusted-context-sha256>
+```
+
+Exit 0 is evidence_complete; 1 is evidence_incomplete; 2 means invalid/unavailable
+inputs. JSON includes a readable checklist and floor failures. Check the top-level
+status, not only individual base-matrix rows. The standalone checker validates
+mapping structure; only the CLI additionally resolves mappings in its checkout.
+Neither file hashes nor a passed report authenticate the collector or prove an
+oracle matches the original requirement. Independent coverage/oracle review is
+required by the CLI and must inspect the raw evidence. The standalone command
+cannot stop Codex/Claude's final chat response and does not install global hooks.
+
+## State, review and recovery
+
+The CLI's implementation gate includes the minimum report before independent
+review. The review returns coverage_review with requirements_complete,
+unmapped_requirements and a concrete observation. The controller binds that
+review to the matrix digest, then recollects evidence. Changing the matrix after
+review requires a new review; changing HEAD or dirtying the tree invalidates the
+proof. A concurrent call using the same run ID is rejected, including cloned snapshots.
+A repeated start rechecks evidence without executing the implementation again;
+explicit resume remains the repair path. Cross-process
+execution remains subject to existing runner/host ownership controls.
+
+PR recheck clears prior completion flags and reruns the floor. Missing evidence
+never promotes an old successful audit. The old history is retained; do not rewrite
+it as verified under the new floor. Fix the named criterion, collect fresh evidence
+and resume within the retry budget. Reconcile ambiguous external side effects
+before retrying. The minimum pass is a prerequisite for existing CI/review/authority
+gates, not merge, deployment or a complete production delivery.
+
+Rollback: restoring the older CLI removes this additional enforcement. Retain the
+versioned evidence/history and report that limitation; never relabel old evidence
+as verified by this floor. Monitor minimum-completion findings and subsequent
+reviewer-discovered gaps through existing local run records; no new telemetry or
+external provider calls are introduced.
+
+## Shared specifications and independent review
+
+The floor's AC-N rows trace back to stable requirement IDs in the team's shared
+As-Is/To-Be specification. Follow [shared system specifications](shared-system-specifications.md)
+for purpose, user experience, cross-view consistency, independent reviews and
+pre/post-PR SQM. These are controller workflow obligations, not fields magically
+validated by the minimum checker. The CLI gate verifies minimum structured evidence;
+it does not launch every design review or SQM phase on its own. Standalone hosts
+remain responsible for executing this skill and cannot claim an enforced host hook.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/shared-system-specifications.md

@@ -0,0 +1,138 @@
+# Shared system specifications and delivery review
+
+Read before planning a Delivery Loop change. The specification belongs to the
+system and its team, not to a single run. Use existing team paths and conventions;
+if none exist, start `docs/systems/<system-id>/` with an index and the applicable
+views below. Repository paths here are a convention, not a demand to move existing
+documents or to create a new service. Keep one canonical source for each concept.
+
+## Shared baseline and proposed change
+
+The system index records its owner/maintainers, repository/document links, stable
+system ID, As-Is source revision(s) and environment, verified date, and gaps.
+Distinguish source-code behavior, locally observed behavior, and deployed behavior.
+An old design or green PR is not proof of current production behavior.
+
+At the start of each run:
+
+1. Read the existing index and current linked views. Reconcile relevant As-Is with
+   code and actual behavior; label unknowns, cite evidence, and correct documented
+   drift without claiming that the drift was part of the requested feature.
+2. State why the change matters: beneficiary, current difficulty, what they can
+   do after the change, observable success, and non-goals. Preserve the user's
+   original request as an independent acceptance source.
+3. Prepare a proposed To-Be on a branch/change proposal linked from the shared
+   system index. Record its baseline revision, affected stable IDs, before/after
+   behavior, dependencies and acceptance oracles. Reuse unchanged views by reference;
+   do not copy the whole specification into every run or generate empty diagrams.
+4. Link the requirement to workflow, screen/control, state/sequence, API/event,
+   data/relationship, permission and runtime boundaries as applicable. Map these
+   stable system IDs to the run's AC-N rows and implementation/evidence locations.
+5. Obtain independent design review before implementation. Supply the original
+   request, shared baseline, To-Be and linked unchanged views. Missing evidence or
+   contradictory views remains pending/failed, never silently accepted.
+
+The twelve-view index must account for every category: present (with a canonical
+link), unchanged (with a revision), not applicable (with a reason), or unknown
+(with an owner/next action). Only create/update a diagram where it describes a
+real system concept. For CLI/skill systems, chat/terminal interactions can be the
+interface views; do not invent application screens, APIs, tables or infrastructure.
+
+| View | Primary content | Consistency checks against other views |
+| --- | --- | --- |
+| art-01-screen-inventory-final | Screens or user interaction surfaces and stable IDs | Every referenced screen/control in workflows, transitions and wireframes exists |
+| art-02-screen-transitions | Navigation, entry/exit, failure/recovery | Reachable inventory entries, correct permission guards and state conditions |
+| art-03-wireframes | Controls, content, empty/loading/error/success states | Each action has a requirement, transition and downstream sequence; no dead control |
+| art-04-functional-requirements | Purpose, beneficiary, outcomes, invariants, acceptance | Every request maps to implementation and evidence through the other affected views |
+| art-05-state-machines | Legal states, guards, terminal outcomes, retry/cancel | Sequences/events trigger legal transitions; UI messages match actual final state |
+| art-06-permissions | Actor/role, action, resource, authority boundary | UI guards, API checks, ownership and execution roles agree |
+| art-07-user-workflows | User goal, steps, completion and recovery experience | Requirements covered end to end through screens, APIs, persistence and runtime |
+| art-08-data-dictionary | Fields, meaning, type, requiredness, lifecycle and owner | API/event payloads, ER cardinality and state invariants use the same definitions |
+| art-09-sequences | Calls/events through components, errors, asynchronous completion | API names/payloads, states, authorization and deployed component boundaries agree |
+| art-10-api-design | Existing APIs, commands or file contracts, errors and compatibility | Sequence inputs/outputs, data meanings and permission checks agree |
+| art-11-er-diagram | Entities, relationships, ownership and cardinality | Dictionary and API reads/writes agree; label logical artifact models as non-DB |
+| art-12-infrastructure | Repositories, execution environments, services and trust boundaries | Every sequence participant has an actual host/owner; revision/rollout dependencies align |
+
+## Review evidence and neutral agents
+
+All reviews use independent agents/sessions, including design, cross-view
+consistency, implementation-versus-To-Be, verification changes and PR review.
+An agent must not approve work it authored. A reviewer can re-review fixes to its
+findings if it did not implement the fixes. Supply raw sources, not desired answers;
+require inspected references, discrepancies, uncertainty and a reasoned verdict.
+Use the repository-required model (gpt-5.5 / xhigh where mandated and available).
+If independent review is unavailable, report that gate as blocked.
+
+Persist a compact review receipt: reviewer/session identity, review kind, original
+request and shared baseline/To-Be references, candidate revisions, inspected views
+and evidence, findings, result, and re-review links. An independent reviewer checks:
+
+- coverage of the original request, user benefit and acceptance oracles;
+- consistency for every affected cross-view link, including unchanged neighbors;
+- behavior after actual operation, reload/session return and final persistence or
+  integration outcome where applicable;
+- implementation and tests against the proposed To-Be, not just against each other;
+- missing/extra functionality, stale evidence and unresolved historical regressions.
+
+A diagram syntax/link checker helps, but cannot replace semantic cross-view review.
+Do not declare neutral review merely by renaming the implementer's role.
+
+## SQM before and after PR creation
+
+Use the installed SQM loop skill. Respect explicit SQM opt-in, existing session and
+service authority. Explain unavailable gates; do not install global hooks, weaken
+rules, force an upload or switch organizations to obtain a pass.
+
+For each phase use fresh, separate local paths outside the diff (for example an
+ignored `.artifacts/delivery/<run>/sqm/pre-pr/` or `post-pr/` directory):
+
+```sh
+simy sqm min-check --base <actual-pr-base> --output <phase>/min.json
+simy sqm check --base <actual-pr-base> --min-result <phase>/min.json --proof <phase>/proof.json --signed-evidence <phase>/proof.json.signed.json
+```
+
+Use supported no-upload options when required by the authorized sharing scope.
+Read the proof and verify its repository, head, base, working-tree/diff identity,
+knowledge bundle version/digest and `outcome.status == passed`; verify the bound
+signature using SQM tooling. Exit zero alone is insufficient. Do not edit or commit
+between min-check and check. Pin the commit before the pre-PR check; writing proof
+into the committed diff would invalidate its identity.
+
+Before the pre-PR phase, inventory relevant known incidents from the team's shared
+incident records, SQM knowledge and repository regression history. Record incident
+or source ID, failure boundary, applicable/unaffected/unknown classification,
+regression command and result, SQM rule match/coverage, and residual gaps. Link this
+ledger from the shared specification so the next task can reuse and improve it.
+Separate confirmed incidents from synthetic risk scenarios; never invent history.
+A zero-match/no-applicable-rules proof does not establish historical coverage.
+Use concrete regressions for relevant uncovered incidents and have an independent
+reviewer assess coverage; keep missing incident history or untested boundaries
+visible. No finite test promises absence of all future bugs.
+
+Pre-PR: implementation-to-To-Be review and relevant regressions pass, then run SQM;
+repair findings within the bounded loop, re-review changed work, and rerun against
+the final candidate before creation. On unavailable/failed proof, withhold creation
+and report the exact blocker while continuing independent authorized preparation.
+
+Post-PR: fetch the actual PR head/base and check out/verify that combination, run
+both SQM phases again into new paths, inspect proof and current CI, and obtain
+independent PR/evidence review. The pre-PR proof cannot stand in for this run.
+If it fails, retain the PR as draft/not-ready with unmet gates recorded, repair and
+rerun affected independent reviews and SQM. A changed head/base/spec or relevant
+bundle invalidates affected approvals and proofs; preserve old receipts as history.
+Promote Ready only with current required gates, including applicable combined-state
+verification. Merge and deployment still require their own authority and evidence.
+
+## Team maintenance after verification
+
+Merge reviewed specification changes with the corresponding implementation through
+the normal team review process. Record proposed, implemented locally, merged and
+verified-in-environment status separately. Advance As-Is only for the revision and
+environment actually verified; a merged To-Be is not automatically production As-Is.
+Preserve the prior baseline and decisions in version history. If another change
+updates a shared view, reconcile its semantics and re-review affected links even
+when Git reports no textual conflict. Do not overwrite concurrent edits.
+
+Each run stores pointers, deltas and evidence in its receipt, not another competing
+master specification. Record unresolved drift with an owner, source and next action.
+Never lower the intended outcome merely to make an implementation match a diagram.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/state-and-receipts.md

@@ -9,11 +9,18 @@ Persist one controller-owned snapshot with at least:
 
 - `run_id`, `state`, monotonic `revision`, and terminal disposition;
 - immutable explicit conditions and their stable digest;
+- acceptance-source identities and digests, architecture boundaries, applicable
+  rule decisions, risk tier, requested/effective delivery levels, the safety
+  ceiling reason, and chat-confirmation receipt;
 - repository, base SHA, head SHA, companion SHAs, merge SHA, image digests, and
   deployed revision;
 - target environments, user journey, user/tenant fixture identities, and
   required artifacts;
 - applicable gates and their current status;
+- frozen acceptance charter digest, current matrix/table paths and digests,
+  superseded matrix snapshots, and the acceptance validator result for each gate;
+- verification-boundary changes, deferred-debt references, and applicable
+  outcome and guardrail measures;
 - attempt number, retry/time/cost budgets, and failure fingerprints;
 - append-only receipt IDs, evidence references, timestamps, and cleanup state.
 
@@ -29,6 +36,7 @@ Use the smallest applicable receipts rather than free-form completion claims:
 - `FailureReproductionReceipt`
 - `ImplementationReceipt`
 - `LocalVerificationReceipt`
+- `AcceptanceEvidenceReceipt` (matrix completeness, not overall completion)
 - `IndependentReviewReceipt`
 - `PRCIReceipt`
 - `IntegrationVerificationReceipt`
@@ -91,6 +99,7 @@ Evidence is revision-bound:
 | Change | Invalidate |
 |---|---|
 | Charter or explicit success conditions | All affected downstream gates |
+| Acceptance source, test oracle, assertion, or CI/security gate changes | The affected gate and all dependent downstream evidence |
 | Head SHA or generated source changes | Local, CI, integration, container, and live evidence |
 | Base SHA or companion revision changes | Integration and later evidence |
 | Container image digest changes | Container user journey and later runtime evidence |
@@ -125,6 +134,8 @@ For the full delivery mode:
 ```text
 done =
   reproduction_verified
+  && acceptance_evidence_complete
+  && minimum_functional_evidence_verified
   && locally_verified
   && pr_ci_green
   && integration_verified
@@ -140,3 +151,10 @@ done =
 Remove only genuinely non-applicable terms and record why. If merge or deploy
 is outside current authority, stop at the highest proven pre-authority state.
 
+Acceptance evidence must cover every applicable criterion for the target gate,
+with current context and the required user/system layers. After each evaluated
+action, refresh the JSON matrix and its readable table; append a receipt for the
+update. Keep the frozen charter distinct from mutable results. A charter patch
+supersedes the old digest only after the controller verifies its authority.
+
+The CLI records minimum evidence in observed_evidence.minimum_completion, independently of executor status. The independent audit is bound to its matrix digest. Legacy v2 histories remain readable, but missing minimum evidence cannot be reused as passing evidence on resume/recheck. Missing or unsupported charters require a refresh; they do not disable verification.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+// Offline record validation only. The controller owns acceptance and provenance.
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const layers = ["user", "system"];
+const hashPattern = /^[a-f0-9]{64}$/;
+const text = (value) => typeof value === "string" && value.trim().length > 0;
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+export const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+export const contextDigest = (context) => sha256(JSON.stringify(canonical(context)));
+
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!object(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+}
+
+function requireValue(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function validateCharter(charter) {
+  requireValue(object(charter) && charter.schema_version === 1 && text(charter.run_id), "Invalid charter header");
+  requireValue(Array.isArray(charter.criteria) && charter.criteria.length > 0, "Charter requires criteria");
+  const ids = new Set();
+  for (const criterion of charter.criteria) {
+    requireValue(object(criterion) && text(criterion.id) && !ids.has(criterion.id), "Duplicate or invalid criterion ID");
+    ids.add(criterion.id);
+    requireValue(text(criterion.outcome) && text(criterion.acceptance_source), "Criterion needs outcome and independent acceptance source");
+    requireValue(object(criterion.layers), "Criterion needs verification layers");
+    let required = 0;
+    for (const layer of layers) {
+      const spec = criterion.layers[layer];
+      requireValue(object(spec), `Missing ${layer} layer specification`);
+      if (spec.applicability === "required") {
+        requireValue(text(spec.method), "Required layer needs a verification method");
+        required += 1;
+      } else {
+        requireValue(spec.applicability === "not_applicable" && text(spec.reason) && text(spec.source), "Non-applicability needs a reason and source in the charter");
+      }
+    }
+    requireValue(required > 0, "A criterion cannot waive both verification layers");
+  }
+}
+
+function validateContext(context, runId) {
+  requireValue(object(context) && context.run_id === runId, "Context run ID mismatch");
+  for (const field of ["stage", "environment", "fixture_id"]) {
+    requireValue(text(context[field]), `Context needs ${field}`);
+  }
+  requireValue(hashPattern.test(context.input_sha256), "Context needs input SHA-256");
+  requireValue(object(context.source_revisions) && Object.keys(context.source_revisions).length > 0, "Context needs repository revisions");
+  for (const [repository, revision] of Object.entries(context.source_revisions)) {
+    requireValue(text(repository) && typeof revision === "string" && /^[a-f0-9]{40}$/.test(revision), "Invalid repository revision");
+  }
+}
+
+export async function readEvidenceArtifact(root, artifact) {
+  requireValue(object(artifact) && text(artifact.path) && hashPattern.test(artifact.sha256), "Invalid artifact reference");
+  // Explicit bundle-relative paths only; never fetch URLs or execute evidence.
+  const segments = artifact.path.split("/");
+  requireValue(!path.isAbsolute(artifact.path) && !artifact.path.includes("\\") &&
+    segments.every((part) => part && part !== "." && part !== ".." && !part.includes(":")), "Unsafe artifact path");
+  let target = root;
+  for (let index = 0; index < segments.length; index += 1) {
+    target = path.join(target, segments[index]);
+    const stat = await lstat(target);
+    requireValue(!stat.isSymbolicLink(), "Symbolic evidence paths are not allowed");
+    if (index < segments.length - 1) requireValue(stat.isDirectory(), "Invalid evidence directory");
+  }
+  const handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const stat = await handle.stat();
+    requireValue(stat.isFile() && stat.size > 0 && stat.size <= 16 * 1024 * 1024, "Artifact must be a nonempty regular file of at most 16 MiB");
+    const bytes = await handle.readFile();
+    requireValue(sha256(bytes) === artifact.sha256, "Artifact digest mismatch");
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+
+const tableText = (value) => String(value ?? "").replaceAll("|", "\\|").replace(/[\r\n]+/g, " ");
+
+export function renderChecklist(report) {
+  const header = [
+    "| Criterion / outcome | Layer / method | Status | Observation | Evidence | Unmet reason / next action |",
+    "| --- | --- | --- | --- | --- | --- |",
+  ];
+  const rows = report.checks.map((row) => "| " + [
+    `${row.id}: ${row.outcome}`, `${row.layer}: ${row.method}`, row.status,
+    row.observation, row.evidence.join(", "), [row.reason, row.next_action].filter(Boolean).join(" / "),
+  ].map(tableText).join(" | ") + " |");
+  return [...header, ...rows, "", `Validator: ${report.status}`,
+    ...report.errors.map((error) => `- ${tableText(error)}`)].join("\n") + "\n";
+}
+
+export async function checkAcceptance({ charterBytes, matrix, expectedCharterSha256, expectedContextSha256, evidenceRoot }) {
+  requireValue(hashPattern.test(expectedCharterSha256) && hashPattern.test(expectedContextSha256), "Trusted charter and context SHA-256 values are required");
+  requireValue(sha256(charterBytes) === expectedCharterSha256, "Frozen charter digest mismatch");
+  const charter = JSON.parse(charterBytes.toString());
+  validateCharter(charter);
+  requireValue(object(matrix) && matrix.schema_version === 1, "Invalid matrix schema version");
+  requireValue(matrix.charter_sha256 === expectedCharterSha256, "Matrix charter digest mismatch");
+  validateContext(matrix.context, charter.run_id);
+  requireValue(contextDigest(matrix.context) === expectedContextSha256, "Current context digest mismatch");
+  requireValue(Array.isArray(matrix.results), "Matrix requires results");
+  const root = await realpath(evidenceRoot);
+  const report = { status: "evidence_incomplete", checks: [], errors: [] };
+  const results = new Map();
+  const expectedIds = new Set(charter.criteria.map((criterion) => criterion.id));
+  for (const row of matrix.results) {
+    requireValue(object(row) && expectedIds.has(row.id) && !results.has(row.id), "Duplicate or unknown result criterion");
+    requireValue(object(row.layers) && Object.keys(row.layers).every((key) => layers.includes(key)), "Invalid result layers");
+    results.set(row.id, row);
+  }
+  for (const criterion of charter.criteria) {
+    for (const layer of layers) {
+      const spec = criterion.layers[layer];
+      const cell = results.get(criterion.id)?.layers[layer];
+      const row = { id: criterion.id, outcome: criterion.outcome, layer, method: spec.method ?? spec.reason,
+        status: "pending", observation: "", evidence: [], reason: "", next_action: "" };
+      report.checks.push(row);
+      if (spec.applicability === "not_applicable") {
+        row.status = "not_applicable";
+        row.reason = `${spec.reason} (${spec.source})`;
+        continue;
+      }
+      if (!object(cell)) {
+        row.reason = "Missing result";
+        row.next_action = "Run the specified check and record evidence";
+      } else {
+        row.observation = text(cell.observation) ? cell.observation : "";
+        row.next_action = text(cell.next_action) ? cell.next_action : "";
+        row.evidence = Array.isArray(cell.evidence) ? cell.evidence.map((entry) => object(entry) && text(entry.path) ? entry.path : "invalid reference") : [];
+        if (!["passed", "failed", "pending"].includes(cell.status)) {
+          row.reason = "Invalid status (results cannot waive a required layer)";
+        } else if (cell.context_sha256 !== expectedContextSha256 || cell.charter_sha256 !== expectedCharterSha256) {
+          row.reason = "Stale result; reverify for the current charter and context";
+        } else if (cell.status !== "passed") {
+          row.status = cell.status;
+          row.reason = text(cell.reason) ? cell.reason : "Missing unmet reason";
+          if (!row.next_action) row.reason += "; missing next action";
+        } else {
+          try {
+            requireValue(text(cell.action) && text(cell.observation), "Passed result needs action and observation");
+            requireValue(text(cell.observed_at) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(cell.observed_at) &&
+              Number.isFinite(Date.parse(cell.observed_at)) && Date.parse(cell.observed_at) <= Date.now(), "Invalid or future observation timestamp");
+            requireValue(Array.isArray(cell.evidence) && cell.evidence.length > 0, "Passed result needs evidence");
+            for (const artifact of cell.evidence) await readEvidenceArtifact(root, artifact);
+            row.status = "passed";
+          } catch {
+            row.reason = "Invalid, missing, empty, unsafe, or changed evidence; check action, observation, timestamp and artifact hashes";
+          }
+        }
+      }
+      if (row.status !== "passed") report.errors.push(`${criterion.id}/${layer}: ${row.reason}`);
+    }
+  }
+  if (!report.errors.length) report.status = "evidence_complete";
+  report.markdown = renderChecklist(report);
+  return report;
+}
+
+async function main(args) {
+  requireValue(args.length === 4 || (args.length === 5 && args[4] === "--markdown"),
+    "Usage: node check-acceptance.mjs <charter.json> <matrix.json> <trusted-charter-sha256> <current-context-sha256> [--markdown]");
+  const [charterPath, matrixPath, expectedCharterSha256, expectedContextSha256] = args;
+  const load = async (target) => {
+    const stat = await lstat(target);
+    requireValue(stat.isFile() && stat.size <= 1024 * 1024, "Input must be a regular JSON file of at most 1 MiB");
+    return readFile(target);
+  };
+  const report = await checkAcceptance({ charterBytes: await load(charterPath),
+    matrix: JSON.parse((await load(matrixPath)).toString()), expectedCharterSha256,
+    expectedContextSha256, evidenceRoot: path.dirname(path.resolve(matrixPath)) });
+  process.stdout.write(args[4] === "--markdown" ? report.markdown : JSON.stringify(report, null, 2) + "\n");
+  process.exitCode = report.status === "evidence_complete" ? 0 : 1;
+}
+
+const entryPath = process.argv[1] ? await realpath(process.argv[1]).catch(() => null) : null;
+if (entryPath === fileURLToPath(import.meta.url)) {
+  main(process.argv.slice(2)).catch(() => {
+    // Do not echo arbitrary JSON, filesystem contents, or sensitive input values.
+    process.stderr.write("Acceptance input invalid. Check JSON schema, paths, frozen charter and current context digests. Usage: node check-acceptance.mjs <charter.json> <matrix.json> <trusted-charter-sha256> <current-context-sha256> [--markdown]\n");
+    process.exitCode = 2;
+  });
+}