harness-everything 0.41.3 → 0.42.1

package/benchmarks/results/live-host/opencode-d1-d2-2026-10-25/README.md

@@ -0,0 +1,30 @@
+# OpenCode D1/D2 live-host observations — 2026-10-25
+
+**Retained negative observations only.** These attempts do not demonstrate a completed task, successful enforcement, or behavioral effectiveness.
+
+## Run record
+
+| Run | Product / fixture baseline | Requested model | Captured result |
+|---|---|---|---|
+| D1 | `37c97046`; fixture `f486e57d` | `opencode/beam-free#default` | Sanitized export records `failed` with direct error type `provider.free-limit`. Shell pipeline exit `1`; OpenCode process exit **UNKNOWN**; sanitized export exit `0`. |
+| D2 | `37c97046`; fixture `39aa0898` | `nvidia/deepseek-ai/deepseek-v4.1-flash` | Process exit `1`, signal `null`, timeout `false`, spawn failure `null`. One filtered stdout event had `type=error` and no session ID; stderr was `0` bytes. Session existence, provider-request status, and cause are **UNKNOWN**. |
+
+The user requested switching from the exhausted free quota to NVIDIA; one D2 invocation was attempted. NVIDIA's catalog listing and configured-auth-presence boolean came only from non-session preflight. The model variant was not shown. D2's filtered error omitted its discriminant, so its cause is unknown; this is not evidence of an NVIDIA outage.
+
+## Setup and retained evidence
+
+Both commands used `opencode run --standalone --format json` and process-local `XDG_CONFIG_HOME`, `OPENCODE_CONFIG_DIR`, `HARNESS_STATE_HOME`, `HARNESS_DOC_RECONCILIATION_PILOT=1`, and `HARNESS_D1_TRACE_FILE`. D1 used the beam-free model above; D2 requested the NVIDIA model above. No user-global credentials or configuration were changed.
+
+| Observation | D1 | D2 |
+|---|---|---|
+| Fixture | Commit clean before/after; ADR hash unchanged | Commit clean before/after; ADR hash unchanged |
+| Natural completion | Not observed | Not observed |
+| Observer | Load marker and trace absent | Trace absent; observer load **not observed** |
+| Refusal/report | No pilot report | Report capture **UNKNOWN**; no session ID was available for lookup |
+| Global Harness absence | **UNCHECKED** | **UNCHECKED** |
+
+The sanitized D1 export is not copied into this record; its SHA-256 is retained in [`evidence.json`](evidence.json). D2 raw stdout/stderr were not retained; only allowlisted metadata and hashes remain. `LOCAL_ONLY` source paths in `evidence.json` identify supporting packets and artifacts that are not shipped in this PR. The D2 runner and its exit/timeout self-check are also local-only; their self-check is deterministic mechanism evidence, not live-host evidence. This PR does not make the full runs publicly reproducible.
+
+## Interpretation
+
+Neither negative attempt qualifies as an E1 cycle or supports E1 GO, benefit, qualification, or promotion. D1 stopped on the free-provider limit. D2 returned an error event without a session ID; no cause or provider request can be established from retained metadata. This PR preserves negative observations only.

package/benchmarks/results/live-host/opencode-d1-d2-2026-10-25/evidence.json

