@kontourai/flow-agents 2.3.0 → 3.0.0

package/evals/integration/test_promote_gate.sh

@@ -0,0 +1,178 @@
+#!/usr/bin/env bash
+# test_promote_gate.sh - promote-then-archive gate (issue #312).
+#
+# Durable-residue extraction is the archival act. Covers:
+#   1. promote writes a well-formed, session-local promotion claim referencing
+#      existing durable doc paths (metadata.promotion + policy_rule evidence, no
+#      execution.label) and an auditable promotion.json.
+#   2. promote REJECTS a nonexistent --evidence-path (fail loud).
+#   3. promote --none --reason records an explicit no-residue claim; --none without
+#      --reason is refused.
+#   4. cleanup-audit classification: a delivered/accepted session WITHOUT a promotion
+#      claim is a cleanup_candidate (blocked from archive) with a remedy naming the
+#      promote step; WITH a real claim OR a --none claim it stays terminal_done (AC1-3).
+#   5. CRITICAL: trust-reconcile stays exit 0 on a bundle carrying a promotion claim -
+#      the claim classifies session-local (ATTESTED), never an unbacked/not-run command
+#      divergence (proves R1 reconcile-safety, no new manifest entry required).
+#
+# Deterministic, no model spend, self-cleaning.
+# Usage: bash evals/integration/test_promote_gate.sh
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+source "$ROOT/evals/lib/node.sh"
+
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+unset FORCE_COLOR  # known local artifact that can perturb child-process output
+
+errors=0
+pass() { echo "  PASS: $1"; }
+fail() { echo "  FAIL: $1"; errors=$((errors + 1)); }
+
+echo "=== Promote-then-archive gate (#312) ==="
+
+# JSON reader helpers (dedicated files; no inline interpreter flags).
+cat > "$TMP/inspect.cjs" <<'JS'
+const fs = require("fs");
+const b = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+const claim = (b.claims || []).find((c) => c.metadata && c.metadata.promotion);
+const ev = claim && (b.evidence || []).find((e) => e.claimId === claim.id);
+const out = {
+  found: String(!!claim),
+  status: (claim && claim.status) || "",
+  targets: (claim && claim.metadata.promotion.targets) || [],
+  none: String(claim ? claim.metadata.promotion.none : ""),
+  evidenceType: (ev && ev.evidenceType) || "",
+  hasExecutionLabel: String(!!(ev && ev.execution && ev.execution.label)),
+};
+fs.writeFileSync(process.argv[3], JSON.stringify(out));
+JS
+cat > "$TMP/field.cjs" <<'JS'
+const fs = require("fs");
+const o = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+let v = o;
+for (const k of process.argv[3].split(".")) v = v[k];
+console.log(Array.isArray(v) ? v.join(",") : v);
+JS
+cat > "$TMP/bucketof.cjs" <<'JS'
+const fs = require("fs");
+const d = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+for (const [b, arr] of Object.entries(d.buckets)) {
+  for (const it of arr) if (it.slug === process.argv[3]) { console.log(b + "|" + (it.reasons[0] || "")); process.exit(0); }
+}
+console.log("MISSING|");
+JS
+
+REPO="$TMP/repo"
+mkdir -p "$REPO/kits" "$REPO/docs/decisions" "$REPO/docs/learnings"
+printf 'x\n' > "$REPO/docs/decisions/promotion-gate.md"
+printf 'y\n' > "$REPO/docs/learnings/note.md"
+SESSION_ROOT="$REPO/.kontourai/flow-agents"
+
+ensure() {
+  flow_agents_node workflow-sidecar ensure-session \
+    --artifact-root "$SESSION_ROOT" --task-slug "$1" \
+    --source-request "r" --title "T" --summary "s" \
+    --criterion "c1" --next-action "n" --timestamp "2026-07-02T00:00:00Z" \
+    >/dev/null 2>"$TMP/$1.ensure.err"
+}
+seed_evidence() {
+  flow_agents_node workflow-sidecar record-evidence "$1" --verdict pass \
+    --check-json '{"id":"docs-check","kind":"policy","status":"pass","summary":"docs reviewed"}' \
+    --timestamp "2026-07-02T00:01:00Z" >/dev/null 2>"$TMP/ev.err"
+}
+term_state() {
+  printf '{"schema_version":"1.0","task_slug":"%s","status":"accepted","phase":"done","updated_at":"2026-07-02T00:00:00Z","next_action":{"status":"done","summary":"done"}}' "$2" > "$1/state.json"
+}
+field() { node "$TMP/field.cjs" "$1" "$2"; }
+
+# --- 1. promote writes a well-formed session-local claim ---------------------
+ensure promoted
+PDIR="$SESSION_ROOT/promoted"
+seed_evidence "$PDIR"
+if flow_agents_node workflow-sidecar promote "$PDIR" --repo-root "$REPO" \
+     --evidence-path docs/decisions/promotion-gate.md \
+     --evidence-path docs/learnings/note.md \
+     --timestamp "2026-07-02T00:02:00Z" >"$TMP/promote.out" 2>"$TMP/promote.err"; then
+  pass "promote with existing paths exits 0"
+else
+  fail "promote with existing paths should exit 0: $(cat "$TMP/promote.err")"
+fi
+[[ -f "$PDIR/promotion.json" ]] && pass "promote writes auditable promotion.json" || fail "promote writes auditable promotion.json"
+
+node "$TMP/inspect.cjs" "$PDIR/trust.bundle" "$TMP/shape.json"
+[[ "$(field "$TMP/shape.json" found)" == "true" ]] && pass "bundle carries a promotion claim (metadata.promotion)" || fail "bundle carries a promotion claim"
+[[ "$(field "$TMP/shape.json" status)" == "verified" ]] && pass "promotion claim derives status verified" || fail "promotion claim derives status verified (got $(field "$TMP/shape.json" status))"
+[[ "$(field "$TMP/shape.json" evidenceType)" == "policy_rule" ]] && pass "promotion evidence is session-local policy_rule" || fail "promotion evidence is session-local policy_rule (got $(field "$TMP/shape.json" evidenceType))"
+[[ "$(field "$TMP/shape.json" hasExecutionLabel)" == "false" ]] && pass "promotion claim carries no execution.label (never a manifest command)" || fail "promotion claim must not carry an execution.label"
+[[ "$(field "$TMP/shape.json" targets)" == "docs/decisions/promotion-gate.md,docs/learnings/note.md" ]] && pass "promotion evidence refs = the durable doc paths written" || fail "promotion targets wrong: $(field "$TMP/shape.json" targets)"
+
+# --- 2. promote rejects a nonexistent path -----------------------------------
+if flow_agents_node workflow-sidecar promote "$PDIR" --repo-root "$REPO" \
+     --evidence-path docs/decisions/does-not-exist.md \
+     --timestamp "2026-07-02T00:03:00Z" >"$TMP/bad.out" 2>"$TMP/bad.err"; then
+  fail "promote should reject a nonexistent evidence path"
+else
+  grep -q "does not exist on disk" "$TMP/bad.err" && pass "promote rejects a nonexistent evidence path (fail loud)" || fail "promote rejection message unclear: $(cat "$TMP/bad.err")"
+fi
+
+# --- 3. explicit no-residue promotion ----------------------------------------
+ensure none-promoted
+NDIR="$SESSION_ROOT/none-promoted"
+seed_evidence "$NDIR"
+if flow_agents_node workflow-sidecar promote "$NDIR" --repo-root "$REPO" \
+     --none --reason "no durable residue: pure refactor" \
+     --timestamp "2026-07-02T00:04:00Z" >"$TMP/none.out" 2>"$TMP/none.err"; then
+  pass "promote --none --reason exits 0"
+else
+  fail "promote --none --reason should exit 0: $(cat "$TMP/none.err")"
+fi
+node "$TMP/inspect.cjs" "$NDIR/trust.bundle" "$TMP/noneshape.json"
+[[ "$(field "$TMP/noneshape.json" none)" == "true" ]] && pass "no-residue claim records none=true" || fail "no-residue claim should record none=true"
+
+if flow_agents_node workflow-sidecar promote "$NDIR" --none \
+     --timestamp "2026-07-02T00:05:00Z" >"$TMP/none2.out" 2>"$TMP/none2.err"; then
+  fail "promote --none without --reason should be refused"
+else
+  grep -q "requires --reason" "$TMP/none2.err" && pass "promote --none without --reason is refused" || fail "promote --none reason-required message unclear"
+fi
+
+# --- 4. cleanup-audit classification with/without the claim ------------------
+AUDIT_ROOT="$TMP/audit-root"
+mkdir -p "$AUDIT_ROOT/promoted" "$AUDIT_ROOT/none-promoted" "$AUDIT_ROOT/unpromoted"
+term_state "$AUDIT_ROOT/promoted" promoted
+term_state "$AUDIT_ROOT/none-promoted" none-promoted
+term_state "$AUDIT_ROOT/unpromoted" unpromoted
+cp "$PDIR/trust.bundle" "$AUDIT_ROOT/promoted/trust.bundle"
+cp "$NDIR/trust.bundle" "$AUDIT_ROOT/none-promoted/trust.bundle"
+# unpromoted: deliberately no trust.bundle
+
+flow_agents_node workflow-artifact-cleanup-audit --artifact-root "$AUDIT_ROOT" --json > "$TMP/audit.json" 2>&1
+bucketof() { node "$TMP/bucketof.cjs" "$TMP/audit.json" "$1"; }
+[[ "$(bucketof promoted | cut -d'|' -f1)" == "terminal_done" ]] && pass "promoted session stays terminal_done" || fail "promoted session should be terminal_done (got $(bucketof promoted))"
+[[ "$(bucketof none-promoted | cut -d'|' -f1)" == "terminal_done" ]] && pass "no-residue promoted session stays terminal_done" || fail "no-residue session should be terminal_done (got $(bucketof none-promoted))"
+[[ "$(bucketof unpromoted | cut -d'|' -f1)" == "cleanup_candidate" ]] && pass "unpromoted delivered session is a cleanup_candidate (archive blocked)" || fail "unpromoted session should be cleanup_candidate (got $(bucketof unpromoted))"
+bucketof unpromoted | grep -q "promote" && pass "cleanup_candidate reason names the promote remedy" || fail "cleanup_candidate reason should name the promote step"
+
+# --- 5. CRITICAL: trust-reconcile exit 0 on a bundle with a promotion claim --
+if node "$ROOT/scripts/ci/trust-reconcile.js" --bundle "$PDIR/trust.bundle" \
+     --commands "true" --repo-root "$REPO" >"$TMP/reconcile.out" 2>&1; then
+  pass "trust-reconcile exits 0 on a bundle carrying a promotion claim"
+else
+  fail "trust-reconcile should exit 0 on a promotion-claim bundle: $(tail -5 "$TMP/reconcile.out")"
+fi
+if grep -q "ATTESTED" "$TMP/reconcile.out" && ! grep -q "trust divergence" "$TMP/reconcile.out"; then
+  pass "promotion claim classifies session-local (ATTESTED), never an unbacked/not-run command"
+else
+  fail "promotion claim must classify session-local, not as a command divergence"
+  grep -iE "classified|ATTESTED|trust divergence" "$TMP/reconcile.out"
+fi
+
+echo ""
+if [[ "$errors" -eq 0 ]]; then
+  echo "Promote-then-archive gate checks passed"
+else
+  echo "Promote-then-archive gate checks failed: $errors"
+  exit 1
+fi

