@openwop/openwop-conformance 1.106.1 → 1.124.0

package/dist/lib/scenario-disposition.js

@@ -0,0 +1,249 @@
+/**
+ * RFC 0148 §A / acceptance item 2 (S6) — file-level requirement recording and
+ * the runner's derivation.
+ *
+ * Two halves that meet through the ledger file sink:
+ *
+ * 1. **In the vitest worker** (`setup.ts` hooks): every scenario FILE records
+ *    exactly one disposition for its own requirement id when it finishes —
+ *    `executed-fail` if any test failed, `executed-pass` if any test passed and
+ *    none failed, and for a file whose tests ALL skipped: `inapplicable` /
+ *    `skipped` if a `behaviorGate` inside the file recorded one of those for the
+ *    profile it gates on (the honest reason the tests did not run), else
+ *    `blocked` — an all-skipped file with no recorded reason is an unclassified
+ *    return, and §A resolves it to `blocked`, never to a pass.
+ *
+ * 2. **In the `--certify` runner** (`deriveRequirementDispositions`): every
+ *    scenario file's requirement is taken FROM THE LEDGER when present, falling
+ *    back to the vitest per-file report only for pass/fail (which the ledger
+ *    would agree with) and to `blocked` (unclassified) otherwise; the floor's
+ *    prefix requirements (`openwop.floor.any.<prefix>`) are derived from the
+ *    files that match; and a claimed profile whose floor contains ANY requirement
+ *    with no ledger entry is flagged `unclassified` so the runner can REJECT the
+ *    certification rather than round the silence up.
+ *
+ * Pure functions, no I/O, so `runner-ledger.test.ts` can pin them without a
+ * host or a vitest subprocess.
+ */
+import { PROFILE_FLOOR_SCENARIOS } from './profiles.js';
+import { requirementIdForScenario, requirementIdForPrefix, requirementsFor } from './requirement-registry.js';
+import { UNCLASSIFIED_RETURN_DETAIL } from './soft-skip.js';
+import { CERTIFIABLE } from './requirement-ledger.js';
+/** All scenario basenames that appear in some profile's runtime floor. */
+export function floorScenarioFiles() {
+    const out = new Set();
+    for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS)) {
+        for (const f of floor.required)
+            out.add(f);
+        for (const c of floor.conditional ?? [])
+            for (const f of c.required)
+                out.add(f);
+    }
+    return out;
+}
+/** The requirement id a scenario FILE records under: the §A floor id when the
+ *  file is part of a floor, else the runner's per-scenario id. */
+export function requirementIdForFile(basename) {
+    return floorScenarioFiles().has(basename)
+        ? requirementIdForScenario(basename)
+        : `openwop.scenario.${basename.replace(/\.test\.ts$/, '')}`;
+}
+/** Worker half: fold a file's per-test states (+ any gate-recorded reason) into
+ *  the ONE disposition the file records. */
+export function fileDisposition(states, gateReason, assertionCount) {
+    if (states.some((s) => s === 'fail'))
+        return { disposition: 'executed-fail', detail: 'one or more assertions in the file failed' };
+    if (states.some((s) => s === 'pass')) {
+        // A test that early-returned through `behaviorGate` is reported by vitest
+        // as a pass with zero assertions. When EVERY passing test in the file did
+        // that (assertionCount 0) and the gate recorded why, the file's honest
+        // disposition is the gate's — `inapplicable` / `skipped` with its reason —
+        // not a vacuous executed-pass. Without a gate reason a zero-assertion pass
+        // stays `executed-pass` with `assertionCount: 0`, which certification
+        // rejects as unclassified (RFC 0148 §A).
+        if (assertionCount === 0 && gateReason === 'inapplicable') {
+            return { disposition: 'inapplicable', detail: 'every test returned early through behaviorGate with zero assertions: profile not advertised in the captured discovery set' };
+        }
+        if (assertionCount === 0 && gateReason === 'skipped') {
+            return { disposition: 'skipped', detail: 'every test returned early through behaviorGate with zero assertions: operator opted the profile out (OPENWOP_OPTED_OUT_PROFILES)' };
+        }
+        return { disposition: 'executed-pass' };
+    }
+    if (gateReason === 'inapplicable')
+        return { disposition: 'inapplicable', detail: 'every test skipped: profile not advertised in the captured discovery set (behaviorGate)' };
+    if (gateReason === 'skipped')
+        return { disposition: 'skipped', detail: 'every test skipped: operator opted the profile out (OPENWOP_OPTED_OUT_PROFILES)' };
+    return {
+        disposition: 'blocked',
+        detail: states.length === 0
+            ? 'no test executed and no disposition recorded — unclassified return (RFC 0148 §A resolves it to blocked)'
+            : 'every test skipped with no recorded reason — unclassified return (RFC 0148 §A resolves it to blocked)',
+    };
+}
+/**
+ * The runner's file-level record (RFC 0148 §A), as `setup.ts` computes it in
+ * `afterAll`. Pure so `conformance-execution-witness.test.ts` can pin the rule
+ * the hooks apply:
+ *   - a failed test ⇒ executed-fail; a witnessed pass ⇒ executed-pass;
+ *   - a zero-assertion "pass" ⇒ the file's noted reason (`softSkip` /
+ *     `seamAbsent`: inapplicable | skipped | blocked) or a behaviorGate reason;
+ *   - a zero-assertion "pass" with NO reason ⇒ `blocked` + the marker detail —
+ *     an early return can never become a pass.
+ */
+export function resolveFileRecord(states, gateReason, assertionCount, noted) {
+    let { disposition, detail } = fileDisposition(states, gateReason, assertionCount);
+    if (disposition === 'executed-pass' && assertionCount === 0) {
+        if (noted !== null) {
+            disposition = noted.kind;
+            detail = noted.reason;
+        }
+        else {
+            disposition = 'blocked';
+            detail = UNCLASSIFIED_RETURN_DETAIL;
+        }
+    }
+    return detail === undefined ? { disposition } : { disposition, detail };
+}
+/**
+ * Runner half. `reportStates` is what vitest's JSON report said per file
+ * (`passed`/`failed`/`skipped`); `ledger` is what the workers recorded.
+ */
+export function deriveRequirementDispositions(reportStates, ledger, claimedProfiles, 
+/** The captured discovery document — needed to evaluate a discovery-conditional floor (G7). */
+document) {
+    const byId = new Map(ledger.map((e) => [e.requirementId, e]));
+    const ledgerPresent = ledger.length > 0;
+    const rows = [];
+    const perFile = new Map();
+    for (const [file, state] of [...reportStates.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const id = requirementIdForFile(file);
+        const rec = byId.get(id);
+        let row;
+        if (rec !== undefined) {
+            row = {
+                requirementId: id,
+                scenarioId: file,
+                disposition: rec.disposition,
+                ...(rec.detail === undefined ? {} : { detail: rec.detail }),
+                ...(rec.assertionCount === undefined ? {} : { assertionCount: rec.assertionCount }),
+            };
+        }
+        else if (state === 'passed') {
+            row = ledgerPresent
+                ? { requirementId: id, scenarioId: file, disposition: 'executed-pass', detail: 'report-derived: vitest passed the file but no disposition was recorded (assertion count unknown) — unclassified for a claimed floor' }
+                : { requirementId: id, scenarioId: file, disposition: 'executed-pass' };
+        }
+        else if (state === 'failed') {
+            row = { requirementId: id, scenarioId: file, disposition: 'executed-fail', detail: 'the scenario executed and failed (report-derived; no ledger entry)' };
+        }
+        else {
+            row = {
+                requirementId: id,
+                scenarioId: file,
+                disposition: 'blocked',
+                detail: ledgerPresent
+                    ? 'unclassified return: the file recorded no disposition — RFC 0148 §A resolves it to blocked, never to a pass'
+                    : 'runner cannot classify a skipped file without a ledger; RFC 0148 §A resolves an unclassifiable requirement to blocked',
+            };
+        }
+        rows.push(row);
+        perFile.set(file, row);
+    }
+    // Prefix requirements: derived from the matching files.
+    const prefixIds = new Set();
+    for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS))
+        for (const p of floor.requiredAnyPrefix ?? [])
+            prefixIds.add(p);
+    for (const prefix of [...prefixIds].sort()) {
+        const matching = [...perFile.entries()].filter(([f]) => f.startsWith(prefix)).map(([, r]) => r);
+        const id = requirementIdForPrefix(prefix);
+        let row;
+        if (matching.some((r) => r.disposition === 'executed-pass')) {
+            // Witnessed by the matching passes: the summary row carries their
+            // combined assertion count so a consumer reading only this row still
+            // sees a witnessed pass (RFC 0148 §C `assertionCount`).
+            const witnessed = matching.filter((r) => r.disposition === 'executed-pass').reduce((n, r) => n + (r.assertionCount ?? 0), 0);
+            row = { requirementId: id, scenarioId: `${prefix}*`, disposition: 'executed-pass', assertionCount: witnessed };
+        }
+        else if (matching.some((r) => r.disposition === 'executed-fail')) {
+            row = { requirementId: id, scenarioId: `${prefix}*`, disposition: 'executed-fail', detail: `no ${prefix}* scenario passed and at least one failed` };
+        }
+        else if (matching.length === 0) {
+            row = { requirementId: id, scenarioId: `${prefix}*`, disposition: 'blocked', detail: `no ${prefix}* scenario ran — unclassified return` };
+        }
+        else {
+            // all matching files are skipped/inapplicable/blocked: the prefix requirement is met by ANY pass, so none ⇒ blocked
+            row = { requirementId: id, scenarioId: `${prefix}*`, disposition: 'blocked', detail: `no ${prefix}* scenario executed a passing assertion (${matching.map((r) => r.disposition).join(', ')})` };
+        }
+        rows.push(row);
+    }
+    const totals = { executedPass: 0, executedFail: 0, skipped: 0, inapplicable: 0, blocked: 0 };
+    for (const r of rows) {
+        if (r.disposition === 'executed-pass')
+            totals.executedPass++;
+        else if (r.disposition === 'executed-fail')
+            totals.executedFail++;
+        else if (r.disposition === 'skipped')
+            totals.skipped++;
+        else if (r.disposition === 'inapplicable')
+            totals.inapplicable++;
+        else
+            totals.blocked++;
+    }
+    const rowById = new Map(rows.map((r) => [r.requirementId, r]));
+    const verdicts = [];
+    for (const profile of claimedProfiles) {
+        const ids = requirementsFor(profile, document);
+        if (ids === null) {
+            const floor = PROFILE_FLOOR_SCENARIOS[profile];
+            const why = floor === undefined ? `(no floor defined for ${profile})` : `(discovery-conditional floor for ${profile} is unevaluable without the discovery document)`;
+            verdicts.push({ profile, unclassified: [], blocking: [why], certifiable: false, runtimeDerived: false, held: false });
+            continue;
+        }
+        const unclassified = [];
+        const blocking = [];
+        let witnessedPasses = 0;
+        for (const id of ids) {
+            const r = rowById.get(id);
+            const fromLedger = byId.has(id) || (r !== undefined && r.scenarioId.endsWith('*'));
+            if (r !== undefined && r.disposition === 'executed-pass' && (r.assertionCount ?? 0) > 0)
+                witnessedPasses += 1;
+            // Unclassified: no row, or a report-derived blocked (nothing recorded), or a
+            // VACUOUS pass — executed-pass with assertionCount 0 is a witness of nothing
+            // (RFC 0148 §A: "a required behavior MUST NOT be certified without a target
+            // execution witness"), so for a claimed floor it counts as unclassified.
+            const vacuous = r !== undefined &&
+                ((r.disposition === 'executed-pass' && r.assertionCount === 0) ||
+                    // the runner's own §A resolution of a zero-assertion file that noted no
+                    // reason: honest as a row, still an unclassified return for a floor
+                    (r.disposition === 'blocked' && r.detail === UNCLASSIFIED_RETURN_DETAIL));
+            // With a ledger present, ANY floor row that did not come from the ledger is
+            // unclassified: silence is evidence of nothing (RFC 0148 §A). Without a
+            // ledger only report-blocked rows are unclassified (the pre-S6 reading).
+            const silent = !fromLedger && (ledgerPresent || r?.disposition === 'blocked');
+            if (r === undefined || silent || vacuous)
+                unclassified.push(id);
+            // Unclassified always blocks: a requirement nobody recorded cannot certify.
+            if (r === undefined || silent || vacuous || !CERTIFIABLE.includes(r.disposition))
+                blocking.push(id);
+        }
+        // discoveryOnly floors have ids.length === 0 and certify by design here (the
+        // requirement-ledger's verifyProfileRequirements is stricter; the runner
+        // consults PROFILE_FLOOR_SCENARIOS.discoveryOnly separately).
+        const discoveryOnly = PROFILE_FLOOR_SCENARIOS[profile]?.discoveryOnly === true;
+        const runtimeDerived = PROFILE_FLOOR_SCENARIOS[profile]?.runtimeDerived === true;
+        // A runtime-derived profile is HELD only when every floor row is a witnessed
+        // pass ("derivable from which scenarios pass" — profiles.md). Anything else
+        // means the host does not hold it: not a rejection, not a blocked claim.
+        const held = ids.length > 0 && witnessedPasses === ids.length;
+        verdicts.push({
+            profile,
+            unclassified: runtimeDerived && !held ? [] : unclassified,
+            blocking: runtimeDerived && !held ? ids.filter((id) => rowById.get(id)?.disposition !== 'executed-pass' || (rowById.get(id)?.assertionCount ?? 0) === 0) : blocking,
+            certifiable: runtimeDerived ? held : discoveryOnly || (ids.length > 0 && blocking.length === 0),
+            runtimeDerived,
+            held,
+        });
+    }
+    return { requirements: rows, totals, verdicts, rejectUnclassified: verdicts.some((v) => v.unclassified.length > 0), ledgerPresent };
+}