@@ -0,0 +1,128 @@
+{
+  "schemaVersion": 1,
+  "clientDate": "2026-10-25",
+  "classification": "retained-negative-observations-only",
+  "publicReproduction": "LOCAL_ONLY supporting packets, fixtures, and runner are not shipped; this PR does not reproduce full runs",
+  "productBaseline": "37c97046cb1e620c4a3585b4da5a2593501a48be",
+  "runs": [
+    {
+      "id": "D1",
+      "engine": "OpenCode v2.1.4",
+      "requestedModel": "opencode/beam-free#default",
+      "fixtureCommit": "f486e57d1ba17d92e585b0b42dd4b9c71b2fda4a",
+      "sessionId": "ses_e8de7be3cffeBTghRaz6CN1T01",
+      "sessionOutcome": "failed",
+      "providerFailureType": "provider.free-limit",
+      "directSanitizedExportErrorTypes": [
+        "provider.free-limit",
+        "provider.free-limit"
+      ],
+      "process": {
+        "shellPipelineExit": 1,
+        "opencodeProcessExit": null,
+        "opencodeProcessExitStatus": "UNKNOWN: pipeline status captured without PIPESTATUS"
+      },
+      "sanitizedExport": {
+        "exitCode": 0,
+        "messageCount": 4,
+        "sha256": "91f80a5e8b2c94015a5a5602022aa45436cff2a52295615f7eb022aed91eee2b",
+        "source": "LOCAL_ONLY:.worktrees/packets/resume-2026-10-25/D1-current/fixture/trace/native-export.json"
+      },
+      "fixture": {
+        "gitCleanBeforeAndAfter": true,
+        "configSha256": "422eb8c6481aaadbf7910d4b415e76b2e60723bd0da4c532a94fad1879c38bcd",
+        "adrBeforeSha256": "65c903eedc1be2ca6022638fd9cab1f70c08c278e9e03be5c73ad0b2ecab4d18",
+        "adrAfterSha256": "65c903eedc1be2ca6022638fd9cab1f70c08c278e9e03be5c73ad0b2ecab4d18",
+        "taskPromptSha256": "524e58eeb6bd64e33986777b19a7fca8ec0829154fc2eb4b0c4a26b8e13b7b5e"
+      },
+      "observations": {
+        "naturalCompletionObserved": false,
+        "observerLoadMarkerObserved": false,
+        "observerTracePresent": false,
+        "pilotReportPresent": false,
+        "innerConsumerCause": "UNCHECKED",
+        "globalHarnessAbsence": "UNCHECKED"
+      },
+      "sourceArtifactSha256": {
+        "beforeState": "91018ac09c0e58537b53ffbef6adb1d2ecd5cc5b079cccc60484493aa592d474",
+        "afterState": "d2f729d1f5eb29b6a17b552fb06a31833ecbe4ef3eda5096e895ebfab212518c",
+        "filteredRunLog": "b1f1b48237c94733a6753440617e52c85ee754d1287a78b94d2513e5fdfa07a5",
+        "observerImplementation": "33a3a3c8da4f5dc495f7462952b11ee8ad46c4fa9ba0882152acd0eebf0ed56f",
+        "taskLocalPluginEntrypoint": "ad4eef698164e644e52eeb0c6f36bef56ca75a5c66d7cd71345d0091108f8fbe"
+      }
+    },
+    {
+      "id": "D2",
+      "engine": "OpenCode CLI invocation; session identity UNKNOWN",
+      "requestedModel": "nvidia/deepseek-ai/deepseek-v4.1-flash",
+      "productBaseline": "37c97046cb1e620c4a3585b4da5a2593501a48be",
+      "fixtureCommit": "39aa08987e0da2fc2ff3ea3556b84bd6d37f4e79",
+      "nvidiaPreflight": {
+        "catalogModel": "nvidia/deepseek-ai/deepseek-v4.1-flash",
+        "configuredAuthPresence": true,
+        "variant": "UNKNOWN",
+        "evidenceLayer": "non-session preflight only",
+        "providerRequestMadeDuringPreflight": false
+      },
+      "process": {
+        "exitCode": 1,
+        "signal": null,
+        "timedOut": false,
+        "spawnFailureReason": null,
+        "stdoutJsonlRecords": 1,
+        "filteredEventType": "error",
+        "sessionId": null,
+        "sessionExistence": "UNKNOWN",
+        "stderrBytes": 0,
+        "rawOutputRetained": false
+      },
+      "errorInterpretation": {
+        "errorDiscriminantRetained": false,
+        "captureLimit": "allowlist omitted the error discriminant",
+        "cause": "UNKNOWN",
+        "providerRequestStatus": "UNKNOWN"
+      },
+      "fixture": {
+        "gitCleanBeforeAndAfter": true,
+        "configSha256": "422eb8c6481aaadbf7910d4b415e76b2e60723bd0da4c532a94fad1879c38bcd",
+        "adrBeforeSha256": "65c903eedc1be2ca6022638fd9cab1f70c08c278e9e03be5c73ad0b2ecab4d18",
+        "adrAfterSha256": "65c903eedc1be2ca6022638fd9cab1f70c08c278e9e03be5c73ad0b2ecab4d18",
+        "taskPromptSha256": "524e58eeb6bd64e33986777b19a7fca8ec0829154fc2eb4b0c4a26b8e13b7b5e",
+        "adrChanged": false
+      },
+      "observations": {
+        "naturalCompletionObserved": false,
+        "observerTracePresent": false,
+        "observerLoad": "NOT_OBSERVED",
+        "sanitizedExportAttempted": false,
+        "reportCapture": "UNKNOWN: no session ID was available for lookup",
+        "globalHarnessAbsence": "UNCHECKED",
+        "isolation": "UNCHECKED"
+      },
+      "sourceArtifactSha256": {
+        "exitMetadata": "61f8904e70fa9266f52437d536a43d9f8c34b338fa1c0f55827cf1527b7f7582",
+        "filteredRunLog": "b2261fe453f0645fb8d7606979e0c4a8b7c08095a6fc1fa3dbb9a670fbf78806",
+        "observerImplementation": "33a3a3c8da4f5dc495f7462952b11ee8ad46c4fa9ba0882152acd0eebf0ed56f",
+        "taskLocalPluginEntrypoint": "ad4eef698164e644e52eeb0c6f36bef56ca75a5c66d7cd71345d0091108f8fbe"
+      }
+    }
+  ],
+  "localRunnerSelfCheck": {
+    "result": "PASS",
+    "checks": [
+      "child exit code 23",
+      "timeout and signal capture",
+      "spawn failure maps to null exit plus reason"
+    ],
+    "evidenceLayer": "deterministic mechanism only; not live-host evidence",
+    "runnerSource": "LOCAL_ONLY:.worktrees/packets/resume-2026-10-25/D2-nvidia-current/scripts/d2-runner.mjs"
+  },
+  "qualification": {
+    "e1Cycle": false,
+    "e1Go": false,
+    "behaviorBenefit": false,
+    "qualifies": false,
+    "nvidiaOutageClaim": false,
+    "prClaim": "retained negative observations only"
+  }
+}

