@openwop/openwop-conformance 2.45.14 → 2.45.16

package/src/scenarios/v2-provider-usage-payload-static.test.ts

@@ -0,0 +1,92 @@
+/**
+ * v2 — the `provider.usage` payload, statically (`spec/v2/core/events.md`
+ * §providerUsage; `schemas/v2/run-event-payloads.schema.json#/$defs/providerUsage`;
+ * RFC 0026; invariant `provider-usage-no-credential-leak`). The v1 twin is the
+ * schema half of `provider-usage`; its emit-seam legs (and the v1
+ * `provider_usage_credential_leak` code, which `spec/v2/errors.json` does not
+ * carry) are not ported.
+ *
+ *   type       `provider.usage` is a registered v2 event type;
+ *   positive   a payload with the four required fields, and one with every
+ *              optional field, validates;
+ *   required   a payload missing provider, model, inputTokens or outputTokens
+ *              is rejected;
+ *   counts     a fractional or negative token count is rejected;
+ *   cost       a negative `costEstimateUsd` is rejected; `currency` is an
+ *              ISO 4217 code ("`providerUsage.currency` is the ISO 4217
+ *              currency of `costEstimateUsd`");
+ *   no-leak    the payload is closed, so a credential ref, a hashed credential
+ *              id or prompt/response text is rejected ("The payload MUST NOT
+ *              carry credential refs, hashed credential identifiers, or prompt
+ *              or response text").
+ *
+ * Host-free: every leg runs with no OPENWOP_BASE_URL.
+ *
+ * @see spec/v2/core/events.md §providerUsage
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2RefValidator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'events.md §providerUsage';
+const ID_TYPE = 'openwop.requirement.provider-usage.event-type-registered';
+const ID_POSITIVE = 'openwop.requirement.provider-usage.payload-well-formed-accepted';
+const ID_REQUIRED = 'openwop.requirement.provider-usage.payload-required-fields';
+const ID_COUNTS = 'openwop.requirement.provider-usage.payload-token-counts';
+const ID_COST = 'openwop.requirement.provider-usage.payload-cost-and-currency';
+const ID_NO_LEAK = 'openwop.requirement.provider-usage.payload-no-credential-or-content';
+
+const MINIMAL = { provider: 'anthropic', model: 'claude-x', inputTokens: 120, outputTokens: 30 } as const;
+const FULL = { ...MINIMAL, totalTokens: 150, costEstimateUsd: 0.0021, currency: 'EUR', cacheHit: false, cacheReadTokens: 0, cacheWriteTokens: 64 } as const;
+
+function without(field: string): Record<string, unknown> {
+  const c: Record<string, unknown> = { ...MINIMAL };
+  delete c[field];
+  return c;
+}
+
+describe('v2 provider.usage payload (events.md §providerUsage)', () => {
+  const validate = v2RefValidator('run-event-payloads.schema.json#/$defs/providerUsage');
+
+  it('provider.usage is a registered v2 run-event type', () => {
+    const r = v2RefValidator('run-event.schema.json#/properties/type')('provider.usage');
+    expect(r.ok, req(ID_TYPE, DOC, `provider.usage MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
+  });
+
+  it('accepts a minimal and a full payload', () => {
+    for (const p of [MINIMAL, FULL]) {
+      const r = validate(p);
+      expect(r.ok, req(ID_POSITIVE, DOC, `a well-formed provider.usage payload MUST validate (${r.errors})`)).toBe(true);
+    }
+  });
+
+  it.each(['provider', 'model', 'inputTokens', 'outputTokens'])('rejects a payload without %s', (field) => {
+    expect(validate(without(field)).ok, req(ID_REQUIRED, DOC, `a provider.usage payload without ${field} MUST be rejected`)).toBe(false);
+  });
+
+  it.each<[string, Record<string, unknown>]>([
+    ['a fractional inputTokens', { ...MINIMAL, inputTokens: 1.5 }],
+    ['a negative outputTokens', { ...MINIMAL, outputTokens: -1 }],
+    ['a string inputTokens', { ...MINIMAL, inputTokens: '120' }],
+  ])('rejects %s', (what, p) => {
+    expect(validate(p).ok, req(ID_COUNTS, DOC, `a provider.usage payload with ${what} MUST be rejected`)).toBe(false);
+  });
+
+  it.each<[string, Record<string, unknown>]>([
+    ['a negative costEstimateUsd', { ...MINIMAL, costEstimateUsd: -0.01 }],
+    ['a lower-case currency', { ...MINIMAL, costEstimateUsd: 0.01, currency: 'usd' }],
+    ['a currency symbol', { ...MINIMAL, costEstimateUsd: 0.01, currency: '$' }],
+  ])('rejects %s', (what, p) => {
+    expect(validate(p).ok, req(ID_COST, DOC, `a provider.usage payload with ${what} MUST be rejected`)).toBe(false);
+  });
+
+  it.each<[string, Record<string, unknown>]>([
+    ['a credential ref', { ...MINIMAL, credentialRef: 'secret:tenant:byok-anthropic:v1' }],
+    ['a hashed credential id', { ...MINIMAL, credentialHash: 'sha256:9f2c' }],
+    ['prompt text', { ...MINIMAL, prompt: 'summarize the attached notes' }],
+    ['response text', { ...MINIMAL, response: 'Here is a summary' }],
+  ])('rejects a payload carrying %s', (what, p) => {
+    expect(validate(p).ok, req(ID_NO_LEAK, DOC, `the provider.usage payload MUST NOT carry ${what}`)).toBe(false);
+  });
+});

package/src/scenarios/v2-purpose-propagation-advertisement.test.ts

@@ -0,0 +1,52 @@
+/**
+ * v2 — the `purposePropagation` advertisement (`spec/v2/core/security-defaults.md` §Onward hops): the purpose-label propagation claim. The v1 twin is
+ * `purpose-propagation`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   propagates-onward-boolean purposePropagation.propagatesOnward is a boolean;
+ *
+ * Not here: propagation itself needs a carrier the suite can receive with a label seat (TODO §8).
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `purposePropagation` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/security-defaults.md §Onward hops
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { purposePropagatesOnwardLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'security-defaults.md §Onward hops';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.purpose-propagation.advert-record-schema';
+const ID_PROPAGATES_ONWARD_BOOLEAN = 'openwop.requirement.purpose-propagation.propagates-onward-boolean';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 purposePropagation advertisement (security-defaults.md §Onward hops)', () => {
+  it('the purposePropagation record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('purposePropagation'))) return softSkip('inapplicable', 'the host does not advertise purposePropagation');
+    const out = recordSchemaLeg(PROFILE, doc, 'purposePropagation', DOC);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_RECORD, x.doc, x.message)).toBe(true);
+  });
+
+  it('purposePropagation.propagatesOnward is a boolean', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('purposePropagation'))) return softSkip('inapplicable', 'the host does not advertise purposePropagation');
+    const out = purposePropagatesOnwardLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_PROPAGATES_ONWARD_BOOLEAN, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-run-execution-bounds.test.ts

@@ -0,0 +1,67 @@
+/**
+ * v2 — run execution bounds (`spec/v2/core/runs.md` §`run` section; RFC 0058).
+ * The v1 twin is `run-execution-bounds-shape`; the legs live in
+ * `lib/run-bounds-witness.ts`, and what differs between majors (the run path,
+ * the closed `configurable` shape, the event name) is the profile row.
+ *
+ *   shape     advertised `limits.maxRunDurationMs` (≥ 1000) and
+ *             `limits.maxLoopIterations` (≥ 1) are well-formed;
+ *   refused   NEW at v2, unaided: `configurable.run.runTimeoutMs: 0` is refused
+ *             `400 validation_error` at create (`runs.md`: "An out-of-range
+ *             recursionLimit or runTimeoutMs MUST return 400");
+ *   breach    the `conformance-run-duration-breach` fixture with a 1 s timeout
+ *             ends `failed` / `run_timeout` and emits `cap.breached
+ *             { kind: 'run-duration' }` with `observed > limit`.
+ *
+ * Dispositions: `limits` not advertised, or neither facet ⇒ shape
+ * `inapplicable`; no advertised fixture to name ⇒ refused `inapplicable`; the
+ * breach fixture unadvertised ⇒ breach `inapplicable` (the fixture is the
+ * opt-in, as for the budget and table-schema witnesses).
+ *
+ * Proven against a scratch double in `lib/run-bounds-witness.test.ts`.
+ *
+ * @see spec/v2/core/runs.md §run section, §Limits
+ */
+
+import { describe, it, expect } from 'vitest';
+import { familyAdvertised, v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { getAdvertisedFixtures } from '../lib/fixtures.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { driveBreach, judgeBreach, refusedLeg, shapeLeg, TIMEOUT_FIXTURE } from '../lib/run-bounds-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_SHAPE = 'openwop.requirement.runs.limits-bounds-shape';
+const ID_REFUSED = 'openwop.requirement.runs.run-timeout-out-of-range-refused';
+const ID_BREACH = 'openwop.requirement.runs.run-timeout-breach';
+
+/** Any advertised fixture names a valid workflow, so a refusal can only be about runTimeoutMs. */
+function aFixture(): string | undefined {
+  const all = [...(getAdvertisedFixtures() ?? [])].sort();
+  return all.includes('conformance-noop') ? 'conformance-noop' : all.includes(TIMEOUT_FIXTURE) ? TIMEOUT_FIXTURE : all[0];
+}
+
+describe('v2 run execution bounds (runs.md §run section)', () => {
+  it('advertised limits.maxRunDurationMs and maxLoopIterations are well-formed', async () => {
+    let doc: Record<string, unknown> | null;
+    try { doc = await v2Discovery(); } catch { doc = null; }
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    if (!(await familyAdvertised('limits'))) return softSkip('inapplicable', 'the host does not advertise limits');
+    const out = shapeLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SHAPE, x.doc, x.message)).toBe(true);
+  });
+
+  it('an out-of-range runTimeoutMs is refused 400 validation_error at create', async () => {
+    const out = await refusedLeg(PROFILE, aFixture());
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_REFUSED, x.doc, x.message)).toBe(true);
+  });
+
+  it('a run exceeding runTimeoutMs fails run_timeout with cap.breached { kind: run-duration }', async () => {
+    const o = await driveBreach(PROFILE);
+    if ('kind' in o) return softSkip(o.disposition, o.reason);
+    for (const x of judgeBreach(o)) expect(x.ok, req(ID_BREACH, x.doc, x.message)).toBe(true);
+  }, 60_000);
+});

