@surlymochan/evalid 0.5.16 → 0.5.18

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project are documented here. Detailed notes live in
 [RELEASE_NOTES.md](RELEASE_NOTES.md).
 
+## [0.5.18] - 2026-11-09
+
+### Added
+- **Export proof verdicts as SARIF for code scanning (#92, closes #73)**: sealed-proof failures now surface as code scanning alerts, not just a red check and a PR comment. `action/sarif.mjs` maps each proof-failure verdict to a SARIF 2.1.0 rule — binding_mismatch / snapshot_mismatch / green_tree_mismatch / reexec_* and the other validator failures (level error; warning for tests_skipped_or_todo / tests_counts_unknown) — one result per named file (file-level location; the validator records no line numbers), degrading to the proof file itself when a verdict has no file location. Stable `partialFingerprints` (`change-id/phase/attempt/verdict/file`) so re-runs of the same proof update the existing alert instead of opening a duplicate; merging upserts per proof, so a valid proof clears its alert. `valid` / `not_required` / infrastructure verdicts produce zero results. `verify-proof.mjs` gains `--sarif-out <path>` (with matching `sarif-out` input and `sarif_path` / `sarif_written` outputs in action.yml); `proof-ledger.yml` passes `--sarif-out evalid-proof.sarif` per proof and uploads with `github/codeql-action/upload-sarif` (`security-events: write`; upload runs on `always()` so it fires exactly when a proof failed, and is `continue-on-error` so fork PRs stay green). Test evidence: 11 new tests in `test/github-action-sarif.test.js` (verdict→rule mapping + levels, per-file locations, no-file degradation, fingerprint stability, merge upsert / valid-clears-alert, SARIF 2.1.0 shape, action.yml declarations, CLI end-to-end on a real sealed proof); PR CI runs verify 42567046823 and ledger 42567046908 both pass; merged main CI run 42567609280 success.
+
+Issue #73 — **closed with end-to-end evidence** (comment 2026-11-09T05:46:16Z, demo PR #94, closed unmerged): a sealed green proof with a tampered `test/demo-sarif.test.js` went red — ledger run 42568411445 fail, verdict `green_tree_mismatch`, files `[test/demo-sarif.test.js]` only; SARIF upload success, analysis 2124250892 (results_count 1), code scanning alert #1 visible in the Security tab (rule `evalid/green-tree-mismatch`, severity error). Re-run (attempt 2, analysis 2124258699) opened no duplicate alert, and the same fingerprint from the earlier demo PR #93 did not create a new alert either. Restoring the test file cleared it — ledger run 42568823086 pass, verdict `valid`, analysis 2124265677 (results_count 0), alert #1 state `fixed` on refs/pull/94/merge. A green PR produces no alert (PR #92 itself has no sealed proof: no SARIF upload, no analysis; main branch alerts 0).
+
+Acceptance debt, stated plainly: the bench-number acceptance for P1-2 / P1-3 / P2-1 / P2-3 still awaits the MiniMax full-matrix batch (15 instances × 4 arms × reps 3), which is stopped on MiniMax Token Plan quota exhaustion. No bench numbers are claimed in this release.
+
+## [0.5.17] - 2026-11-09
+
+### Added
+- **M3 slice 3: wire I6d into xflow audit replay and the I6c gate (#89)**: `xflow audit` now runs the I6d gate in the scratch clone when the diff touches Python test files (or a pytest claim exists) and the audited repo carries the I6d plugin — an unexecuted assertion inside the diff flips the verdict to `mismatch` (exit 1) even when the replay itself is fully green; no plugin / no Python test change / pytest unavailable is recorded `not applicable` and leaves the verdict alone (`--no-i6d` skips it). The I6c gate folds `specs/changes/<id>/tdd/i6d-0.json` evidence into fail findings (code `unexecuted_assertions`, one line per assertion). Test evidence: local full `npm test` 496 tests / 495 pass / 0 fail / 1 skipped (pre-existing); merged main CI run 42551898032 success.
+- **M3 slice 4: acceptance demo for the I6d assertion-execution gate (#90)**: `scripts/demo-i6d-gate.sh` proves the gate end to end through the real `xflow audit` CLI (not the JS API) with a RED/GREEN double control — RED: a diff adding a never-called callback (`assert value == 42` never executes) with a claimed all-green pytest run is judged `mismatch`, exit 1, `i6d: unexecuted_assertions` (1/3 executed, 1 unexecuted); GREEN: a diff adding only really-executed assertions is judged `verified`, exit 0, `i6d: pass`. Test evidence: new test `test/i6d-acceptance-demo.test.js` 1/1 pass; `test/xflow-audit.test.js` 15/15 pass; local full `npm test` 511 tests / 510 pass / 0 fail / 1 skipped (pre-existing); merged main CI run 42557796622 success.
+- **Concurrency policy test coverage, external contribution (#88, closes #87)**: 14 new tests in `test/concurrency-policy.test.js` covering `createConcurrencyPolicy()` — default settings, configured maxima and fractional normalization, invalid limits with fallback, mission-level overrides, atom/registry parallel weights, fixed and weighted charging. No production code changed. Test evidence: contributor ran the new file 14/14 pass (full suite was blocked locally by a missing dependency on their machine); full-suite verification after merge comes from main CI run 42556898257 success.
+
+Milestone M3 "I6d assertion-execution gate" — **accepted** 2026-11-09. Acceptance evidence (issue #69, comment 6731688418): the slice-4 demo proves the gate's acceptance standard end to end — every new/changed assertion must actually execute during the green run, and an unexecuted assertion does not count as green (RED case: assertion never executed while the tests all pass, still `mismatch`; GREEN case: all assertions executed, `verified`). Demo script `scripts/demo-i6d-gate.sh` is in main and locked into the suite by `test/i6d-acceptance-demo.test.js`; the #69 checklist box is ticked.
+
+Acceptance debt, stated plainly: the bench-number acceptance for P1-2 / P1-3 / P2-1 / P2-3 still awaits the MiniMax full-matrix batch (15 instances × 4 arms × reps 3), which is stopped on MiniMax Token Plan quota exhaustion. No bench numbers are claimed in this release.
+
 ## [0.5.16] - 2026-11-09
 
 ### Added

package/README.md

@@ -231,6 +231,13 @@ claims found in the supplied text), `unverifiable` (a claimed command
 could not run). Exit codes are 0 / 1 / 3 / 1 respectively (2 = misuse).
 `--json` prints the machine-readable report; `--out <file>` writes it.
 
+When the diff touches Python test files and the audited repo carries the
+I6d plugin (`xflow/atoms/i6d_assertion_execution.py`), the audit also runs
+the assertion-execution gate: an added or changed assertion that never
+executes during the green replay flips the verdict to `mismatch`, even
+when every claimed run replays green. `scripts/demo-i6d-gate.sh` is a
+self-contained red/green demonstration of that gate (M3).
+
 ## Commands
 
 The installed binary is `xflow` (`npm install -g evalid` installs the `xflow` CLI). Every

package/RELEASE_NOTES.md

@@ -1,5 +1,29 @@
 # Release Notes
 
+## 0.5.18 - Proof verdicts as SARIF for code scanning (issue #73 closed)
+
+Patch release. One merged PR since 0.5.17, verified end to end in CI and locally, with the Security-tab acceptance evidence from a demo PR.
+
+**Export proof verdicts as SARIF for code scanning (#92, closes #73).** Sealed-proof failures now surface as code scanning alerts, not just a red check and a PR comment. `action/sarif.mjs` maps each proof-failure verdict to a SARIF 2.1.0 rule (binding / snapshot / green-tree / reexec failures at error level; skipped-tests and unknown-counts at warning), one result per named file, with stable fingerprints so re-runs update the existing alert instead of duplicating it and a valid proof clears its alert. `verify-proof.mjs` gains `--sarif-out`, and `proof-ledger.yml` uploads the SARIF per proof (fires exactly when a proof failed; fork PRs stay green). Test evidence: 11 new tests in `test/github-action-sarif.test.js`; PR CI runs verify 42567046823 and ledger 42567046908 both pass; merged main CI run 42567609280 success.
+
+**Issue #73 — closed with end-to-end evidence** (demo PR #94, closed unmerged): a sealed green proof with a tampered `test/demo-sarif.test.js` went red — ledger run 42568411445 fail, verdict `green_tree_mismatch`, files `[test/demo-sarif.test.js]` only; SARIF upload success, analysis 2124250892 (results_count 1), code scanning alert #1 visible in the Security tab (rule `evalid/green-tree-mismatch`, severity error). A re-run opened no duplicate alert, and restoring the test file cleared it — ledger run 42568823086 pass, verdict `valid`, analysis 2124265677 (results_count 0), alert #1 state `fixed` on refs/pull/94/merge. A green PR produces no alert (main branch alerts 0).
+
+Acceptance debt, stated plainly: the bench-number acceptance for P1-2, P1-3, P2-1 and P2-3 — the wall-clock/token/resolved lines from issue #5 — still awaits the MiniMax full-matrix batch (15 instances × 4 arms × reps 3), which is stopped on MiniMax Token Plan quota exhaustion. No bench numbers are claimed in this release.
+
+## 0.5.17 - I6d assertion-execution gate (milestone M3 accepted)
+
+Patch release. Three merged PRs since 0.5.16, all verified end to end in CI and locally.
+
+**M3 slice 3: I6d wired into `xflow audit` replay and the I6c gate (#89).** When an audited diff touches Python test files, the audit now runs the I6d gate in the scratch clone: an unexecuted assertion inside the diff flips the verdict to `mismatch` even when the replay itself is fully green; repos without the I6d plugin are unaffected. The I6c gate folds the same evidence into fail findings naming each unexecuted assertion. Test evidence: local full `npm test` 496 tests / 495 pass / 0 fail / 1 skipped (pre-existing); merged main CI run 42551898032 success.
+
+**M3 slice 4: acceptance demo (#90).** `scripts/demo-i6d-gate.sh` proves the gate through the real `xflow audit` CLI with a RED/GREEN double control — RED: a never-called callback's `assert value == 42` with a claimed all-green pytest run is judged `mismatch`, exit 1, `i6d: unexecuted_assertions`; GREEN: only really-executed assertions are judged `verified`, exit 0, `i6d: pass`. Test evidence: new test `test/i6d-acceptance-demo.test.js` 1/1 pass; `test/xflow-audit.test.js` 15/15 pass; local full `npm test` 511 tests / 510 pass / 0 fail / 1 skipped (pre-existing); merged main CI run 42557796622 success.
+
+**Concurrency policy test coverage, external contribution (#88, closes #87).** 14 new tests in `test/concurrency-policy.test.js` covering `createConcurrencyPolicy()` limits, weights and overrides; no production code changed. Test evidence: contributor ran the new file 14/14 pass; full-suite verification after merge comes from main CI run 42556898257 success.
+
+**Milestone M3 "I6d assertion-execution gate" — accepted.** Evidence in issue #69, comment 6731688418: the slice-4 demo proves the acceptance standard end to end — every new/changed assertion must actually execute during the green run, and an unexecuted assertion does not count as green. The demo script is in main and locked into the suite; the #69 checklist box is ticked.
+
+Acceptance debt, stated plainly: the bench-number acceptance for P1-2, P1-3, P2-1 and P2-3 — the wall-clock/token/resolved lines from issue #5 — still awaits the MiniMax full-matrix batch (15 instances × 4 arms × reps 3), which is stopped on MiniMax Token Plan quota exhaustion. No bench numbers are claimed in this release.
+
 ## 0.5.16 - M3 slices 1–2: pytest assertion-execution tracking, diff-scoped (milestone M3 not yet accepted)
 
 Patch release. Two merged slices since 0.5.15, both verified end to end in CI and locally.

package/atoms/registry.json

@@ -238,6 +238,19 @@
         "tdd_mode": "red-green|refactor|docs?"
       }
     },
+    "I6d.tdd.assertion_execution": {
+      "track": "lite",
+      "type": "python",
+      "script": "xflow/atoms/i6d_assertion_execution.py",
+      "description": "Prove every new/changed pytest assertion really executed during the green run (M3 slice 3). Runs after I6b and before I6c, so I6c can fold its verdict into quality-0.json.",
+      "input_schema": {
+        "project_root": "string",
+        "change_id": "string",
+        "only_changed": "boolean?",
+        "diff_base": "string?",
+        "include_uncommitted": "boolean?"
+      }
+    },
     "J4a.spec_consistency.structural": {
       "track": "lite",
       "type": "python",

package/bin/xflow.js

@@ -5810,6 +5810,8 @@ async function handleAudit(args) {
     headRef,
     claimsText,
     timeoutMs,
+    python: process.env.PYTHON || 'python3',
+    i6d: !parsedArgs.no_i6d,
     keepWorkdir: Boolean(parsedArgs.keep_workdir),
   });
   if (parsedArgs.out) writeFileSync(resolve(parsedArgs.out), `${JSON.stringify(report, null, 2)}\n`);
@@ -6740,7 +6742,11 @@ Audit any git diff / PR without adopting evalid workflows: extract the test
 runs the change claims to have passed, replay each one in a clean clone at
 the change's head, and compare exit codes and pass/fail counts against the
 claim. Diffs carrying an evalid proof seal are replayed through the existing
-i6b seal validator. No seal semantics, CLI name, or bin path changes.
+i6b seal validator. When the diff touches Python test files and the audited
+repo carries the I6d plugin, the I6d assertion-execution gate also runs in
+the scratch clone (scoped to the diff): unexecuted in-diff assertions flip
+the verdict to mismatch, since a green run that never executed an assertion
+must not count as green. No seal semantics, CLI name, or bin path changes.
 
 Verdicts / exit codes: verified 0, mismatch 1, unverifiable 1, misuse 2,
 no_claims 3 (no test claims found in the supplied text).
@@ -6754,6 +6760,7 @@ Options:
   --claims TEXT       Claims text (default: PR body for --pr)
   --claims-file FILE  Read claims text from a file
   --timeout SEC       Per-command replay timeout, default: 300
+  --no-i6d            Skip the I6d assertion-execution gate
   --json              Print the machine-readable report
   --out FILE          Write the JSON report to a file
   --keep-workdir      Keep the scratch clone for debugging

package/docs/launch-dossier.md

@@ -1,6 +1,6 @@
 # evalid Launch Dossier
 
-Generated: 2026-11-08T23:43:07.000Z
+Generated: 2026-11-09T05:51:48.645Z
 Mode: post_publish
 Verdict: conditionally ready: engine and adoption evidence are strong, registry publication remains required for a splash launch
 Launch ready: not yet
@@ -117,7 +117,7 @@ Evidence:
 - Adoption records: 1; status: pass
 - Goal audit: pass; goal: Keep evalid credible as an open-source agent delivery runtime: repo-owned workflow contracts, executable verification gates, durable project context, and honest benchmark evidence.
 - Package evidence: missing; source: registry_json
-- Package name/version: @surlymochan/evalid@0.5.16
+- Package name/version: @surlymochan/evalid@0.5.18
 
 ## Passing Evidence
 

package/docs/workflow-manual.md

@@ -49,7 +49,7 @@
 └────────────────────────────┬────────────────────────────────────┘
                              │  atom dispatch
 ┌────────────────────────────▼────────────────────────────────────┐
-│  L0  原子组件（85 atoms，每个只有一处实现）                       │
+│  L0  原子组件（86 atoms，每个只有一处实现）                       │
 │                                                                 │
 │  xflow/atoms/*.py          A/B/C/E6/H1/I6/J/K  (lite)      │
 │  src/core/atoms/**/*.js        D/E/F/G/E3/E4/E7    (heavy)     │
@@ -219,7 +219,7 @@ CHANGE_ID=<id> xflow workflow run workflows/yolo.yaml
            │ ack
     ▼
 ┌──────────────────────┐
-│  21b tdd-green       │  atoms: I6a(green) + I6b(green) + I6c quality
+│  21b tdd-green       │  atoms: I6a(green) + I6b(green) + I6d assertion + I6c quality
 │  gate: artifact-verify│◄─── green/refactor 必须通过
 └──────────┬───────────┘
            │ exist
@@ -251,6 +251,7 @@ specs/changes/<change_id>/
 ├── tdd/
 │   ├── red-0.json       (I6a/I6b @ phase 21a, passed:false)
 │   ├── green-0.json     (I6a/I6b @ phase 21b, passed:true)
+│   ├── i6d-0.json       (I6d @ phase 21b, assertion execution)
 │   └── quality-0.json   (I6c @ phase 21b, test quality review)
 ├── merge-product.md     (A5 @ archive)
 ├── merge-architecture.md
@@ -377,8 +378,8 @@ CHANGE_ID=<id> xflow workflow run workflows/corps.yaml
 ┌──────────────────┐
 │ 21a tdd-red      │  I6a(red) + I6b(red)
 │ 22 execute       │  implementation happens here
-│ 21b tdd-green    │  I6a(green) + I6b(green) + I6c quality
-│ gate: artifact   │◄── red-0.json + green-0.json + quality-0.json
+│ 21b tdd-green    │  I6a(green) + I6b(green) + I6d assertion + I6c quality
+│ gate: artifact   │◄── red-0.json + green-0.json + i6d-0.json + quality-0.json
 └────────┬─────────┘
          │
     ▼
@@ -627,6 +628,8 @@ J 管验证      K 管收尾归档
 │    │ I6b tdd.proof_validate       重算 proof 绑定，在快照上重跑命令（lite） │
 │    │ I6c tdd.quality_review       测试质量、红绿命令、skip/弱断言；       │
 │    │                              tdd_mode=refactor|docs 时替代 red 证明  │
+│    │ I6d tdd.assertion_execution  新增/改动 pytest 断言真实执行证明；    │
+│    │                              无改动 pytest 测试时直接通过（lite）    │
 ├────┼──────────────────────────────────────────────────────────────────────┤
 │ J  │ Judge /       验证层：确定性测试 + 漂移扫描 + 证据收集   mixed   3      │
 │    │ Verify                                                               │

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surlymochan/evalid",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "description": "Claimed != verified: a runtime verification layer for coding agents. It seals each test run and replays it from a clean snapshot, with a zero-judge gate pipeline (spec clarification, code review, TDD proof) and the xflow CLI.",
   "keywords": [
     "ai-agents",

package/scripts/demo-i6d-gate.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+# M3 slice 4 — acceptance demo for the I6d assertion-execution gate.
+#
+# End-to-end proof, through the real `xflow audit` CLI (not the JS API):
+#   RED   — a diff whose new test defines a callback that is never called,
+#           so its `assert value == 42` never executes, while the claimed
+#           pytest run still passes  -> audit must say mismatch, exit 1.
+#   GREEN — a diff whose new assertions all execute, same green claim
+#           -> audit must say verified, exit 0.
+#
+# The gate's job (M3, parent #69): an assertion that never runs must not
+# count as green. The RED case is exactly the README gap ("assertions in
+# callbacks that never run").
+#
+# Usage: scripts/demo-i6d-gate.sh
+# Everything happens in a throwaway repo under $TMPDIR; nothing is pushed.
+# Needs a python with pytest (ambient, else a throwaway venv is built and
+# pip installs pytest — same approach as test/xflow-audit.test.js).
+set -euo pipefail
+
+EVALID_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/evalid-i6d-demo-XXXXXX")"
+trap 'rm -rf "$WORK"' EXIT
+
+# --- python with pytest -------------------------------------------------
+# EVALID_I6D_PYTEST_PYTHON lets a caller (e.g. the node test) hand over an
+# already-provisioned interpreter instead of building a second venv.
+PY="${EVALID_I6D_PYTEST_PYTHON:-python3}"
+if ! "$PY" -c 'import pytest' 2>/dev/null; then
+  echo '[demo] no ambient pytest; building a throwaway venv…'
+  "$PY" -m venv "$WORK/venv"
+  "$WORK/venv/bin/python" -m pip install --quiet pytest
+  PY="$WORK/venv/bin/python"
+fi
+export PYTHON="$PY"
+export PATH="$(dirname "$PY"):$PATH"
+echo "[demo] pytest python: $PY"
+
+# --- throwaway demo repo (carries the I6d plugin, like a real adopter) ---
+DEMO="$WORK/repo"
+mkdir -p "$DEMO/xflow/atoms"
+cp "$EVALID_ROOT/xflow/atoms/i6d_assertion_execution.py" "$DEMO/xflow/atoms/"
+cd "$DEMO"
+git init -q -b main
+git config user.email 'i6d-demo@example.test'
+git config user.name 'i6d-demo'
+printf 'def test_normal():\n    assert 1 + 1 == 2\n' > test_dead.py
+git add .
+git commit -qm base
+BASE="$(git rev-parse HEAD)"
+
+run_case() { # $1 = RED|GREEN, $2 = file content, $3 = expected verdict, $4 = expected exit
+  local name="$1" content="$2" want_verdict="$3" want_exit="$4"
+  printf '%s' "$content" > test_dead.py
+  git diff > "$WORK/$name.diff"
+  printf 'Tests: `pytest test_dead.py` — 2 tests, all pass.\n' > "$WORK/$name.claims.txt"
+  git checkout -q -- test_dead.py
+  echo "=== $name case: xflow audit --diff $name.diff --base $BASE ==="
+  set +e
+  node "$EVALID_ROOT/bin/xflow.js" audit --repo "$DEMO" \
+    --diff "$WORK/$name.diff" --base "$BASE" \
+    --claims-file "$WORK/$name.claims.txt" --out "$WORK/$name.json"
+  local rc=$?
+  set -e
+  local verdict
+  verdict="$(node -p "require('$WORK/$name.json').verdict")"
+  local i6d_verdict unexecuted
+  i6d_verdict="$(node -p "require('$WORK/$name.json').i6d.verdict")"
+  unexecuted="$(node -p "require('$WORK/$name.json').i6d.unexecuted.map(u => u.file + ':' + u.line + ' ' + u.source).join('; ')")"
+  echo "[$name] audit exit=$rc verdict=$verdict i6d=$i6d_verdict unexecuted=[$unexecuted]"
+  if [ "$verdict" != "$want_verdict" ] || [ "$rc" != "$want_exit" ]; then
+    echo "[$name] FAIL: expected verdict=$want_verdict exit=$want_exit" >&2
+    return 1
+  fi
+  echo "[$name] PASS"
+}
+
+RED_CONTENT='def test_callback_never_runs():
+    def on_done(value):
+        assert value == 42
+    # on_done is defined but never called: its assert never executes.
+    assert True
+
+
+def test_normal():
+    assert 1 + 1 == 2
+'
+
+GREEN_CONTENT='def test_normal():
+    assert 1 + 1 == 2
+
+
+def test_new_ok():
+    assert 2 + 2 == 4
+'
+
+run_case RED "$RED_CONTENT" mismatch 1
+run_case GREEN "$GREEN_CONTENT" verified 0
+
+echo
+echo '=== M3 acceptance demo: PASS ==='
+echo 'RED   diff (dead callback assert) -> mismatch, exit 1 (i6d: unexecuted_assertions)'
+echo 'GREEN diff (all asserts execute) -> verified, exit 0 (i6d: pass)'
+echo 'A never-executed assertion does not count as green.'

package/src/core/audit.js

@@ -18,6 +18,17 @@
  *   no_claims    — no test claims found in the supplied text
  *   unverifiable — a claimed command could not run (missing runner, timeout)
  *
+ * Slice 3 (M3, issue #86) adds the I6d assertion-execution gate to the
+ * replay: when the diff touches Python test files (or a pytest run is
+ * claimed) and the audited repo carries the I6d plugin
+ * (xflow/atoms/i6d_assertion_execution.py), the gate runs in the scratch
+ * clone, scoped to the diff. A pytest run can exit 0 while an assertion
+ * inside a never-called callback never executes -- that change must not
+ * count as green, so unexecuted in-diff assertions flip the verdict to
+ * mismatch. When the plugin is absent, the diff touches no Python tests,
+ * or pytest is unavailable, the gate reports not applicable and the
+ * verdict is unchanged (the audit stays usable for any repo).
+ *
  * Exit codes mirror the verdicts: 0 verified, 1 mismatch/unverifiable,
  * 2 misuse, 3 no_claims (inconclusive, not a failure of the change).
  */
@@ -54,6 +65,101 @@ export function isTestFile(path) {
   return /(^|\/)test(s)?\/|\.test\.[cm]?[jt]sx?$|_test\.go$|^test_[^/]*\.py$|_test\.py$|\.spec\.[cm]?[jt]sx?$/.test(path);
 }
 
+/** Python files pytest collects as tests by default (test_*.py / *_test.py). */
+export function isPythonTestFile(path) {
+  const name = String(path || '').split('/').pop();
+  return /\.py$/.test(name) && (name.startsWith('test_') || name.endsWith('_test.py'));
+}
+
+/**
+ * Run the I6d assertion-execution gate in an audit scratch clone.
+ * Scope comes from the audit's diff text (--diff-file in the I6d CLI),
+ * so uncommitted diffs work without committing anything.
+ *
+ * Returns `{ applicable: false, reason }` when the gate cannot apply
+ * (no plugin in the audited repo, no Python test changes and no pytest
+ * claim, pytest unavailable), and `{ applicable: true, verdict, ... }`
+ * otherwise. `pytest_failed` in the gate run does NOT flip the audit
+ * verdict by itself -- a failing pytest run is the claim replay's job
+ * to judge; only `unexecuted_assertions` (and gate errors) change it.
+ */
+export function runI6dCheck(workdir, options = {}) {
+  const {
+    diffText = '',
+    claims = [],
+    python = process.env.PYTHON || 'python3',
+    timeoutMs = 300000,
+  } = options;
+  const plugin = join(workdir, 'xflow', 'atoms', 'i6d_assertion_execution.py');
+  if (!existsSync(plugin)) {
+    return { applicable: false, reason: 'plugin_not_present' };
+  }
+  const { files } = parseDiffFiles(diffText);
+  const changedPyTests = files.filter(isPythonTestFile);
+  const hasPytestClaim = claims.some((claim) => /\bpytest\b/.test(claim.command || ''));
+  if (changedPyTests.length === 0 && !hasPytestClaim) {
+    return { applicable: false, reason: 'no_python_test_changes' };
+  }
+  const targets = changedPyTests.filter((file) => existsSync(join(workdir, file)));
+  if (targets.length === 0 && !hasPytestClaim) {
+    return { applicable: false, reason: 'no_python_test_changes' };
+  }
+  const pytestCheck = spawnSync(python, ['-c', 'import pytest'], { cwd: workdir, encoding: 'utf8', timeout: 60000 });
+  if (pytestCheck.status !== 0) {
+    return { applicable: false, reason: 'pytest_unavailable' };
+  }
+  const scratch = mkdtempSync(join(tmpdir(), 'evalid-audit-i6d-'));
+  try {
+    const diffPath = join(scratch, 'audit.diff');
+    const evidencePath = join(scratch, 'i6d-evidence.json');
+    writeFileSync(diffPath, diffText);
+    const result = spawnSync(python, [
+      plugin,
+      '--root', workdir,
+      '--output', evidencePath,
+      '--pytest-python', python,
+      '--only-changed',
+      '--diff-file', diffPath,
+      '--',
+      ...targets,
+    ], { cwd: workdir, encoding: 'utf8', timeout: timeoutMs });
+    if (!existsSync(evidencePath)) {
+      return {
+        applicable: true,
+        verdict: 'i6d_error',
+        error: `i6d gate wrote no evidence (exit ${result.status}): ${(result.stderr || result.stdout || '').trim().slice(-300)}`,
+      };
+    }
+    let evidence;
+    try {
+      evidence = JSON.parse(readFileSync(evidencePath, 'utf8'));
+    } catch {
+      return { applicable: true, verdict: 'i6d_error', error: 'i6d evidence JSON unparseable' };
+    }
+    const unexecuted = (evidence.unexecuted || []).map((entry) => ({
+      file: String(entry.file || '').startsWith(workdir)
+        ? String(entry.file).slice(workdir.length + 1)
+        : entry.file,
+      line: entry.line,
+      test: entry.test,
+      source: entry.source,
+    }));
+    return {
+      applicable: true,
+      verdict: evidence.verdict,
+      exit: result.status,
+      executed: evidence.executed ?? 0,
+      total: evidence.total ?? 0,
+      unexecuted,
+      skipped: (evidence.skipped || []).length,
+      outOfScope: (evidence.outOfScope || []).length,
+      pytestExit: evidence.pytestExit ?? null,
+    };
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
 function normalizeCommand(raw) {
   return String(raw || '').replace(/\s+/g, ' ').trim();
 }
@@ -322,6 +428,10 @@ function replaySeal(workdir, repoRoot, seal, python, timeoutMs) {
  *   timeoutMs  — per-command timeout (default 300_000)
  *   python     — python binary for the i6b validator (default 'python3')
  *   keepWorkdir — keep the scratch clone for debugging (default false)
+ *   python     — python binary for the i6b validator and the i6d gate
+ *               (default 'python3' / $PYTHON)
+ *   i6d        — run the I6d assertion-execution gate when it applies
+ *               (default true; --no-i6d on the CLI disables it)
  */
 export function runAudit(options = {}) {
   const {
@@ -333,6 +443,7 @@ export function runAudit(options = {}) {
     timeoutMs = 300000,
     python = process.env.PYTHON || 'python3',
     keepWorkdir = false,
+    i6d = true,
   } = options;
   if (!repoDir || !existsSync(repoDir)) {
     return { ok: false, verdict: 'misuse', error: `repo not found: ${repoDir}`, exitCode: 2 };
@@ -432,14 +543,28 @@ export function runAudit(options = {}) {
     const sealResults = diff.seals.map((seal) => replaySeal(workdir, resolve(repoDir), seal, python, timeoutMs));
     const badSeal = sealResults.find((seal) => !seal.ok);
 
+    // Slice 3 (M3): the I6d gate judges whether the diff's new/changed
+    // assertions really executed during the green run. A replay can exit 0
+    // while an assertion in a never-called callback never ran -- that
+    // change must not count as green.
+    const i6dResult = i6d === false
+      ? { applicable: false, reason: 'disabled' }
+      : runI6dCheck(workdir, { diffText, claims, python, timeoutMs });
+
     let verdict;
     let exitCode;
-    if (claims.length === 0 && sealResults.length === 0) {
+    if (i6dResult.applicable && i6dResult.verdict === 'unexecuted_assertions') {
+      verdict = 'mismatch';
+      exitCode = 1;
+    } else if (claims.length === 0 && sealResults.length === 0) {
       verdict = 'no_claims';
       exitCode = 3;
     } else if (mismatch || badSeal) {
       verdict = 'mismatch';
       exitCode = 1;
+    } else if (i6dResult.applicable && (i6dResult.verdict === 'diff_error' || i6dResult.verdict === 'i6d_error')) {
+      verdict = 'unverifiable';
+      exitCode = 1;
     } else if (claimResults.some((entry) => entry.replay && (entry.replay.timedOut || entry.replay.spawnError))) {
       verdict = 'unverifiable';
       exitCode = 1;
@@ -454,6 +579,7 @@ export function runAudit(options = {}) {
       exitCode,
       claims: claimResults,
       seals: sealResults,
+      i6d: i6dResult,
       files: diff.files,
       testFiles: diff.testFiles,
       setup,
@@ -492,6 +618,21 @@ export function renderAuditReport(report) {
   for (const seal of report.seals || []) {
     lines.push(`- ${seal.ok ? '✓' : '✗'} seal ${seal.changeId}/${seal.phase}/${seal.attempt}: ${seal.verdict}`);
   }
+  const gate = report.i6d;
+  if (gate) {
+    if (!gate.applicable) {
+      lines.push(`i6d: not applicable (${gate.reason})`);
+    } else if (gate.verdict === 'pass') {
+      lines.push(`i6d: pass (${gate.executed}/${gate.total} assertions executed, ${gate.skipped} skipped, ${gate.outOfScope} out of scope)`);
+    } else if (gate.verdict === 'unexecuted_assertions') {
+      lines.push(`i6d: ✗ unexecuted_assertions (${gate.executed}/${gate.total} executed, ${gate.unexecuted.length} unexecuted)`);
+      for (const entry of gate.unexecuted) {
+        lines.push(`  unexecuted: ${entry.file}:${entry.line}: ${entry.source}`);
+      }
+    } else {
+      lines.push(`i6d: ${gate.verdict}${gate.error ? `: ${gate.error}` : ''}`);
+    }
+  }
   if (report.durationMs !== undefined) lines.push(`duration: ${(report.durationMs / 1000).toFixed(1)}s`);
   return lines.join('\n');
 }

package/workflows/corps.yaml

@@ -398,10 +398,13 @@ phases:
         with: { phase: "green", test_command: "${input.tdd_green_command}", expect: "pass" }
       - id: I6b.tdd.proof_validate
         with: { phase: "green", tdd_mode: "${input.tdd_mode}" }
+      - id: I6d.tdd.assertion_execution
+        with: { only_changed: true, include_uncommitted: true }
       - id: I6c.tdd.quality_review
         with: { tdd_mode: "${input.tdd_mode}" }
     artifacts:
       - { path: "specs/changes/${change_id}/tdd/green-0.json", optional: false }
+      - { path: "specs/changes/${change_id}/tdd/i6d-0.json", optional: false }
       - { path: "specs/changes/${change_id}/tdd/quality-0.json", optional: false }
     gate:
       type: artifact-verify

package/workflows/yolo.yaml

@@ -187,10 +187,13 @@ phases:
         with: { phase: "green", test_command: "${input.tdd_green_command}", expect: "pass" }
       - id: I6b.tdd.proof_validate
         with: { phase: "green", tdd_mode: "${input.tdd_mode}" }
+      - id: I6d.tdd.assertion_execution
+        with: { only_changed: true, include_uncommitted: true }
       - id: I6c.tdd.quality_review
         with: { tdd_mode: "${input.tdd_mode}" }
     artifacts:
       - { path: "specs/changes/${change_id}/tdd/green-0.json", optional: false }
+      - { path: "specs/changes/${change_id}/tdd/i6d-0.json", optional: false }
       - { path: "specs/changes/${change_id}/tdd/quality-0.json", optional: false }
     gate:
       type: artifact-verify

package/xflow/atoms/i6c_tdd_quality_review.py

@@ -21,6 +21,14 @@ shapes of it: expected values taken from the implementation's own constants
 named callbacks that are never referenced again (they execute zero times),
 and self-comparison assertions (x == x). Type-only or existence-only
 assertions are flagged only when they are the sole assertions.
+
+Slice 3 (M3, issue #86) folds the I6d assertion-execution evidence into
+this review: when the I6d atom ran first (tdd-green phase order is I6a,
+I6b, I6d, I6c) and wrote ``specs/changes/<id>/tdd/i6d-0.json``, an
+``unexecuted_assertions`` verdict becomes one fail finding per unexecuted
+assert, and a ``pytest_unavailable`` verdict becomes a fail finding of its
+own. When no i6d-0.json exists (I6d not run, e.g. a change with no Python
+tests) this review behaves exactly as before.
 """
 import argparse
 import json
@@ -343,6 +351,43 @@ def main() -> None:
     for test_file in sorted(reviewed):
         findings.extend(review_test_file(project_root, test_file, implementation_sources))
 
+    # Slice 3 (M3): fold the I6d assertion-execution evidence in, when the
+    # I6d atom ran first and wrote i6d-0.json. An assertion that never
+    # executed during the green run must fail the quality gate, even when
+    # the run itself was green. No i6d-0.json means I6d did not run (no
+    # Python test changes): behaviour is unchanged, no finding added.
+    i6d_evidence = read_json(proof_dir / "i6d-0.json")
+    i6d_summary = None
+    if i6d_evidence:
+        i6d_summary = {
+            "verdict": i6d_evidence.get("verdict"),
+            "executed": i6d_evidence.get("executed"),
+            "total": i6d_evidence.get("total"),
+            "unexecuted": len(i6d_evidence.get("unexecuted") or []),
+            "skipped": len(i6d_evidence.get("skipped") or []),
+        }
+        if i6d_evidence.get("verdict") == "unexecuted_assertions":
+            for entry in i6d_evidence.get("unexecuted") or []:
+                findings.append({
+                    "severity": "fail",
+                    "code": "unexecuted_assertions",
+                    "path": entry.get("file"),
+                    "line": entry.get("line"),
+                    "test": entry.get("test"),
+                    "source": entry.get("source"),
+                    "message": "An assertion added/changed by this diff never "
+                    "executed during the green run; it must not count as green.",
+                })
+        elif i6d_evidence.get("verdict") == "pytest_unavailable":
+            findings.append({
+                "severity": "fail",
+                "code": "i6d_pytest_unavailable",
+                "message": "The I6d assertion-execution gate could not run: "
+                "pytest is unavailable, so added/changed assertions could "
+                "not be proven executed.",
+                "assertions_at_stake": i6d_evidence.get("total"),
+            })
+
     failed = any(finding.get("severity") == "fail" for finding in findings)
     verdict = "failed" if failed else "passed"
     proof = {
@@ -354,6 +399,7 @@ def main() -> None:
         "code_files": code_files,
         "test_files": test_files,
         "read_cache": _read_cache.stats(),
+        "i6d": i6d_summary,
         "findings": findings,
         "recorded_at": datetime.now(timezone.utc).isoformat(),
     }
@@ -368,6 +414,7 @@ def main() -> None:
         "tdd_mode": mode,
         "proof_file": str(proof_file),
         "read_cache": _read_cache.stats(),
+        "i6d": i6d_summary,
         "failures": sum(1 for finding in findings if finding.get("severity") == "fail"),
         "warnings": sum(1 for finding in findings if finding.get("severity") == "warn"),
         "failed_codes": [

package/xflow/atoms/i6d_assertion_execution.py

@@ -39,6 +39,22 @@ and the CLI exposes the same as ``--only-changed`` / ``--diff-base``.
 With scoping on, asserts outside the diff are reported as ``outOfScope``
 (never red), an empty diff passes (exit 0), and only in-scope unexecuted
 asserts fail the gate. Without the flag, slice 1 behaviour is unchanged.
+
+Slice 3 wires the gate into ``xflow audit`` replay and the I6c gate:
+
+* ``changed_lines_from_diff(diff_text, repo)`` -- the same changed-lines
+  shape as ``changed_lines`` but parsed from a unified diff *text* (the
+  audit's --diff / PR diff, which may be uncommitted or carry context
+  lines), so the audit can scope the gate without committing anything;
+* ``changed_lines(..., uncommitted=True)`` -- additionally unions
+  ``git diff HEAD`` (working tree + staged), for the workflow atom, where
+  the change under review is still uncommitted;
+* atom mode (``--change-id`` / ``--project-root``, as invoked by the
+  workflow executor): evidence lands in
+  ``specs/changes/<id>/tdd/i6d-0.json`` and stdout is a single JSON line
+  (``{ok, verdict, proof_file, ...}``), so the executor can parse it and
+  the I6c review can fold the verdict into quality-0.json. With no
+  changed Python test files the atom passes without running pytest.
 """
 
 import argparse
@@ -53,7 +69,22 @@ from pathlib import Path
 EVIDENCE_ENV = "EVALID_I6D_EVIDENCE"
 DIFF_ONLY_ENV = "EVALID_I6D_ONLY_CHANGED"
 DIFF_BASE_ENV = "EVALID_I6D_DIFF_BASE"
-VERSION = 2
+DIFF_FILE_ENV = "EVALID_I6D_DIFF_FILE"
+INCLUDE_UNCOMMITTED_ENV = "EVALID_I6D_INCLUDE_UNCOMMITTED"
+VERSION = 3
+
+
+def is_python_test_file(path):
+    """True for files pytest collects as tests by default.
+
+    Mirrors pytest's default ``python_files`` (``test_*.py`` /
+    ``*_test.py``); kept in sync with ``isPythonTestFile`` in
+    ``src/core/audit.js``.
+    """
+    name = os.path.basename(str(path))
+    return name.endswith(".py") and (
+        name.startswith("test_") or name.endswith("_test.py")
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -127,23 +158,25 @@ def resolve_diff_base(repo, base="main"):
 _HUNK_RE = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
 
 
-def changed_lines(repo, base="main"):
-    """Return ``(merge_base_sha, {abspath: {new-side line numbers}})``.
+def _parse_unified_diff(diff_text, repo):
+    """``{abspath: {new-side line numbers}}`` from a unified diff text.
 
-    The diff is ``git diff <merge-base> HEAD -U0``: committed changes on
-    this branch only. A file's changed lines are the new-side lines of
-    every hunk (for a brand-new file, every line). Deleted files contribute
-    nothing; uncommitted working-tree edits are not included.
+    Only lines actually added (``+`` lines inside a hunk) count -- context
+    lines and hunk-header ranges do not, so a -U3 diff (``gh pr diff``,
+    the audit's --diff input) scopes exactly like a -U0 one. Deleted
+    lines do not advance the new-side number; ``\\ No newline`` lines
+    neither. Deleted files and files with no added lines contribute
+    nothing.
     """
-    merge_base = resolve_diff_base(repo, base)
-    raw = _git(repo, "diff", merge_base, "HEAD", "-U0", "--")
     changed = {}
     current = None
-    for line in raw.splitlines():
+    new_lineno = None
+    for line in diff_text.splitlines():
         if line.startswith("+++ "):
             target = line[4:].strip()
             if target in ("/dev/null", ""):
                 current = None
+                new_lineno = None
                 continue
             if target.startswith("b/"):
                 target = target[2:]
@@ -151,14 +184,54 @@ def changed_lines(repo, base="main"):
                 target = json.loads(target)
             current = os.path.realpath(os.path.join(repo, target))
             changed.setdefault(current, set())
+            new_lineno = None
         elif line.startswith("@@ ") and current is not None:
             match = _HUNK_RE.match(line)
-            if match is None:
-                continue
-            start = int(match.group(1))
-            count = int(match.group(2)) if match.group(2) is not None else 1
-            changed[current].update(range(start, start + count))
-    return merge_base, {path: lines for path, lines in changed.items() if lines}
+            new_lineno = int(match.group(1)) if match else None
+        elif current is None or new_lineno is None:
+            continue
+        elif line.startswith("+") and not line.startswith("+++"):
+            changed[current].add(new_lineno)
+            new_lineno += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            pass  # deleted line: the new-side number does not advance
+        elif line.startswith("\\"):
+            pass  # "": no advance
+        else:
+            new_lineno += 1  # context line
+    return {path: lines for path, lines in changed.items() if lines}
+
+
+def changed_lines_from_diff(diff_text, repo):
+    """Changed lines from a unified diff *text* (slice 3, for the audit).
+
+    Unlike :func:`changed_lines` this needs no git state: the audit
+    replays an uncommitted diff (or a PR diff) in a scratch clone, where
+    the change is not a commit yet. Same return shape as
+    :func:`changed_lines` minus the merge-base.
+    """
+    return _parse_unified_diff(diff_text, repo)
+
+
+def changed_lines(repo, base="main", uncommitted=False):
+    """Return ``(merge_base_sha, {abspath: {new-side line numbers}})``.
+
+    The diff is ``git diff <merge-base> HEAD -U0``: committed changes on
+    this branch only. With ``uncommitted=True`` the working tree + staged
+    changes vs HEAD (``git diff HEAD -U0``) are unioned in, for the
+    workflow atom, where the change under review is still uncommitted.
+    A file's changed lines are its added lines. Deleted files contribute
+    nothing; without ``uncommitted``, uncommitted working-tree edits are
+    not included.
+    """
+    merge_base = resolve_diff_base(repo, base)
+    raw = _git(repo, "diff", merge_base, "HEAD", "-U0", "--")
+    changed = _parse_unified_diff(raw, repo)
+    if uncommitted:
+        raw_wt = _git(repo, "diff", "HEAD", "-U0", "--")
+        for path, lines in _parse_unified_diff(raw_wt, repo).items():
+            changed.setdefault(path, set()).update(lines)
+    return merge_base, changed
 
 
 def assert_in_scope(entry, changed):
@@ -172,9 +245,9 @@ def assert_in_scope(entry, changed):
     )
 
 
-def load_diff_scope(repo, base="main"):
+def load_diff_scope(repo, base="main", uncommitted=False):
     """``{'base': <merge-base sha>, 'changed': {path: [lines]}}`` (JSON-safe)."""
-    merge_base, changed = changed_lines(repo, base)
+    merge_base, changed = changed_lines(repo, base, uncommitted=uncommitted)
     return {
         "base": merge_base,
         "changed": {path: sorted(lines) for path, lines in changed.items()},
@@ -218,11 +291,21 @@ class _AssertionExecutionPlugin:
     def pytest_sessionstart(self, session):
         self._old_trace = sys.gettrace()
         sys.settrace(self._global_trace)
-        if os.environ.get(DIFF_ONLY_ENV):
+        if os.environ.get(DIFF_FILE_ENV):
+            # Slice 3 (audit): scope from a diff text, not from git state --
+            # the audited change may be uncommitted in a scratch clone.
+            try:
+                text = Path(os.environ[DIFF_FILE_ENV]).read_text(encoding="utf-8")
+                self.diff_changed = changed_lines_from_diff(text, self.rootdir)
+                self.diff_base = None
+            except Exception as exc:  # noqa: BLE001 - surface as evidence, not a crash
+                self.diff_error = str(exc)
+        elif os.environ.get(DIFF_ONLY_ENV):
             try:
                 base = os.environ.get(DIFF_BASE_ENV) or "main"
                 self.diff_base, self.diff_changed = changed_lines(
-                    self.rootdir, base
+                    self.rootdir, base,
+                    uncommitted=bool(os.environ.get(INCLUDE_UNCOMMITTED_ENV)),
                 )
             except Exception as exc:  # noqa: BLE001 - surface as evidence, not a crash
                 self.diff_error = str(exc)
@@ -373,34 +456,234 @@ def write_evidence(evidence):
 # CLI: run pytest under the plugin, then judge the evidence
 # ---------------------------------------------------------------------------
 
+def _pytest_available(pytest_python):
+    """True when ``pytest_python`` can import pytest."""
+    try:
+        proc = subprocess.run(
+            [pytest_python, "-c", "import pytest"],
+            capture_output=True, text=True, timeout=60,
+        )
+    except OSError:
+        return False
+    return proc.returncode == 0
+
+
+def _atom_summary(*, ok, verdict, proof_file, evidence, pytest_exit):
+    return {
+        "ok": ok,
+        "verdict": verdict,
+        "proof_file": str(proof_file),
+        "executed": evidence.get("executed", 0),
+        "total": evidence.get("total", 0),
+        "unexecuted": len(evidence.get("unexecuted", [])),
+        "skipped": len(evidence.get("skipped", [])),
+        "pytest_exit": pytest_exit,
+    }
+
+
 def run_gate(*, root, output, pytest_python, pytest_args,
-             only_changed=False, diff_base="main"):
+             only_changed=False, diff_base="main", diff_file=None,
+             include_uncommitted=False, change_id=None, project_root=None):
+    """Run pytest under the plugin, then judge the evidence.
+
+    Slice 3 additions: ``diff_file`` scopes from a diff text instead of a
+    git range (the audit's case); ``include_uncommitted`` unions the
+    working tree into the git-range scope; ``change_id`` switches on atom
+    mode (evidence to ``specs/changes/<id>/tdd/i6d-0.json``, stdout a
+    single JSON line for the workflow executor). Atom mode always counts
+    uncommitted changes -- the change under review is still uncommitted
+    when the workflow runs -- and passes without running pytest when the
+    diff touches no Python test files.
+    """
+    atom_mode = change_id is not None
+    if atom_mode:
+        root = project_root or root
+        include_uncommitted = True
+    root = os.path.realpath(root)
+    output = os.path.abspath(output)
+    parent = os.path.dirname(output)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    # Resolve the diff scope before running pytest: the audit and the
+    # atom both need the changed Python test files as pytest targets, and
+    # the atom short-circuits when there are none.
+    changed = None
+    diff_base_out = None
+    diff_source = None
+    diff_error = None
+    if only_changed:
+        try:
+            if diff_file is not None:
+                with open(diff_file, encoding="utf-8") as handle:
+                    changed = changed_lines_from_diff(handle.read(), root)
+                diff_source = "diff-file"
+            else:
+                diff_base_out, changed = changed_lines(
+                    root, diff_base, uncommitted=include_uncommitted,
+                )
+                diff_source = (
+                    "git-range+uncommitted" if include_uncommitted
+                    else "git-range"
+                )
+        except Exception as exc:  # noqa: BLE001 - surface as evidence, not a crash
+            diff_error = str(exc)
+
+    targets = []
+    if only_changed and changed is not None and not pytest_args:
+        targets = sorted(
+            os.path.relpath(path, root)
+            for path, lines in changed.items()
+            if is_python_test_file(path) and lines
+            and os.path.exists(path)
+        )
+        pytest_args = targets
+
+    if atom_mode and only_changed and not pytest_args and diff_error is None:
+        # No changed Python test files: nothing for the gate to judge.
+        # Slice 2's empty-diff contract is "pass", so the atom passes
+        # without running pytest at all.
+        evidence = {
+            "tool": "i6d_assertion_execution",
+            "version": VERSION,
+            "root": root,
+            "pytestExit": None,
+            "verdict": "pass",
+            "total": 0,
+            "executed": 0,
+            "unexecuted": [],
+            "skipped": [],
+            "diffBase": diff_base_out,
+            "diffSource": diff_source,
+            "inScope": 0,
+            "outOfScope": [],
+            "notApplicable": "no_python_test_changes",
+        }
+        with open(output, "w", encoding="utf-8") as handle:
+            json.dump(evidence, handle, indent=2)
+        print(json.dumps(_atom_summary(
+            ok=True, verdict="pass", proof_file=output,
+            evidence=evidence, pytest_exit=None,
+        )))
+        return 0
+
+    if diff_error is not None:
+        evidence = {
+            "tool": "i6d_assertion_execution",
+            "version": VERSION,
+            "root": root,
+            "pytestExit": None,
+            "verdict": "diff_error",
+            "total": 0,
+            "executed": 0,
+            "unexecuted": [],
+            "skipped": [],
+            "diffBase": diff_base_out,
+            "diffSource": diff_source,
+            "diffError": diff_error,
+        }
+        with open(output, "w", encoding="utf-8") as handle:
+            json.dump(evidence, handle, indent=2)
+        if atom_mode:
+            print(json.dumps(_atom_summary(
+                ok=False, verdict="diff_error", proof_file=output,
+                evidence=evidence, pytest_exit=None,
+            )))
+        else:
+            print(f"i6d: diff_error: {diff_error}", file=sys.stderr)
+        return 2
+
     atoms_dir = str(Path(__file__).resolve().parent)
     env = dict(os.environ)
-    env[EVIDENCE_ENV] = os.path.abspath(output)
+    env[EVIDENCE_ENV] = output
     if only_changed:
         env[DIFF_ONLY_ENV] = "1"
         env[DIFF_BASE_ENV] = diff_base
+        if diff_file is not None:
+            env[DIFF_FILE_ENV] = os.path.abspath(diff_file)
+        if include_uncommitted:
+            env[INCLUDE_UNCOMMITTED_ENV] = "1"
     env["PYTHONPATH"] = atoms_dir + os.pathsep + env.get("PYTHONPATH", "")
+
+    if not _pytest_available(pytest_python):
+        # The gate cannot judge anything without pytest. When the diff
+        # touches Python test files this is a real gap (exit 2), not a
+        # silent pass; statically count the asserts at stake for the
+        # evidence so the failure names what could not be judged.
+        total = 0
+        for target in (pytest_args or []):
+            candidate = target if os.path.isabs(target) else os.path.join(root, target)
+            if is_python_test_file(candidate) and os.path.exists(candidate):
+                try:
+                    total += len(collect_assertions(candidate))
+                except Exception:  # noqa: BLE001 - best effort only
+                    pass
+        evidence = {
+            "tool": "i6d_assertion_execution",
+            "version": VERSION,
+            "root": root,
+            "pytestExit": None,
+            "verdict": "pytest_unavailable",
+            "total": total,
+            "executed": 0,
+            "unexecuted": [],
+            "skipped": [],
+            "diffBase": diff_base_out,
+            "diffSource": diff_source,
+            "inScope": total if only_changed else None,
+            "outOfScope": [],
+        }
+        with open(output, "w", encoding="utf-8") as handle:
+            json.dump(evidence, handle, indent=2)
+        if atom_mode:
+            print(json.dumps(_atom_summary(
+                ok=False, verdict="pytest_unavailable", proof_file=output,
+                evidence=evidence, pytest_exit=None,
+            )))
+        else:
+            print("i6d: pytest_unavailable: "
+                  f"{pytest_python} cannot import pytest", file=sys.stderr)
+        return 2
+
     command = [pytest_python, "-m", "pytest", "-p", "i6d_assertion_execution", *pytest_args]
     try:
-        proc = subprocess.run(command, cwd=root, env=env)
+        # Atom mode: the workflow executor parses stdout as one JSON line,
+        # so pytest's own session output must not leak onto stdout. Capture
+        # it; the evidence JSON carries the verdict, and the tail is only
+        # surfaced when no evidence was written.
+        if atom_mode:
+            proc = subprocess.run(command, cwd=root, env=env,
+                                  capture_output=True, text=True)
+        else:
+            proc = subprocess.run(command, cwd=root, env=env)
     except OSError as exc:
         print(f"i6d: could not run pytest: {exc}", file=sys.stderr)
         return 2
     try:
-        with open(os.path.abspath(output), encoding="utf-8") as handle:
+        with open(output, encoding="utf-8") as handle:
             evidence = json.load(handle)
     except (OSError, json.JSONDecodeError) as exc:
-        print(f"i6d: no evidence written ({exc}); pytest exit {proc.returncode}", file=sys.stderr)
+        detail = f"pytest exit {proc.returncode}"
+        if atom_mode and getattr(proc, "stdout", None):
+            detail += f"; pytest output tail: {(proc.stdout or '')[-500:]}"
+        print(f"i6d: no evidence written ({exc}); {detail}", file=sys.stderr)
         return 2
     evidence["pytestExit"] = proc.returncode
+    if diff_source is not None:
+        evidence["diffSource"] = diff_source
     if evidence["verdict"] == "unexecuted_assertions" and proc.returncode == 0:
         pass  # verdict already reflects the gate; pytest itself passed.
     elif proc.returncode != 0 and not evidence["unexecuted"]:
         evidence["verdict"] = "pytest_failed"
-    with open(os.path.abspath(output), "w", encoding="utf-8") as handle:
+    with open(output, "w", encoding="utf-8") as handle:
         json.dump(evidence, handle, indent=2)
+    if atom_mode:
+        ok = evidence["verdict"] == "pass"
+        print(json.dumps(_atom_summary(
+            ok=ok, verdict=evidence["verdict"], proof_file=output,
+            evidence=evidence, pytest_exit=proc.returncode,
+        )))
+        return 0 if ok else 1
     summary = (
         f"i6d: {evidence['verdict']} "
         f"({evidence['executed']}/{evidence['total']} assertions executed, "
@@ -422,27 +705,52 @@ def main(argv=None):
     parser = argparse.ArgumentParser(
         description="I6d assertion-execution gate: prove every assert in "
         "the pytest run really executed (slice 2 adds --only-changed to "
-        "judge only asserts added/changed vs a diff base, default main)."
+        "judge only asserts added/changed vs a diff base, default main; "
+        "slice 3 adds --diff-file to scope from a diff text, and "
+        "--change-id atom mode for the workflow executor)."
     )
     parser.add_argument("--root", default=os.getcwd(), help="project root to run pytest in")
-    parser.add_argument("--output", default=".evalid-i6d-evidence.json",
-                        help="where to write the evidence JSON")
+    parser.add_argument("--project-root", default=None,
+                        help="alias for --root (workflow executor passes this)")
+    parser.add_argument("--output", default=None,
+                        help="where to write the evidence JSON "
+                        "(default: specs/changes/<id>/tdd/i6d-0.json in atom mode, "
+                        ".evalid-i6d-evidence.json otherwise)")
     parser.add_argument("--pytest-python", default=sys.executable,
                         help="python binary to run pytest with")
     parser.add_argument("--only-changed", action="store_true",
                         help="only judge asserts in the diff vs --diff-base")
     parser.add_argument("--diff-base", default="main",
                         help="diff base ref (merge-base of HEAD and this ref; default main)")
+    parser.add_argument("--diff-file", default=None,
+                        help="scope from a unified diff file instead of a git range")
+    parser.add_argument("--include-uncommitted", action="store_true",
+                        help="union working-tree + staged changes vs HEAD into the scope")
+    parser.add_argument("--change-id", default=None,
+                        help="atom mode: write evidence to specs/changes/<id>/tdd/i6d-0.json "
+                        "and print a single JSON summary line")
     parser.add_argument("pytest_args", nargs="*", help="arguments passed to pytest (after --)")
     args = parser.parse_args(argv)
+    root = args.project_root or args.root
+    if args.output:
+        output = args.output
+    elif args.change_id:
+        output = os.path.join(
+            root, "specs", "changes", args.change_id, "tdd", "i6d-0.json")
+    else:
+        output = ".evalid-i6d-evidence.json"
     # argparse keeps a literal "--" out of pytest_args already.
     return run_gate(
-        root=args.root,
-        output=args.output,
+        root=root,
+        output=output,
         pytest_python=args.pytest_python,
         pytest_args=args.pytest_args,
         only_changed=args.only_changed,
         diff_base=args.diff_base,
+        diff_file=args.diff_file,
+        include_uncommitted=args.include_uncommitted,
+        change_id=args.change_id,
+        project_root=args.project_root,
     )