package/dist/lib/soft-skip.js

@@ -0,0 +1,82 @@
+/**
+ * RFC 0148 §A — say WHY a scenario returned early.
+ *
+ * A test that returns before its first `expect` reports to vitest as a pass
+ * with zero assertions. Under the ledger that is an UNCLASSIFIED return: the
+ * runner cannot tell "capability not advertised" from "seam not mounted" from
+ * "operator opted out". `behaviorGate` records the first two cases for
+ * profile-gated files; every other early return in the corpus was silent.
+ *
+ * `softSkip(kind, reason)` notes the reason for the CURRENT test file (from
+ * vitest's `expect.getState().testPath`) and returns `undefined`, so an
+ * early return becomes one expression:
+ *
+ *   if (!(await advertised())) return softSkip('inapplicable', 'host does not advertise X');
+ *   if (res.status === 404) return softSkip('blocked', 'seam /v1/host/sample/... not mounted');
+ *
+ * `setup.ts` reads the notes when it records the file: a file whose passes are
+ * all zero-assertion takes the noted disposition (`inapplicable` / `skipped` /
+ * `blocked`, worst-first if mixed) with the joined reasons; a file with real
+ * assertions is `executed-pass` regardless of notes. A zero-assertion file with
+ * NO note at all is recorded `blocked` — "unclassified return; RFC 0148 §A
+ * resolves it to blocked" — and stays UNCLASSIFIED for certification (a floor
+ * row with that disposition still rejects), so the honest bundle row and the
+ * pressure to say why both survive.
+ */
+import { expect } from 'vitest';
+import { basename } from 'node:path';
+/** Detail marker the runner writes for a zero-assertion file that noted nothing. */
+export const UNCLASSIFIED_RETURN_DETAIL = 'every test returned early with zero assertions and no recorded reason — unclassified return; RFC 0148 §A resolves it to blocked (add softSkip(kind, reason) at the early return)';
+const notes = new Map();
+function currentFile() {
+    try {
+        const p = expect.getState().testPath;
+        return typeof p === 'string' && p.length > 0 ? basename(p) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Note an early return for the current file. Returns undefined so `return softSkip(...)` reads naturally. */
+export function softSkip(kind, reason) {
+    const file = currentFile();
+    if (file === null)
+        return undefined;
+    const arr = notes.get(file) ?? [];
+    if (!arr.some((n) => n.kind === kind && n.reason === reason))
+        arr.push({ kind, reason });
+    notes.set(file, arr);
+    return undefined;
+}
+/**
+ * An advertised capability whose observation seam is absent or refused
+ * (404 / 403 / `null` from a seam helper): the host made a claim the suite
+ * cannot check. Default mode notes `blocked` with the reason (RFC 0148 §A);
+ * under `OPENWOP_REQUIRE_BEHAVIOR=true` it FAILS (RFC 0148 §B / RFC 0139 G14
+ * flip) — advertised behaviour MUST be present. Use as `return seamAbsent(...)`.
+ */
+export function seamAbsent(reason) {
+    if (process.env['OPENWOP_REQUIRE_BEHAVIOR'] === 'true') {
+        throw new Error(`RFC 0148 §B: advertised behaviour is not observable — ${reason} (OPENWOP_REQUIRE_BEHAVIOR=true fails an advertised-missing seam)`);
+    }
+    return softSkip('blocked', reason);
+}
+const RANK = { blocked: 0, skipped: 1, inapplicable: 2 };
+/**
+ * The noted disposition for a file, worst-first when mixed (`blocked` beats
+ * `skipped` beats `inapplicable` — a file that could not check one thing is
+ * not certifiable on the strength of another thing being inapplicable), with
+ * the reasons joined. `null` when nothing was noted.
+ */
+export function softSkipDisposition(file) {
+    const arr = notes.get(file);
+    if (arr === undefined || arr.length === 0)
+        return null;
+    const kind = [...arr].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0].kind;
+    const reason = arr.map((n) => (arr.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
+    return { kind, reason };
+}
+/** Test hook. */
+export function resetSoftSkips() {
+    notes.clear();
+}

package/fixtures/conformance-a2a-task-roundtrip.json

@@ -6,7 +6,7 @@
   "nodes": [
     {
       "id": "a2a-invoke",
-      "typeId": "core.a2a.invoke",
+      "typeId": "core.conformance.a2a-invoke",
       "name": "Invoke A2A peer",
       "position": { "x": 0, "y": 0 },
       "config": {

package/fixtures.md

@@ -103,7 +103,7 @@ All fixtures MUST advertise:
 | Orchestrator Terminate                    | `conformance-orchestrator-terminate`                                                            | Phase 5 / CO-3 — terminate decision is final                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `completed`                                                                         | ≤ 30s                        |
 | Orchestrator Low-Confidence               | `conformance-orchestrator-low-confidence`                                                       | Phase 5 / CP-1 — supervisor low-confidence suspend                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `waiting-approval` (suspends)                                                       | unbounded (suspends)         |
 | MCP Tool Roundtrip                        | `conformance-mcp-tool-roundtrip`                                                                | Track 6 — host invokes a tool on the conformance suite's synthetic MCP server; trust-boundary visibility in the event log                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `completed`                                                                         | ≤ 30s                        |
-| A2A Task Roundtrip                        | `conformance-a2a-task-roundtrip`                                                                | Track 6 — host consumes the conformance suite's synthetic A2A peer; covers drift points #3 (`AUTH_REQUIRED`) and #4 (`REJECTED`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `failed` or `waiting-input` (per `driftScenario` input)                             | ≤ 30s                        |
+| A2A Task Roundtrip                        | `conformance-a2a-task-roundtrip`                                                                | Track 6 — host consumes the conformance suite's synthetic A2A peer; covers drift points #3 (`AUTH_REQUIRED`) and #4 (`REJECTED`). Node `core.conformance.a2a-invoke` is a **conformance-RESERVED** typeId (renamed 2026-08-16 from `core.a2a.invoke`, a multi-segment `core.*` id no host shipped and the corpus never defined): a host that consumes A2A peers MUST map it to its A2A bridge node (a host-extension node — `a2a-integration.md` §"State projection"); a host that does not consume A2A MUST NOT advertise this fixture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `failed` or `waiting-input` (per `driftScenario` input)                             | ≤ 30s                        |
 | WASM Pack Roundtrip                       | `conformance-wasm-pack-roundtrip`                                                               | RFC 0008 — invokes `vendor.openwop.rust-hello.greet` (loaded WASM pack); exercises required exports + at least one import                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `completed`                                                                         | ≤ 10s                        |
 | WASM Pack Memory-Cap Breach               | `conformance-wasm-pack-memory-cap-breach`                                                       | RFC 0008 §K — invokes the deliberately-misbehaving `vendor.openwop.misbehaving.memory-bomb` pack (allocates 1 GiB beyond the host's `memoryPagesMax`). Host MUST emit `cap.breached` with `kind: "wasm-memory"` and drive the run to terminal `failed`. Misbehaving pack lives at `openwop-examples:examples/packs/rust-misbehaving-memory/` (repo-qualified per the 2026-06 monorepo split — the `openwop-examples` sibling repo) and is fixture-only (NOT signed for registry publication).                                                                                                                                                             | `failed` (with `cap.breached`)                                                      | ≤ 10s                        |
 | Configurable Schema                       | `conformance-configurable-schema`                                                               | Track 13 — workflow declares `configurableSchema` (`additionalProperties: false`, `recursionLimit: integer ≥ 1`). Suite verifies `GET /v1/workflows/{id}` surfaces the schema AND `POST /v1/runs` with a mismatched `configurable` returns `validation_error`.                                                                                                                                                                                                                                                                                                                                                                                            | `completed` (with accepted overlay)                                                 | ≤ 5s                         |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "1.106.1",
+  "version": "1.124.0",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",

package/schemas/CORPUS-STAMP.json

@@ -1,5 +1,5 @@
 {
   "_comment": "Provenance of this vendored schemas/ copy. See conformance/README.md \u00a7\"Resolving the contract\". Compare against the stamp in your installed @openwop/openwop-conformance to detect a stale hand-copied contract.",
-  "suiteVersion": "1.106.1",
-  "corpusCommit": "eb487d75adb0178afdcb897e8602f6111a4099a9"
+  "suiteVersion": "1.124.0",
+  "corpusCommit": "7dffa37f3864f170141130aa0360765ba89b2e7e"
 }

package/schemas/README.md

@@ -89,6 +89,7 @@
 | `workflow-definition.schema.json` | `channels-and-reducers.md` + `node-packs.md` | DAG of nodes + edges + triggers + variables + channels |
 | `certification-bundle-v2.schema.json` | `profiles.md` + RFC 0148 §C | Certification bundle v2 — per-requirement dispositions instead of pass/fail/skip file lists. `blocked` is a REQUIRED total because `blocked: 0` asserted differs from `blocked` unstated, and `assertionCount` makes an `executed-pass` that ran nothing visible in the artifact |
 | `workload-identity.schema.json` | `auth.md` + RFC 0154 §A/§B | Verified workload identity + delegated actor chain. Closed by design: raw certificates, tokens, proofs, and credentials MUST NOT enter these objects — `subject` is opaque and `proofRef`/`thumbprintRef` are digest references, because these objects reach events, spans, and audit records |
+| `compensation-policy.schema.json` | `compensation.md` §B + RFC 0151 | The reserved `settings.compensation` workflow key — WHEN an unwind starts (`triggers`, closed: `node-failure`/`run-cancel`/`cap-breach`/`operator-request`) and HOW it runs (`orderingModel`, `retry`/`timeoutMs` defaults, `exhaustedDisposition`, escalate-only `approvalScope`, `onParentCancel`). Authored, not per-run; `additionalProperties:false`. A non-advertising host MUST refuse it with `capability_required` rather than accept a policy it will never honour |
 | `workspace-file.schema.json` | `agent-workspace.md` + `RFCS/0059` | RFC 0059 — a versioned workspace file (`{path, content, version, etag, updatedAt}`); response of `GET/PUT /v1/host/workspace/files/{path}`. |
 | `workspace-file-create.schema.json` | `agent-workspace.md` + `RFCS/0059` | RFC 0059 — `PUT /v1/host/workspace/files/{path}` request body (content + optional contentType; path from the URL, version/etag host-assigned). |
 

package/schemas/capabilities.schema.json

@@ -2864,11 +2864,11 @@
         "agentCardUrl": {
           "type": "string",
           "format": "uri",
-          "description": "The A2A 0.3 well-known agent card URL (`/.well-known/agent-card.json`)."
+          "description": "The A2A well-known agent card URL (`/.well-known/agent-card.json` \u2014 the same path in 0.3 and 1.0; the protocol version is discovered INSIDE the 1.0 card via `supportedInterfaces[].protocolVersion`, RFC 0152 \u00a7C)."
         },
         "streaming": {
           "type": "boolean",
-          "description": "Host supports `message/stream` + `tasks/resubscribe` (A2A `capabilities.streaming`). Gates the RFC 0100 \u00a73 resubscribe re-attach."
+          "description": "Host supports `message/stream` + `tasks/resubscribe` (0.3 names) / `SendStreamingMessage` + `SubscribeToTask` (1.0 names) \u2014 A2A `capabilities.streaming`. Gates the RFC 0100 \u00a73 resubscribe re-attach; MUST equal the Agent Card's `capabilities.streaming` (RFC 0152 \u00a7C)."
         },
         "pushNotifications": {
           "type": "boolean",

package/schemas/compensation-policy.schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openwop.dev/spec/v1/compensation-policy.schema.json",
+  "title": "CompensationPolicy",
+  "description": "RFC 0151 §B — the workflow-level compensation policy, carried as the reserved `settings.compensation` key on `WorkflowDefinition` (`workflow-definition.schema.json` §WorkflowSettings). Node-level `compensation` declarations say WHAT the inverse action is; this policy says WHEN the host starts an unwind and HOW it runs one — which failures qualify (`triggers`), the ordering model, retry/timeout defaults for inverse actions, what happens when an inverse action exhausts its retries, whether approval is escalated, and what a parent cancel does to an active unwind. Closed and additive. A host that advertises `capabilities.compensation` MUST validate the policy at workflow registration and refuse one that names an `orderingModel` or `profileVersion` it does not advertise (`validation_error`). A host that does NOT advertise the family MUST refuse a workflow that carries this key with `capability_required` (`details.requiredCapability: \"compensation\"`, per `capabilities.md` §\"Unsupported capability — refusal contract\") rather than accept it silently: accepting a policy the host will never honour tells the author an unwind will happen when it will not, which is RFC 0148 §B's advertise-and-opt-out failure with the sign flipped. Nothing here can WEAKEN a node's own declaration — a node's `compensation.requiresApproval: true` and `retry` bounds always win over the policy's defaults. Policy is authored, not per-run: there is deliberately no run-options overlay, because a per-run caller who could lower approval scope or drop a trigger would be authorizing their own unwind (RFC 0147 R9).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["triggers"],
+  "properties": {
+    "profileVersion": {
+      "type": "string",
+      "pattern": "^[1-9][0-9]*$",
+      "description": "The RFC 0151 profile version this policy was authored against. OPTIONAL; when present it MUST equal the host's advertised `capabilities.compensation.profileVersion` or registration fails, because `profileVersion` is part of the inverse-action identity (§C) and a workflow authored under one ordering rule MUST NOT mint identities under another."
+    },
+    "orderingModel": {
+      "type": "string",
+      "enum": ["reverse-completion", "dependency-graph"],
+      "default": "reverse-completion",
+      "description": "RFC 0151 §A/§C. `reverse-completion` (default) orders inverse actions by descending durable forward-completion sequence; `dependency-graph` MUST be a DAG and preserve reverse dependency order. The value MUST be one of the host's advertised `capabilities.compensation.orderingModels[]`; a host MUST refuse the workflow at registration otherwise, so an unwind never discovers at failure time that its ordering rule is unimplemented."
+    },
+    "triggers": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "enum": ["node-failure", "run-cancel", "cap-breach", "operator-request"]
+      },
+      "description": "Which events start an unwind. REQUIRED and closed — a policy that names no trigger is not a policy, and an open string here would let a host and an author disagree about a word. `node-failure`: a node reaches terminal failure after its own RFC 0009 retry policy and the run cannot continue. `run-cancel`: an RFC 0094 cancel is accepted while committed effects exist. `cap-breach`: an RFC 0058 / RFC 0084 `cap.breached` hard stop. `operator-request`: an authorized operator explicitly requests an unwind (§E) — MUST be authorized per RFC 0049, binding tenant, principal, action, and plan version. A trigger not listed here does NOT start an unwind; the run ends with its committed effects in place and `compensationStatus: none`, which is the honest shape — no generic rollback is inferred from an undeclared trigger (RFC 0151 §Compatibility)."
+    },
+    "retry": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Defaults for inverse actions whose node-level `compensation.retry` is absent. A node's own bounds always win. Retries reuse the inverse action's stable identity (§C) — never a fresh one, or a transient refund failure mints a second refund.",
+      "properties": {
+        "maxAttempts": { "type": "integer", "minimum": 1 },
+        "backoffMs": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "timeoutMs": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Wall-clock ceiling per inverse-action attempt, in milliseconds. A timed-out attempt counts against `retry.maxAttempts`; it is not a distinct outcome."
+    },
+    "exhaustedDisposition": {
+      "type": "string",
+      "enum": ["record-outcome", "manual-intervention"],
+      "default": "record-outcome",
+      "description": "RFC 0151 §E — what the host does when an inverse action exhausts its retries. Either way the run MUST route to RFC 0053 dead-letter handling and the run's `compensationStatus` follows the §D fold (`partial` or `failed`). `record-outcome` (default): record the failure and continue unwinding the remaining actions. `manual-intervention`: additionally emit `compensation.manual_intervention_required` and stop issuing further inverse actions until an authorized operator retries, skips with recorded justification, substitutes a registered action, or terminates as uncompensated — the rollup reads `manual` while that is unresolved. Requires `capabilities.compensation.manualIntervention: true`; a host that does not advertise it MUST refuse a policy that selects it."
+    },
+    "approvalScope": {
+      "type": "string",
+      "enum": ["declared", "all"],
+      "default": "declared",
+      "description": "RFC 0151 §E. `declared` (default): only inverse actions whose node sets `compensation.requiresApproval: true` create an RFC 0051 approval interrupt. `all`: every inverse action does, regardless of the node's declaration. This value can only ESCALATE — there is no `none`, because a policy MUST NOT strip an approval a node declared for itself (RFC 0147 R9: an inverse action can itself be harmful)."
+    },
+    "onParentCancel": {
+      "type": "string",
+      "enum": ["continue", "pause", "manual"],
+      "default": "continue",
+      "description": "RFC 0151 §C — cancellation of the parent run MUST NOT silently abandon an active compensation. `continue`: the unwind runs to its terminal rollup. `pause`: emit `compensation.paused` and hold for authorized intervention (the run's own `status` carries the wait). `manual`: emit `compensation.manual_intervention_required` and stop; rollup reads `manual`. `pause`/`manual` require `capabilities.compensation.manualIntervention: true`."
+    }
+  }
+}

package/schemas/run-snapshot.schema.json

@@ -33,6 +33,11 @@
       ],
       "description": "Current run state. `waiting-external` MUST be used when the suspended interrupt's `kind` is `external-event` per `interrupt-profiles.md §openwop-interrupt-external-event` — distinguishes external-event waits from HITL waits at the wire level. `cancelling` (RFC 0094 §B) is the transitional state between a cancel request being accepted and the terminal `cancelled` — `rest-endpoints.md` and the OpenAPI cancel responses already document the transition; a snapshot read during the cancel cascade carries it. Forward-compat: future statuses MAY be added; readers SHOULD treat unknown values as terminal-unknown rather than throw."
     },
+    "compensationStatus": {
+      "type": "string",
+      "enum": ["none", "pending", "running", "completed", "partial", "failed", "manual"],
+      "description": "RFC 0151 §D — the run's compensation (unwind) rollup, kept separate from `status` on purpose: `status` is the FORWARD execution state and a closed union exported by the SDK, so RFC 0151 forbids reinterpreting it (there is deliberately no `compensating` run status). OPTIONAL and capability-gated — a host that does not advertise `capabilities.compensation` MUST omit this field; a host that advertises it MUST include it on every snapshot, `none` when no compensation was ever requested for the run. Presence is therefore a wire witness of the advert, and a `none` cannot be read as \"unwind is monitored here\" from a host that would never unwind. Values are the deterministic fold of the six `compensation.*` events over the persisted plan, defined normatively in `spec/v1/compensation.md §\"Run rollup: compensationStatus\"`: `none` (no `compensation.requested`), `pending` (requested, no `started`), `running` (started, plan active — a §E approval pause does NOT change it; the run's own `status: waiting-approval` carries the wait), `completed` (every inverse action completed), `partial` (plan inactive; some completed and some did not — reported, never rounded), `failed` (plan inactive; none completed), `manual` (`manual_intervention_required` recorded and unresolved; takes precedence over `partial`/`failed` while unresolved). Content-free by construction. Resolves RFC 0151 UQ3: `RunSnapshot` (`GET /v1/runs/{runId}`) is the sole owner; debug bundles and the AsyncAPI `run.snapshot` reuse it by `$ref`."
+    },
     "owner": {
       "type": "object",
       "description": "RFC 0048. The identity triple that owns this run. Redaction-safe — `principal` is an opaque identifier, never PII or credential material. Optional: single-tenant hosts omit it. A principal scoped to one `workspace` MUST NOT read a run owned by another (`run_forbidden`).",