package/ci/action-gate.test.js

@@ -353,6 +353,92 @@ try {
 
   check(fs.readFileSync(rulesPath, 'utf8') === fs.readFileSync(pluginRules, 'utf8'), 'canonical and plugin action-gate rule tables are byte-identical');
   check(fs.existsSync(pluginScript), 'OpenAI plugin packages action-gate runtime');
+
+  // Codex PR metadata scope: exact operation AND actual argument allowlist.
+  const metadataInput = { repository_full_name: 'acme/repo', pr_number: 376, body: 'metadata fixture' };
+  const metadataPayload = (input = metadataInput, tool = 'mcp__codex_apps__github__update_pull_request', extra = {}) => ({
+    ...payload('', { tool }), tool_input: input, ...extra,
+  });
+  for (const tool of ['update_pull_request', 'mcp__github__update_pull_request', 'mcp__codex_apps__github__update_pull_request', 'mcp__codex_apps__github_update_pull_request']) {
+    for (const fields of [{ body: '' }, { title: 'new title' }, { title: 'new title', body: 'new body' }]) {
+      const candidate = metadataPayload({ repository_full_name: 'acme/repo', pr_number: 376, ...fields }, tool);
+      const result = actionGate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+      check(result.kind === 'allow' && result.stdout === null && result.exitCode === 0, `${tool} ${Object.keys(fields)} defers without a permission decision`);
+      const descriptor = actionGate.normalizeActionDescriptor(candidate);
+      check(descriptor.action === 'mutate' && descriptor.classification === 'gated', 'metadata remains a non-safe mutation');
+    }
+  }
+  for (const selector of [{ owner: 'acme', repo: 'repo', pullNumber: 376 }, { owner: 'acme', repo: 'repo', pull_number: 376 }]) {
+    check(actionGate.evaluatePreToolUse(metadataPayload({ ...selector, body: 'provider-neutral' }), { host: 'codex', sessionDir, ruleTable: table }).kind === 'allow', 'provider-neutral selectors support metadata updates');
+  }
+  const ownUnknown = JSON.parse('{"repository_full_name":"acme/repo","pr_number":376,"body":"fixture","__proto__":{"state":"closed"}}');
+  check(actionGate.evaluatePreToolUse(metadataPayload(ownUnknown), { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'own __proto__ field cannot escape the argument allowlist');
+  const explicitDelete = metadataPayload(metadataInput, undefined, { action_descriptor: { action: 'delete' } });
+  check(actionGate.evaluatePreToolUse(explicitDelete, { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'explicit higher-risk action cannot inherit metadata deferral');
+  for (const extra of [
+    { state: 'closed' }, { state: 'open' }, { state: null }, { base_branch: 'other' },
+    { maintainer_can_modify: false }, { maintainer_can_modify: null }, { unknown: true },
+    { title: 'mixed', state: 'closed' }, { draft: true }, { base: 'other' },
+    { action_descriptor: { action: 'delete' } },
+  ]) {
+    const result = actionGate.evaluatePreToolUse(metadataPayload({ ...metadataInput, ...extra }), { host: 'codex', sessionDir, ruleTable: table });
+    check(result.kind === 'block' && result.exitCode === 2, `metadata with ${JSON.stringify(extra)} remains gated`);
+  }
+  for (const input of [null, [], 'body', {}, { repository_full_name: 'acme/repo', pr_number: 376 },
+    { ...metadataInput, body: null }, { ...metadataInput, title: 2 }, { ...metadataInput, body: {} }]) {
+    check(actionGate.evaluatePreToolUse(metadataPayload(input), { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'missing or malformed metadata remains gated');
+  }
+  for (const tool of ['mcp__demo__update_pull_requests', 'mcp__demo__foo_update_pull_request', 'mcp__demo__update_pull_request_and_delete', 'mcp__codex_apps__github_update_pull_request_extra', 'mcp__demo__merge_pull_request', 'mcp__demo__close_pull_request']) {
+    check(actionGate.evaluatePreToolUse(metadataPayload(metadataInput, tool), { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', `${tool} receives no metadata exception`);
+  }
+  for (const host of ['claude', 'opencode', 'unknown']) {
+    const result = actionGate.evaluatePreToolUse(metadataPayload(), { host, sessionDir, ruleTable: table });
+    check(result.rule && result.rule.id === 'structured-mutate', `${host} retains existing mutation rule`);
+  }
+  for (const hint of [{ actionGate: { required: true } }, { workflowPlan: { actionGate: { required: true } } }, { harness: { workflowPlan: { actionGate: { required: true } } } }, { routerContract: { workflowPlan: { actionGate: { required: true } } } }]) {
+    check(actionGate.evaluatePreToolUse(metadataPayload(metadataInput, undefined, hint), { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'explicit required metadata gate cannot be bypassed');
+  }
+  for (const action of ['read', 'unknown']) {
+    for (const descriptor of [{ action_descriptor: { action } }, { actionDescriptor: { action } }, { harness: { actionDescriptor: { action } } }]) {
+      const candidate = metadataPayload({ ...metadataInput, state: 'closed' }, undefined, {
+        ...descriptor, workflowPlan: { actionGate: { required: true } },
+      });
+      const result = actionGate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+      check(result.kind === 'block' && result.exitCode === 2, `known Codex PR mutation cannot be downgraded to ${action}`);
+      check(result.record && result.record.actionDescriptor.action === 'mutate', 'downgrade refusal remains an audited mutation');
+    }
+    const inputDescriptor = metadataPayload({ ...metadataInput, state: 'closed', action_descriptor: { action } }, undefined, { actionGate: { required: true } });
+    check(actionGate.evaluatePreToolUse(inputDescriptor, { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', `input ${action} descriptor cannot hide a required PR mutation gate`);
+  }
+  const misleadingProvider = metadataPayload({ ...metadataInput, state: 'closed' }, 'mcp__get_provider__update_pull_request');
+  check(actionGate.evaluatePreToolUse(misleadingProvider, { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'provider namespace read token cannot downgrade exact PR mutation');
+  for (const host of ['claude', 'opencode', 'unknown']) {
+    const describedRead = metadataPayload(metadataInput, undefined, { action_descriptor: { action: 'read' } });
+    check(actionGate.evaluatePreToolUse(describedRead, { host, sessionDir, ruleTable: table }).kind === 'allow', `${host} explicit descriptor behavior remains unchanged`);
+  }
+  for (const action of ['read', 'unknown', 'mutate', 'delete', 'publish', 'deploy', 'send']) {
+    const candidate = metadataPayload({ ...metadataInput, state: 'closed', action_descriptor: { toolFamily: 'shell', action } }, undefined, { actionGate: { required: true } });
+    const result = actionGate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+    check(result.kind === 'block' && result.exitCode === 2, `shell family cannot disguise exact Codex PR ${action}`);
+    check(result.record && result.record.actionDescriptor.toolFamily === 'mcp', 'known MCP identity is preserved in audit');
+  }
+  const gateEnvelopes = gate => [
+    { actionGate: gate }, { workflowPlan: { actionGate: gate } },
+    { routerContract: { workflowPlan: { actionGate: gate } } },
+    { harness: { workflowPlan: { actionGate: gate } } },
+  ];
+  for (let requiredAt = 0; requiredAt < 4; requiredAt++) {
+    const optionalHints = Object.assign({}, ...gateEnvelopes({ required: false }));
+    const hints = { ...optionalHints, ...gateEnvelopes({ required: true })[requiredAt] };
+    const candidate = metadataPayload(metadataInput, undefined, hints);
+    const result = actionGate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+    check(result.kind === 'block' && result.exitCode === 2, `required hint envelope ${requiredAt} wins over optional envelopes`);
+    check(result.record && result.record.routerActionGate.required === true, 'audit retains required hint instead of a conflicting optional hint');
+    const creation = { ...candidate, tool_name: 'mcp__github__create_pull_request' };
+    check(actionGate.evaluatePreToolUse(creation, { host: 'codex', sessionDir, ruleTable: table }).kind === 'block', 'PR creation still honors the documented explicit required gate');
+  }
+
+
 } catch (err) {
   console.error(err.stack || err.message);
   failed++;

package/ci/mechanism-2aa-codex-action-gate-policy.test.js

@@ -127,6 +127,53 @@ try {
   assert.strictEqual(attributedBlock.exitCode, 2);
   assert.ok(attributedBlock.attribution.file && fs.existsSync(attributedBlock.attribution.file), 'destructive hook entry must be attributable before the block result');
 
+  // Execute both canonical and packaged pre-entrypoints with real MCP argument shapes.
+  for (const gate of [actionGate, require(path.join(pluginRoot, 'hooks', 'scripts', 'action-gate.js'))]) {
+    for (const outcome of ['success', 'failure']) {
+      const candidate = {
+        ...payload('', { toolUseId: `metadata-${outcome}`, turnId: 'metadata-turn' }),
+        tool_name: 'mcp__codex_apps__github__update_pull_request',
+        tool_input: { repository_full_name: 'acme/repo', pr_number: 376, body: 'private fixture body' },
+      };
+      const pre = gate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+      assert.strictEqual(pre.kind, 'allow');
+      assert.strictEqual(pre.stdout, null);
+      assert.strictEqual(pre.record.disposition, 'deferred-to-host');
+      assert.strictEqual(pre.record.host, 'codex');
+      assert.strictEqual(pre.record.toolUseId, candidate.tool_use_id);
+      assert.strictEqual(pre.record.matchedRule, 'routine-pr-metadata-update');
+      const hash = gate.hashExact(gate.exactPayloadText(candidate));
+      assert.strictEqual(pre.record.commandHash, hash);
+      assert.strictEqual(pre.record.actionDescriptor.payloadHash, hash);
+      assert.ok(!JSON.stringify(pre.record).includes('private fixture body'));
+      const post = gate.finalizeExecution(candidate, outcome, { sessionDir });
+      assert.strictEqual(post.record.disposition, 'executed');
+      assert.strictEqual(post.record.executionOutcome, outcome);
+      assert.strictEqual(post.record.commandHash, hash);
+
+      gate.evaluatePreToolUse(candidate, { host: 'codex', sessionDir, ruleTable: table });
+      const altered = { ...candidate, tool_input: { ...candidate.tool_input, state: 'closed' } };
+      assert.strictEqual(gate.finalizeExecution(altered, 'success', { sessionDir }).record.disposition, 'integrity-violation');
+      const denied = gate.evaluatePreToolUse(altered, { host: 'codex', sessionDir, ruleTable: table });
+      assert.strictEqual(denied.kind, 'block');
+      assert.strictEqual(denied.exitCode, 2);
+      assert.strictEqual(denied.stdout, null);
+      assert.strictEqual(denied.record.disposition, 'rejected');
+      assert.strictEqual(denied.record.rejectionReason, 'host-ask-decision-unverified-or-unsupported');
+      assert.notStrictEqual(denied.record.commandHash, hash);
+    }
+  }
+  const metadataEntry = preAdapter.processPayload({
+    ...payload('', { toolUseId: 'metadata-entry' }),
+    tool_name: 'mcp__codex_apps__github_update_pull_request',
+    tool_input: { repository_full_name: 'acme/repo', pr_number: 376, title: 'fixture' },
+  }, { host: 'codex', sessionDir, ruleTable: table, attributionDir, runNonce: 'metadata-fixture' });
+  assert.strictEqual(metadataEntry.kind, 'allow');
+  assert.strictEqual(metadataEntry.attribution.record.payloadHash, metadataEntry.record.commandHash);
+  assert.strictEqual(metadataEntry.attribution.record.toolUseId, metadataEntry.record.toolUseId);
+  assert.strictEqual(fs.readFileSync(path.join(ROOT, 'hooks/scripts/action-gate.js'), 'utf8'),
+    fs.readFileSync(path.join(pluginRoot, 'hooks/scripts/action-gate.js'), 'utf8'));
+
   const blockedParent = path.join(tempRoot, 'not-a-directory');
   fs.writeFileSync(blockedParent, 'fixture', 'utf8');
   const failedAttribution = preAdapter.processPayload(payload('git push --force origin main', {

package/ci/mechanism-325-3b-h1-qualification.test.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+'use strict';
+
+// #325 H1 deterministic qualification: provider independence/preparation.
+// H1 only: advisory suggestions are never passed to the F4 consumer.
+
+const fs = require('fs');
+const path = require('path');
+
+const fx = require(path.join(__dirname, 'lib', 'doc-reconciliation-prep-fixtures'));
+const { stage } = require(path.join(__dirname, 'lib', 'doc-reconciliation-staged-tree'));
+const F4_CASES = path.join(__dirname, 'fixtures', 'doc-obligations', 'reconciliation-s2b', 'f4', 'cases.json');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SOURCE_OBLIGATIONS = require(path.join(REPO_ROOT, 'harness-everything', 'scripts', 'doc-obligations.js'));
+const PACKAGED_OBLIGATIONS = require(path.join(REPO_ROOT, 'plugins', 'harness-everything', 'skills', 'harness-everything', 'scripts', 'doc-obligations.js'));
+const SOURCE_PROVIDER = require(path.join(REPO_ROOT, 'harness-everything', 'scripts', 'doc-providers.js'));
+const PACKAGED_PROVIDER = require(path.join(REPO_ROOT, 'plugins', 'harness-everything', 'skills', 'harness-everything', 'scripts', 'doc-providers.js'));
+
+const LEGS = ['source', 'packaged'];
+const CASE = id => fx.readCaseCorpus(F4_CASES).cases.find(item => item.id === id);
+
+const EXPECTED_MUSTS = [
+  { id: 'doc-change:doc-lint', capability: 'doc-lint', strength: 'MUST', applicability: 'applicable', scope: { paths: ['docs/a.md'] }, acceptance: 'Run document lifecycle lint for every changed governed document.' },
+  { id: 'doc-change:link-check', capability: 'link-check', strength: 'MUST', applicability: 'applicable', scope: { paths: ['docs/a.md'] }, acceptance: 'Check in-repository links for every changed governed document.' }
+];
+
+const PROVIDER_A_INPUT = {
+  activeStep: { id: 'verify-docs', stepType: 'verification' },
+  neededCapabilities: ['doc-lint'],
+  availableProviderMetadata: [
+    { providerId: 'fixture-lint-a', capabilities: ['doc-lint'], stepTypes: ['verification'], requiresHostCapabilities: ['execution-events'], locator: { kind: 'tool', id: 'fixture-lint-a' } }
+  ],
+  hostCapabilities: ['execution-events']
+};
+
+const PROVIDER_B_INPUT = {
+  activeStep: { id: 'verify-docs', stepType: 'verification' },
+  neededCapabilities: ['doc-lint'],
+  availableProviderMetadata: [
+    { providerId: 'fixture-lint-b', capabilities: ['doc-lint'], stepTypes: ['verification'], requiresHostCapabilities: ['execution-events'], locator: { kind: 'tool', id: 'fixture-lint-b' } }
+  ],
+  hostCapabilities: ['execution-events']
+};
+
+const PROVIDER_OMITTED_INPUT = {
+  activeStep: { id: 'verify-docs', stepType: 'verification' },
+  neededCapabilities: ['doc-lint'],
+  availableProviderMetadata: [],
+  hostCapabilities: []
+};
+
+const PROVIDER_A_SUGGESTION = [{ capability: 'doc-lint', providerId: 'fixture-lint-a', availability: 'available', reason: 'active-step capability and host requirements match' }];
+const PROVIDER_B_SUGGESTION = [{ capability: 'doc-lint', providerId: 'fixture-lint-b', availability: 'available', reason: 'active-step capability and host requirements match' }];
+const PROVIDER_OMITTED_UNAVAILABLE = [{ capability: 'doc-lint', reason: 'no available provider metadata for the active-step capability' }];
+
+let passCount = 0;
+let failCount = 0;
+let infraCount = 0;
+
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function record(status, id, detail) {
+  const suffix = detail ? ` - ${detail}` : '';
+  if (status === 'PASS') passCount += 1;
+  else if (status === 'FAIL') failCount += 1;
+  else infraCount += 1;
+  console.log(`   ${status.padEnd(5)} ${id}${suffix}`);
+}
+
+function cloneZero(caseDef) {
+  return {
+    ...caseDef,
+    id: `${caseDef.id}-zero-evidence`,
+    actions: caseDef.actions.filter(action => action.id !== 'lint-run' && action.id !== 'post-lint')
+  };
+}
+
+function checkProvider(leg, providerCase) {
+  const module = leg === 'source' ? SOURCE_PROVIDER : PACKAGED_PROVIDER;
+  let input;
+  let expectedSuggestions;
+  let expectedUnavailable;
+  if (providerCase === 'A') {
+    input = PROVIDER_A_INPUT;
+    expectedSuggestions = PROVIDER_A_SUGGESTION;
+    expectedUnavailable = [];
+  } else if (providerCase === 'B') {
+    input = PROVIDER_B_INPUT;
+    expectedSuggestions = PROVIDER_B_SUGGESTION;
+    expectedUnavailable = [];
+  } else {
+    input = PROVIDER_OMITTED_INPUT;
+    expectedSuggestions = [];
+    expectedUnavailable = PROVIDER_OMITTED_UNAVAILABLE;
+  }
+  const result = module.suggestDocProviders(input);
+  const ok = deepEqual(result.suggestions, expectedSuggestions) && deepEqual(result.unavailable, expectedUnavailable);
+  record(ok ? 'PASS' : 'FAIL', `H1.${leg}.${providerCase}.provider-suggestion`, ok ? '' : `suggestions=${JSON.stringify(result.suggestions)}, unavailable=${JSON.stringify(result.unavailable)}`);
+  return ok;
+}
+
+function checkDerivedMusts(leg, label) {
+  const module = leg === 'source' ? SOURCE_OBLIGATIONS : PACKAGED_OBLIGATIONS;
+  const caseDef = CASE('F4-POS-body-edit');
+  const config = JSON.parse(caseDef.input.baseFiles['.agents/harness-everything/project-docs.json']);
+  const base = { files: caseDef.input.baseFiles };
+  const candidate = { files: { ...caseDef.input.baseFiles, ...caseDef.input.candidateFiles } };
+  const { facts } = module.deriveDocFacts({ base, candidate, config, inventory: { complete: true } });
+  const obligations = module.deriveDocObligations(facts);
+  const fullMusts = obligations.filter(item => item.strength === 'MUST' && item.applicability === 'applicable');
+
+  let ok = deepEqual(fullMusts, EXPECTED_MUSTS);
+  for (const item of fullMusts) {
+    if (!item.id || !item.capability || !item.strength || !item.applicability || !item.scope || !Array.isArray(item.scope.paths) || item.scope.paths.some(pathValue => !pathValue) || !item.acceptance) ok = false;
+  }
+  record(ok ? 'PASS' : 'FAIL', `${label}.derived-full-musts`, ok ? '' : JSON.stringify(fullMusts));
+  return ok;
+}
+
+function runCell(leg, providerCase, evidenceMode) {
+  const label = `H1.${leg}.${providerCase}.${evidenceMode}`;
+  const staged = stage(leg);
+  try {
+    checkProvider(leg, providerCase);
+    checkDerivedMusts(leg, label);
+
+    staged.writeExport(staged.validExport());
+
+    const baseCase = CASE('F4-POS-body-edit');
+    const caseDef = evidenceMode === 'valid' ? baseCase : cloneZero(baseCase);
+
+    const root = fx.replayCase(caseDef, staged.dist, { pilot: '1' });
+    const faults = fx.infrastructureFaults(caseDef, root, 'on');
+    if (faults.length) {
+      record('INFRA', label, faults.map(fault => `${fault.actionId}: ${fault.message}`).join('; '));
+      return;
+    }
+
+    const pilot = root.pilot || {};
+    const checks = [];
+
+    checks.push(deepEqual(root.pilotReportOrigin, 'runtime'));
+    checks.push(deepEqual(pilot.reportOrigin, 'runtime'));
+    checks.push(deepEqual(pilot.expectedMustIds, ['doc-change:doc-lint', 'doc-change:link-check']));
+    const verifyAction = root.actions && root.actions['verify-pass'];
+    const verifyRequirement = verifyAction?.state?.obligations?.requirements?.find(item => item.id === 'req-verify');
+    checks.push(verifyRequirement?.requiredBindings?.some(binding => binding.id === 'verification-loop' && binding.status === 'loaded') === true);
+
+    if (evidenceMode === 'valid') {
+      checks.push(pilot.pilotCredit === true);
+      checks.push(pilot.pilotStatus === 'credited');
+      checks.push(deepEqual(pilot.unsatisfied, []));
+      checks.push(deepEqual(pilot.creditedCapabilities, ['doc-lint', 'link-check']));
+      checks.push(Array.isArray(pilot.acceptedRefs) && pilot.acceptedRefs.some(ref => ref.endsWith('#doc-lint')) && pilot.acceptedRefs.some(ref => ref.endsWith('#link-check')));
+      checks.push(verifyAction && verifyAction.exitCode === 0);
+      const stopAction = root.actions && root.actions.stop;
+      checks.push(stopAction && stopAction.exitCode === 0);
+      checks.push(stopAction && stopAction.state && stopAction.state.workflow && stopAction.state.workflow.state === 'satisfied');
+    } else {
+      checks.push(pilot.pilotCredit === false);
+      checks.push(pilot.pilotStatus === 'unresolved');
+      checks.push(Array.isArray(pilot.unsatisfied) && pilot.unsatisfied.length >= 2);
+      checks.push(pilot.unsatisfied.some(item => item.obligationId === 'doc-change:doc-lint'));
+      checks.push(pilot.unsatisfied.some(item => item.obligationId === 'doc-change:link-check'));
+      checks.push(deepEqual(pilot.creditedCapabilities, []));
+      checks.push(deepEqual(pilot.acceptedRefs, []));
+      checks.push(verifyAction && verifyAction.exitCode === 2);
+      const stopAction = root.actions && root.actions.stop;
+      checks.push(stopAction && stopAction.exitCode === 0);
+      checks.push(stopAction && stopAction.state && stopAction.state.workflow && stopAction.state.workflow.state === 'running');
+    }
+
+    record(checks.every(Boolean) ? 'PASS' : 'FAIL', label, checks.every(Boolean) ? '' : `checks=${JSON.stringify(checks)}, pilot=${JSON.stringify(pilot).slice(0, 500)}`);
+  } catch (error) {
+    record('FAIL', label, error.message);
+  } finally {
+    staged.cleanup();
+  }
+}
+
+function main() {
+  console.log('\n== H1 qualification: provider side input and F4 replay matrix ==');
+  for (const leg of LEGS) {
+    for (const providerCase of ['A', 'B', 'omitted']) {
+      for (const evidenceMode of ['valid', 'zero']) {
+        runCell(leg, providerCase, evidenceMode);
+      }
+    }
+  }
+
+  console.log('\n== H1 qualification evidence ==');
+  console.log(`passing checks: ${passCount}`);
+  console.log(`unexpected failures: ${failCount}`);
+  console.log(`infrastructure faults: ${infraCount}`);
+  if (failCount === 0 && infraCount === 0) {
+    console.log('\nSTATUS: GREEN (all assertions passed)');
+    return 0;
+  }
+  console.log('\nSTATUS: NOT-GREEN');
+  return 1;
+}
+
+process.exitCode = main();