package/src/scenarios/v2-scheduling-advertisement.test.ts

@@ -0,0 +1,55 @@
+/**
+ * v2 — the `scheduling` advertisement (`spec/v2/core/host-services.md`
+ * §scheduling; RFC 0052). The v1 twin is the advertisement legs of
+ * `scheduling-capability-shape`; the legs live in
+ * `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   forms          each advertised form (`cron`, `delayed`, `calendar`) is one boolean.
+ *
+ * Not ported: the v1 leg that `maxFutureHorizon` is an ISO-8601 duration. The v2
+ * schema seat is a plain string and no v2 prose states the format as binding
+ * the host, so it is not a failing leg here.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `scheduling` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/host-services.md §scheduling
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { recordSchemaLeg, schedulingFormsLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'host-services.md §scheduling';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.scheduling.advert-record-schema';
+const ID_FORMS_BOOLEAN = 'openwop.requirement.scheduling.forms-boolean';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 scheduling advertisement (host-services.md §scheduling)', () => {
+  it('the scheduling record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('scheduling'))) return softSkip('inapplicable', 'the host does not advertise scheduling');
+    const out = recordSchemaLeg(PROFILE, doc, 'scheduling', DOC);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_RECORD, x.doc, x.message)).toBe(true);
+  });
+
+  it('scheduling.cron, delayed and calendar are booleans', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('scheduling'))) return softSkip('inapplicable', 'the host does not advertise scheduling');
+    const out = schedulingFormsLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_FORMS_BOOLEAN, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-self-hosted-runner-advertisement.test.ts

@@ -0,0 +1,52 @@
+/**
+ * v2 — the `selfHostedRunner` advertisement (`spec/v2/core/execution.md`
+ * §selfHostedRunner; RFC 0122). The v1 twin is the advertisement leg of
+ * `self-hosted-runner`; the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its seat in
+ *                  `schemas/v2/capabilities.schema.json` (no v1 `supported` seat);
+ *   dispatchKinds  `dispatchKinds` lists `model`, `tool` or both, each once.
+ *
+ * Not here: registration, subject isolation, at-most-once and liveness need a
+ * runner seam; the frame shapes are `v2-self-hosted-runner-frames-static`.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `selfHostedRunner` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/execution.md §selfHostedRunner
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { recordSchemaLeg, selfHostedRunnerDispatchKindsLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'execution.md §selfHostedRunner';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.self-hosted-runner.advert-record-schema';
+const ID_DISPATCH_KINDS = 'openwop.requirement.self-hosted-runner.dispatch-kinds';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 selfHostedRunner advertisement (execution.md §selfHostedRunner)', () => {
+  it('the selfHostedRunner record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = recordSchemaLeg(PROFILE, doc, 'selfHostedRunner', DOC);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_RECORD, x.doc, x.message)).toBe(true);
+  });
+
+  it('selfHostedRunner.dispatchKinds lists model, tool or both', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    const out = selfHostedRunnerDispatchKindsLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_DISPATCH_KINDS, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-self-hosted-runner-frames-static.test.ts

@@ -0,0 +1,121 @@
+/**
+ * v2 — the self-hosted-runner frame and registration shapes, statically
+ * (`spec/v2/core/execution.md` §selfHostedRunner; RFC 0122). The v1 twin is
+ * the schema half of `self-hosted-runner`; its live legs (subject isolation,
+ * `runner_unavailable`, at-most-once) need a runner seam and are not ported.
+ *
+ *   compile       the three schemas compile under Ajv 2020 with the v2 tree;
+ *   dispatch      a model and a tool dispatch frame validate; a frame with no
+ *                 `seq`, a non-integer or negative `seq`, an unknown `kind`, a
+ *                 model frame without `provider`/`model`, or a tool frame
+ *                 without `tool` is rejected;
+ *   result        a result frame validates; one without `output` is rejected;
+ *   closed        dispatch, result and registration (and its `capabilities`)
+ *                 are closed objects, so no frame or record can carry a
+ *                 credential field alongside the step ("A runner credential
+ *                 MUST NOT transit the host or appear in any frame");
+ *   registration  a registration validates; one without `subject` is rejected
+ *                 (subject-first routing keys on it).
+ *
+ * The shape rules these schemas state bind the host's dispatch frames and its
+ * registration record; the result frame is the runner's, so its legs witness
+ * the corpus shape the host's intake is written against, not the host.
+ *
+ * Host-free: every leg runs with no OPENWOP_BASE_URL.
+ *
+ * @see spec/v2/core/execution.md §selfHostedRunner
+ * @see schemas/v2/self-hosted-runner-dispatch-frame.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Validator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'execution.md §selfHostedRunner';
+const ID_COMPILE = 'openwop.requirement.self-hosted-runner.frame-schemas-compile';
+const ID_DISPATCH = 'openwop.requirement.self-hosted-runner.dispatch-frame-shape';
+const ID_RESULT = 'openwop.requirement.self-hosted-runner.result-frame-shape';
+const ID_CLOSED = 'openwop.requirement.self-hosted-runner.frames-closed';
+const ID_REGISTRATION = 'openwop.requirement.self-hosted-runner.registration-shape';
+
+const SCHEMAS = ['self-hosted-runner-dispatch-frame', 'self-hosted-runner-result-frame', 'self-hosted-runner-registration'] as const;
+
+const MODEL_FRAME = { runId: 'acme/run_x-xxxxxxxxxx', stepId: 'step_3', seq: 12, kind: 'model', provider: 'anthropic', model: 'claude-x', inputs: { messages: [] } } as const;
+const TOOL_FRAME = { runId: 'acme/run_y-xxxxxxxxxx', stepId: 'step_1', seq: 0, kind: 'tool', tool: 'local.shell.readFile', inputs: { path: '/tmp/x' } } as const;
+const RESULT = { runId: 'acme/run_x-xxxxxxxxxx', stepId: 'step_3', seq: 12, output: { role: 'assistant', content: 'ok' } } as const;
+const REGISTRATION = { runnerId: 'runner_laptop_01', subject: 'user_42', capabilities: { providers: ['anthropic'], models: ['claude-x'] } } as const;
+
+function without(o: Readonly<Record<string, unknown>>, field: string): Record<string, unknown> {
+  const c: Record<string, unknown> = { ...o };
+  delete c[field];
+  return c;
+}
+
+describe('v2 self-hosted-runner frames: schemas compile', () => {
+  for (const name of SCHEMAS) {
+    it(`${name}.schema.json compiles under Ajv 2020`, () => {
+      expect(() => v2Validator(name), req(ID_COMPILE, DOC, `schemas/v2/${name}.schema.json MUST compile`)).not.toThrow();
+    });
+  }
+});
+
+describe('v2 self-hosted-runner frames: dispatch frame', () => {
+  const validate = v2Validator('self-hosted-runner-dispatch-frame');
+
+  it('accepts a model frame and a tool frame', () => {
+    for (const f of [MODEL_FRAME, TOOL_FRAME]) {
+      const r = validate(f);
+      expect(r.ok, req(ID_DISPATCH, DOC, `a well-formed ${f.kind} dispatch frame MUST validate (${r.errors})`)).toBe(true);
+    }
+  });
+
+  it.each<[string, Record<string, unknown>]>([
+    ['no seq cursor', without(MODEL_FRAME, 'seq')],
+    ['a fractional seq', { ...MODEL_FRAME, seq: 1.5 }],
+    ['a negative seq', { ...MODEL_FRAME, seq: -1 }],
+    ['an unknown kind', { ...MODEL_FRAME, kind: 'agent' }],
+    ['a model frame without provider', without(MODEL_FRAME, 'provider')],
+    ['a model frame without model', without(MODEL_FRAME, 'model')],
+    ['a tool frame without tool', without(TOOL_FRAME, 'tool')],
+    ['no stepId (the at-most-once key)', without(MODEL_FRAME, 'stepId')],
+  ])('rejects %s', (_what, frame) => {
+    expect(validate(frame).ok, req(ID_DISPATCH, DOC, `a dispatch frame with ${_what} MUST be rejected`)).toBe(false);
+  });
+});
+
+describe('v2 self-hosted-runner frames: result frame', () => {
+  const validate = v2Validator('self-hosted-runner-result-frame');
+
+  it('accepts a result frame', () => {
+    const r = validate(RESULT);
+    expect(r.ok, req(ID_RESULT, DOC, `a well-formed result frame MUST validate (${r.errors})`)).toBe(true);
+  });
+
+  it('rejects a result frame without output', () => {
+    expect(validate(without(RESULT, 'output')).ok, req(ID_RESULT, DOC, 'a result frame without output MUST be rejected')).toBe(false);
+  });
+});
+
+describe('v2 self-hosted-runner frames: closed shapes carry no credential field', () => {
+  it.each<[string, string, Record<string, unknown>]>([
+    ['dispatch frame', 'self-hosted-runner-dispatch-frame', { ...MODEL_FRAME, apiKey: 'sk-canary' }],
+    ['result frame', 'self-hosted-runner-result-frame', { ...RESULT, credential: 'sk-canary' }],
+    ['registration', 'self-hosted-runner-registration', { ...REGISTRATION, bearer: 'sk-canary' }],
+    ['registration capabilities', 'self-hosted-runner-registration', { ...REGISTRATION, capabilities: { providers: ['anthropic'], apiKeys: { anthropic: 'sk-canary' } } }],
+  ])('a %s with an extra credential-named field is rejected', (what, schema, doc) => {
+    expect(v2Validator(schema)(doc).ok, req(ID_CLOSED, DOC, `the ${what} is closed: a runner credential MUST NOT appear in any frame`)).toBe(false);
+  });
+});
+
+describe('v2 self-hosted-runner frames: registration', () => {
+  const validate = v2Validator('self-hosted-runner-registration');
+
+  it('accepts a registration', () => {
+    const r = validate(REGISTRATION);
+    expect(r.ok, req(ID_REGISTRATION, DOC, `a well-formed registration MUST validate (${r.errors})`)).toBe(true);
+  });
+
+  it('rejects a registration without subject', () => {
+    expect(validate(without(REGISTRATION, 'subject')).ok, req(ID_REGISTRATION, DOC, 'a registration without its owning subject MUST be rejected')).toBe(false);
+  });
+});

package/src/scenarios/v2-sub-workflow-advertisement.test.ts

@@ -0,0 +1,53 @@
+/**
+ * v2 — the `subWorkflow` advertisement (`spec/v2/core/execution.md`
+ * §subWorkflow; RFCs 0007, 0022). The v1 twin is the record shape `subWorkflow`
+ * carried at v1; the legs live in `lib/family-advert-witness.ts`.
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   inputMapping   one boolean.
+ *
+ * Not here: the refusal of a non-empty `inputMapping` by a host not advertising
+ * it, and the child-run legs, need workflow registration and a fixture run.
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `subWorkflow` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/execution.md §subWorkflow
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import { recordSchemaLeg, subWorkflowInputMappingLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'execution.md §subWorkflow';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.sub-workflow.advert-record-schema';
+const ID_INPUT_MAPPING_BOOLEAN = 'openwop.requirement.sub-workflow.input-mapping-boolean';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 subWorkflow advertisement (execution.md §subWorkflow)', () => {
+  it('the subWorkflow record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('subWorkflow'))) return softSkip('inapplicable', 'the host does not advertise subWorkflow');
+    const out = recordSchemaLeg(PROFILE, doc, 'subWorkflow', DOC);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_RECORD, x.doc, x.message)).toBe(true);
+  });
+
+  it('subWorkflow.inputMapping is one boolean', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('subWorkflow'))) return softSkip('inapplicable', 'the host does not advertise subWorkflow');
+    const out = subWorkflowInputMappingLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_INPUT_MAPPING_BOOLEAN, x.doc, x.message)).toBe(true);
+  });
+});

package/src/scenarios/v2-subworkflow-input-mapping.test.ts

@@ -0,0 +1,74 @@
+/**
+ * v2 — `core.subWorkflow` `inputMapping` (`spec/v2/core/execution.md`
+ * §`subWorkflow`: "`inputMapping` (`childVar → parentVar`) seeds the child
+ * once, at creation, after and over its `variables[].defaultValue`, which MUST
+ * seed first. An unset parent variable MUST arrive undefined, never an error
+ * or `null`."). The v1 twin is `subworkflow-input-mapping`; the legs live in
+ * `lib/subworkflow-witness.ts`.
+ *
+ *   seed      `conformance-subworkflow-input-mapping`: the child's
+ *             `receivedPrdId` is seeded at creation;
+ *   override  it is the parent's `currentPrdId` ("prd-1"), not the child's
+ *             default ("baked-in");
+ *   unset     `conformance-subworkflow-input-mapping-no-default`: the parent's
+ *             `currentPrdId` is unset — both runs complete, and the child's
+ *             value is absent or its own default, never `null`.
+ * NOT ported: the mid-run mutation leg (it drives a variables seam) and the
+ * registration-refusal leg (it drives a capability-toggle seam).
+ *
+ * Dispositions: the parent fixture or `conformance-subworkflow-input-mapping-child`
+ * not in `fixtures[]` ⇒ `inapplicable`; discovery unreadable ⇒ `blocked`.
+ *
+ * Proven against a double in `lib/subworkflow-witness.test.ts`.
+ *
+ * @see spec/v2/core/execution.md §subWorkflow (inputMapping)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import type { Outcome, Skip } from '../lib/fixture-run-observer.js';
+import { IM_NO_DEFAULT_FIXTURE, IM_PARENT_FIXTURE, driveInputMapping, judgeOverride, judgeSeed, judgeUnset, type MappingObservation } from '../lib/subworkflow-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_SEED = 'openwop.requirement.sub-workflow.input-mapping-seeds-child';
+const ID_OVERRIDE = 'openwop.requirement.sub-workflow.input-mapping-overrides-default';
+const ID_UNSET = 'openwop.requirement.sub-workflow.input-mapping-unset-undefined';
+
+const runs = new Map<string, Promise<Skip | MappingObservation>>();
+async function observation(fixture: string): Promise<MappingObservation | (() => undefined)> {
+  if (!process.env['OPENWOP_BASE_URL']) return () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+  if (!runs.has(fixture)) runs.set(fixture, driveInputMapping(PROFILE, fixture));
+  const o = await runs.get(fixture)!;
+  return 'kind' in o ? () => softSkip(o.disposition, o.reason) : o;
+}
+function assert(id: string, out: Outcome): undefined {
+  if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+  for (const x of out.findings) expect(x.ok, req(id, x.doc, x.message)).toBe(true);
+  return undefined;
+}
+
+describe('v2 subWorkflow: inputMapping (execution.md §subWorkflow)', () => {
+  it('inputMapping seeds the child variable bag at creation', async () => {
+    const o = await observation(IM_PARENT_FIXTURE);
+    if (typeof o === 'function') return o();
+    return assert(ID_SEED, judgeSeed(o));
+  }, 90_000);
+
+  it('the mapped parent value lands after and over the child defaultValue', async () => {
+    const o = await observation(IM_PARENT_FIXTURE);
+    if (typeof o === 'function') return o();
+    return assert(ID_OVERRIDE, judgeOverride(o));
+  }, 90_000);
+
+  it('an unset parent variable arrives undefined, never an error or null', async () => {
+    const o = await observation(IM_NO_DEFAULT_FIXTURE);
+    if (typeof o === 'function') return o();
+    return assert(ID_UNSET, judgeUnset(o));
+  }, 90_000);
+});

package/src/scenarios/v2-subworkflow-linkage.test.ts

@@ -0,0 +1,76 @@
+/**
+ * v2 — `core.subWorkflow` output and parent link (`spec/v2/core/execution.md`
+ * §`subWorkflow`). The v1 twin is `subworkflow`; the legs live in
+ * `lib/subworkflow-witness.ts`.
+ *
+ * A run of `conformance-subworkflow-parent` (node `subwf-call` starts
+ * `conformance-subworkflow-child`, `outputMapping: { childOutcome: childResult }`)
+ * is created with `POST /runs` and its log read with `events/poll`:
+ *   output         the parent's `node.completed` for `subwf-call` carries
+ *                  `outputs.childRunId` and `outputs.childStatus`, and the
+ *                  status is the child's terminal status;
+ *   outputMapping  the parent's `childOutcome` is the child's `childResult`;
+ *   ancestry       where `getRunAncestry` is served, the child's `parent` is
+ *                  the parent run with `cause: "core.subWorkflow"`.
+ * RETIRED, not ported: v1's child `parentRunId` / `parentNodeId` linkage
+ * (`spec/v1/migrations.json` C4.18). At v2 `parentRunId` is fork lineage.
+ *
+ * Dispositions: either fixture not in `fixtures[]` ⇒ `inapplicable`;
+ * `multiAgent.executionModel.crossHostCausation.ancestryEndpointSupported` not
+ * advertised ⇒ the ancestry leg `inapplicable`; discovery unreadable ⇒ `blocked`.
+ *
+ * Proven against a double in `lib/subworkflow-witness.test.ts`.
+ *
+ * @see spec/v2/core/execution.md §subWorkflow (Output, outputMapping, Parent link)
+ * @see spec/v2/core/runs.md §Diff and ancestry
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import type { Outcome, Skip } from '../lib/fixture-run-observer.js';
+import { driveLinkage, judgeAncestry, judgeOutput, judgeOutputMapping, type LinkageObservation } from '../lib/subworkflow-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_OUTPUT = 'openwop.requirement.sub-workflow.node-completed-child-outputs';
+const ID_OUTPUT_MAPPING = 'openwop.requirement.sub-workflow.output-mapping-copied';
+const ID_ANCESTRY = 'openwop.requirement.sub-workflow.ancestry-parent-link';
+const validateAncestry = v2RefValidator('run-ancestry-response.schema.json');
+
+let run: Promise<Skip | LinkageObservation> | undefined;
+async function observation(): Promise<LinkageObservation | (() => undefined)> {
+  if (!process.env['OPENWOP_BASE_URL']) return () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  if (!doc) return () => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+  run ??= driveLinkage(PROFILE, doc);
+  const o = await run;
+  return 'kind' in o ? () => softSkip(o.disposition, o.reason) : o;
+}
+function assert(id: string, out: Outcome): undefined {
+  if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+  for (const x of out.findings) expect(x.ok, req(id, x.doc, x.message)).toBe(true);
+  return undefined;
+}
+
+describe('v2 subWorkflow: output and parent link (execution.md §subWorkflow)', () => {
+  it('node.completed for the core.subWorkflow node carries outputs.childRunId and outputs.childStatus', async () => {
+    const o = await observation();
+    if (typeof o === 'function') return o();
+    return assert(ID_OUTPUT, judgeOutput(o));
+  }, 90_000);
+
+  it('outputMapping copies the child variable into the parent after the child completes', async () => {
+    const o = await observation();
+    if (typeof o === 'function') return o();
+    return assert(ID_OUTPUT_MAPPING, judgeOutputMapping(o));
+  }, 90_000);
+
+  it('getRunAncestry names the parent run with cause core.subWorkflow', async () => {
+    const o = await observation();
+    if (typeof o === 'function') return o();
+    return assert(ID_ANCESTRY, judgeAncestry(o, validateAncestry));
+  }, 90_000);
+});