package/evals/integration/test_publish_delivery.sh

@@ -4,8 +4,10 @@
 # Proves that:
 #   1. END-TO-END-RECORD-RELEASE: record-release auto-publishes trust.bundle.
 #   2. SUBCOMMAND: publish-delivery subcommand copies bundle to delivery/.
-#   3. RECONCILE-DIVERGENCE: delivery trust.bundle + CI fail -> exit 1.
-#   4. RECONCILE-MATCHING: delivery trust.bundle + CI pass -> exit 0.
+#   3. RECONCILE-DIVERGENCE: delivery trust.bundle (+ matching-sha checkpoint sibling, ADR
+#      0022 addendum part 2 bundle-ownership binding) + CI fail -> exit 1.
+#   4. RECONCILE-MATCHING: delivery trust.bundle (+ matching-sha checkpoint sibling) + CI
+#      pass -> exit 0.
 #   5. FAIL-SOFT: no trust.bundle -> publishDelivery skips, record-release exits 0.
 #
 # Deterministic, no model spend, self-cleaning.
@@ -41,10 +43,10 @@ code_lines = [
   "const fs = require('fs');",
   "const [,, dest, label, passingStr] = process.argv;",
   "const passing = passingStr === 'true';",
-  "const b = { schemaVersion: 3, source: 'test-fixture',",
+  "const b = { schemaVersion: 5, source: 'test-fixture',",
   "  claims: [{ id: 'c1', claimType: 'workflow.check.build',",
   "    value: passing ? 'pass' : 'fail', status: passing ? 'verified' : 'disputed',",
-  "    subjectId: 'ts/build', surface: 'flow-agents.workflow',",
+  "    subjectId: 'ts/build', facet: 'flow-agents.workflow',",
   "    subjectType: 'workflow-check', fieldOrBehavior: 'build',",
   "    createdAt: '2026-06-27T00:00:00Z', updatedAt: '2026-06-27T00:00:00Z',",
   "    impactLevel: 'high', verificationPolicyId: 'policy:wf.build' }],",
@@ -63,6 +65,19 @@ PY
   node "$helper" "$dest" "$label" "$passing"
 }
 
+# write_checkpoint_to <delivery_dir> <sha>
+# Writes a minimal, well-formed trust.checkpoint.json naming <sha> as commit_sha, so a
+# bare fixture trust.bundle written directly into delivery/ (TEST 3/4 below -- these do
+# NOT go through the real seal-checkpoint pipeline) still carries the commit-identity
+# binding trust-reconcile.js's bundle-ownership staleness check now requires (ADR 0022
+# addendum, part 2) for an auto-discovered bundle to be treated as owned by the change
+# under test, not stale.
+write_checkpoint_to() {
+  local delivery_dir="$1" sha="$2"
+  printf '{"schema_version":"1.0","slug":"publish-delivery-fixture","work_item":null,"status":"delivered","phase":"release","sealed_at":"2026-06-27T00:00:00Z","commit_sha":"%s","checkpoint":{"asOf":"2026-06-27T00:00:00.000Z","statusByClaimId":{}}}' \
+    "$sha" > "$delivery_dir/trust.checkpoint.json"
+}
+
 # Session setup helper
 setup_session() {
   local aroot="$1" slug="$2" bundle_src="$3"
@@ -181,8 +196,9 @@ mkdir -p "$REPO3/delivery"
 # -> claimed cmd not in canonical set -> not-run divergence, AND canonical fails
 DELIVERY3="$REPO3/delivery/trust.bundle"
 write_bundle_to "$DELIVERY3" "node --version" "true"
+write_checkpoint_to "$REPO3/delivery" "1111111111111111111111111111111111111111"
 
-recon3_out=$(TRUST_RECONCILE_COMMANDS="false" \
+recon3_out=$(TRUST_RECONCILE_SHA="1111111111111111111111111111111111111111" TRUST_RECONCILE_COMMANDS="false" \
   node "$RECONCILE" --repo-root "$REPO3" 2>&1)
 recon3_exit=$?
 
@@ -208,8 +224,9 @@ mkdir -p "$REPO4/delivery"
 # Bundle claims "node --version" passed; canonical verify is ALSO "node --version" (passes)
 DELIVERY4="$REPO4/delivery/trust.bundle"
 write_bundle_to "$DELIVERY4" "node --version" "true"
+write_checkpoint_to "$REPO4/delivery" "2222222222222222222222222222222222222222"
 
-recon4_out=$(TRUST_RECONCILE_COMMANDS="node --version" \
+recon4_out=$(TRUST_RECONCILE_SHA="2222222222222222222222222222222222222222" TRUST_RECONCILE_COMMANDS="node --version" \
   node "$RECONCILE" --repo-root "$REPO4" 2>&1)
 recon4_exit=$?
 

package/evals/integration/test_pull_work_assignment_join.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# test_pull_work_assignment_join.sh — Two-session disjoint-selection simulation (#290).
+#
+# HONESTY NOTE (plan Design Decision / Stop-Short Risks): this eval simulates the assignment ⋈
+# liveness join's exclusion property with two actor structs evaluating the same candidate
+# subject id fixture in sequence, inside ONE process. It does NOT stand up two real concurrent
+# agent runtimes, and does not prove true concurrency (a real race between two simultaneous
+# writers). It is the closest *local* proof available for the issue's literal acceptance line
+# ("two sessions running pull-work against the same backlog select disjoint issues") without a
+# multi-runtime test harness this repo does not have — see the plan's Stop-Short Risks section.
+# What IS proven here, deterministically: once session A's assignment claim is recorded (local-
+# file or a rendered-then-status-confirmed GitHub fixture), session B's subsequent
+# `assignment-provider status` / join check for the SAME subject reports it `held` (excluded),
+# never `free` — so `pull-work`'s selection loop (kits/builder/skills/pull-work/SKILL.md,
+# "### 1. Read Board State") would skip it for session B.
+#
+# Supports AC12 (disjoint-selection-simulated), AC10 (docs pointer — see
+# docs/workflow-usage-guide.md's new Assignment Ownership subsection).
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+CLI="$ROOT/build/src/cli.js"
+FIXTURES="$ROOT/evals/fixtures/assignment-provider"
+ACTOR_A="$FIXTURES/actor-a.json"
+ACTOR_B="$FIXTURES/actor-b.json"
+ISSUE_CLAIMED="$FIXTURES/github-issue-claimed.json"
+LIVENESS_FRESH="$FIXTURES/liveness-fresh.json"
+
+TMPDIR_EVAL="$(mktemp -d)"
+trap 'rm -rf "$TMPDIR_EVAL"' EXIT
+ARTIFACT_ROOT="$TMPDIR_EVAL/artifact-root"
+
+errors=0
+pass() { echo "  ✓ $1"; }
+fail() { echo "  ✗ $1"; errors=$((errors + 1)); }
+
+json_query() {
+  node -e 'const fs=require("fs"); let cur=JSON.parse(fs.readFileSync(process.argv[1],"utf8")); for (const part of process.argv[2].split(".")) cur=part==="length" ? cur.length : (Array.isArray(cur) ? cur[Number(part)] : cur[part]); console.log(cur);' "$1" "$2"
+}
+
+if [[ ! -f "$CLI" ]]; then
+  echo "build/src/cli.js not found — run 'npm run build' first" >&2
+  exit 1
+fi
+
+echo "=== Two-session disjoint-selection simulation (assignment ⋈ liveness join) ==="
+
+EMPTY_LIVENESS="$TMPDIR_EVAL/liveness-empty.json"
+echo '[]' > "$EMPTY_LIVENESS"
+
+# --- local-file leg: session A claims, session B's join check on the same subject is excluded ---
+
+SUBJECT_ID="kontourai/flow-agents#9301"
+
+# "Session A" (actor A) evaluates the candidate subject before anyone has claimed it: free.
+node "$CLI" assignment-provider status \
+  --provider local-file --artifact-root "$ARTIFACT_ROOT" --subject-id "$SUBJECT_ID" \
+  --self-actor "claude-code:eval-actor-a-session:eval-host" --liveness-events-json "$EMPTY_LIVENESS" \
+  > "$TMPDIR_EVAL/session-a-preclaim.json"
+[[ "$(json_query "$TMPDIR_EVAL/session-a-preclaim.json" "effective.effective_state")" == "free" ]] && pass "local-file: candidate subject is free before either session claims" || fail "local-file: candidate subject is free before either session claims"
+
+# Session A selects and claims it (pull-work's "Assignment Claim On Selection" step).
+node "$CLI" assignment-provider claim \
+  --provider local-file --artifact-root "$ARTIFACT_ROOT" --subject-id "$SUBJECT_ID" \
+  --actor-json "$ACTOR_A" --branch "agent/claude-code-eval-actor-a-session-eval-host/flow-agents-9301" \
+  --artifact-dir ".kontourai/flow-agents/flow-agents-9301" > /dev/null
+status=$?
+[[ "$status" -eq 0 ]] && pass "local-file: session A's claim on the candidate subject succeeds" || fail "local-file: session A's claim on the candidate subject succeeds"
+
+# "Session B" (actor B, a distinct actor struct — the second concurrent pull-work session)
+# evaluates the SAME candidate subject next. Its own liveness heartbeat is fresh (it is alive),
+# but that must not matter: the join is computed against the HOLDER's freshness, not the
+# reader's — session B must see the subject excluded.
+NOW_ISO="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+cat > "$TMPDIR_EVAL/liveness-actor-a-fresh.json" <<JSON
+[
+  {"type":"claim","subjectId":"$SUBJECT_ID","actor":"claude-code:eval-actor-a-session:eval-host","at":"$NOW_ISO","ttlSeconds":1800}
+]
+JSON
+node "$CLI" assignment-provider status \
+  --provider local-file --artifact-root "$ARTIFACT_ROOT" --subject-id "$SUBJECT_ID" \
+  --self-actor "claude-code:eval-actor-b-session:eval-host" \
+  --liveness-events-json "$TMPDIR_EVAL/liveness-actor-a-fresh.json" > "$TMPDIR_EVAL/session-b-postclaim.json"
+[[ "$(json_query "$TMPDIR_EVAL/session-b-postclaim.json" "assignment.assignee")" == "claude-code:eval-actor-a-session:eval-host" ]] && pass "local-file: session B's status read shows actor A as the holder" || fail "local-file: session B's status read shows actor A as the holder"
+[[ "$(json_query "$TMPDIR_EVAL/session-b-postclaim.json" "effective.effective_state")" == "held" ]] && pass "local-file: session B's join check reports held (excluded) for the same subject session A just claimed" || fail "local-file: session B's join check reports held (excluded) for the same subject session A just claimed"
+[[ "$(json_query "$TMPDIR_EVAL/session-b-postclaim.json" "effective.effective_state")" != "free" ]] && pass "local-file: subject is definitively NOT free for session B (disjoint selection holds)" || fail "local-file: subject is definitively NOT free for session B (disjoint selection holds)"
+
+# Session B, correctly excluding the held subject, selects a DIFFERENT subject instead — the
+# literal "select disjoint issues" property, one selection loop iteration at a time.
+SUBJECT_ID_2="kontourai/flow-agents#9302"
+node "$CLI" assignment-provider status \
+  --provider local-file --artifact-root "$ARTIFACT_ROOT" --subject-id "$SUBJECT_ID_2" \
+  --self-actor "claude-code:eval-actor-b-session:eval-host" --liveness-events-json "$EMPTY_LIVENESS" \
+  > "$TMPDIR_EVAL/session-b-alternate.json"
+[[ "$(json_query "$TMPDIR_EVAL/session-b-alternate.json" "effective.effective_state")" == "free" ]] && pass "local-file: session B's alternate candidate is free — it can select a disjoint subject" || fail "local-file: session B's alternate candidate is free — it can select a disjoint subject"
+node "$CLI" assignment-provider claim \
+  --provider local-file --artifact-root "$ARTIFACT_ROOT" --subject-id "$SUBJECT_ID_2" \
+  --actor-json "$ACTOR_B" --branch "agent/claude-code-eval-actor-b-session-eval-host/flow-agents-9302" \
+  --artifact-dir ".kontourai/flow-agents/flow-agents-9302" > /dev/null
+[[ $? -eq 0 ]] && pass "local-file: session B claims the disjoint subject successfully" || fail "local-file: session B claims the disjoint subject successfully"
+
+# Final proof: the two sessions' claimed subject sets are disjoint.
+node "$CLI" assignment-provider list --provider local-file --artifact-root "$ARTIFACT_ROOT" --actor-json "$ACTOR_A" > "$TMPDIR_EVAL/list-a.json"
+node "$CLI" assignment-provider list --provider local-file --artifact-root "$ARTIFACT_ROOT" --actor-json "$ACTOR_B" > "$TMPDIR_EVAL/list-b.json"
+DISJOINT="$(node -e '
+const fs = require("fs");
+const a = JSON.parse(fs.readFileSync(process.argv[1], "utf8")).subject_ids;
+const b = JSON.parse(fs.readFileSync(process.argv[2], "utf8")).subject_ids;
+const overlap = a.filter((id) => b.includes(id));
+console.log(overlap.length === 0 && a.length === 1 && b.length === 1 ? "yes" : "no");
+' "$TMPDIR_EVAL/list-a.json" "$TMPDIR_EVAL/list-b.json")"
+[[ "$DISJOINT" == "yes" ]] && pass "session A and session B's claimed subject sets are disjoint (one each, no overlap)" || fail "session A and session B's claimed subject sets are disjoint (one each, no overlap)"
+
+# --- GitHub leg: a rendered-and-status-confirmed claim on a fixture also excludes a second reader ---
+
+# The already-claimed GitHub fixture stands in for "session A already claimed and the render
+# was executed + status-confirmed" (SKILL.md's "Assignment Claim On Selection" round trip).
+# "Session B" reads the SAME fixture next with a fresh liveness fixture for the holder: held.
+node "$CLI" assignment-provider status --provider github --issue-json "$ISSUE_CLAIMED" \
+  --self-actor "claude-code:eval-actor-b-session:eval-host" \
+  --liveness-events-json "$LIVENESS_FRESH" --now "2026-06-01T12:20:00Z" \
+  > "$TMPDIR_EVAL/github-session-b.json"
+[[ "$(json_query "$TMPDIR_EVAL/github-session-b.json" "effective.effective_state")" == "held" ]] && pass "github: session B's join check on an already-claimed fixture issue reports held (excluded)" || fail "github: session B's join check on an already-claimed fixture issue reports held (excluded)"
+[[ "$(json_query "$TMPDIR_EVAL/github-session-b.json" "effective.effective_state")" != "free" ]] && pass "github: subject is definitively NOT free for session B" || fail "github: subject is definitively NOT free for session B"
+
+echo ""
+if [[ "$errors" -eq 0 ]]; then
+  echo "test_pull_work_assignment_join: all checks passed."
+else
+  echo "test_pull_work_assignment_join: $errors check(s) failed."
+fi
+exit "$errors"