@openwop/openwop-conformance 2.45.15 → 2.45.17

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-snapshot-etag.test.ts

@@ -7,6 +7,10 @@
  * a host that sends no ETag records `inapplicable`. Every response carries
  * `OpenWOP-Version` (versioning.md §1.4), the 304 included.
  *
+ * The revalidation runs once per client spelling (`OpenWOP-Version: 2.0`,
+ * `2`, and `2` with a wildcard Accept): a host MUST treat them alike
+ * (versioning.md §1), and one public origin served 304 to the first only.
+ *
  * Control: a non-matching `If-None-Match` MUST receive 200 with the body — a
  * host that answers 304 to any conditional request fails here. `headers.md`
  * scopes `If-None-Match` to the discovery document; runs.md applies it to the
@@ -27,6 +31,13 @@ import { req } from '../lib/requirement-ids.js';
 const ID = 'openwop.requirement.0170.run-snapshot-etag';
 const DOC = 'spec/v2/core/runs.md §Snapshot';
 const NOOP = 'conformance-noop';
+/** The client spellings a host MUST treat alike (versioning.md §1): openwop-app's public origin answered 304 to `2.0` and 200 to bare `2`. */
+const SPELLINGS: ReadonlyArray<Readonly<Record<string, string>>> = [
+  { 'OpenWOP-Version': '2.0' },
+  { 'OpenWOP-Version': '2' },
+  { 'OpenWOP-Version': '2', Accept: '*/*' },
+];
+const label = (h: Readonly<Record<string, string>>): string => Object.entries(h).map(([k, v]) => `${k}: ${v}`).join(', ');
 
 async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
@@ -51,29 +62,31 @@ describe('v2 run-snapshot-etag (runs.md §Snapshot)', () => {
     // happened to finish inside the sleep. It also let a host with a CONSTANT tag
     // pass for the wrong reason, which the control below still catches.
     await pollUntilTerminal(runId, { timeoutMs: scaledTimeoutMs(30_000) });
-    let etag: string | null = null;
-    let hit: OpenWOPResponse | null = null;
-    // A terminal run should be still, but "should" is not the claim under test:
-    // if the tag moves again, take the NEW tag and retry. The violation is a 200
-    // whose ETag EQUALS the If-None-Match that was sent — never a 200 per se.
-    for (let attempt = 0; attempt < 4; attempt++) {
-      const first = await http(() => driver.get(path));
-      if (first === null || first.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${first?.status ?? 'no response'}`);
-      etag = first.headers.get('etag');
-      if (!etag) return softSkip('inapplicable', 'the snapshot carries no ETag — runs.md §Snapshot makes the ETag a SHOULD; the 304 rule applies only when it is present');
-      const sent = etag;
-      hit = await http(() => driver.get(path, { headers: { 'If-None-Match': sent } }));
-      if (hit === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
-      if (hit.status !== 200 || hit.headers.get('etag') === sent) break; // 304, or the real violation: decided below
-      await new Promise((r) => setTimeout(r, 500)); // 200 with a DIFFERENT tag: the representation moved; the tag sent was honestly stale
-    }
-    if (hit === null || etag === null) return softSkip('blocked', 'no conditional GET was made');
-    if (hit.status === 200 && hit.headers.get('etag') !== etag) {
-      return softSkip('blocked', `the snapshot of a TERMINAL run kept changing across four reads (last tag sent ${etag}, answered 200 with ${String(hit.headers.get('etag'))}) — the 304 rule cannot be witnessed against a representation that never holds still`);
+    for (const spelling of SPELLINGS) {
+      let etag: string | null = null;
+      let hit: OpenWOPResponse | null = null;
+      // A terminal run should be still, but "should" is not the claim under test:
+      // if the tag moves again, take the NEW tag and retry. The violation is a 200
+      // whose ETag EQUALS the If-None-Match that was sent — never a 200 per se.
+      for (let attempt = 0; attempt < 4; attempt++) {
+        const first = await http(() => driver.get(path, { headers: { ...spelling } }));
+        if (first === null || first.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${first?.status ?? 'no response'}`);
+        etag = first.headers.get('etag');
+        if (!etag) return softSkip('inapplicable', 'the snapshot carries no ETag — runs.md §Snapshot makes the ETag a SHOULD; the 304 rule applies only when it is present');
+        const sent = etag;
+        hit = await http(() => driver.get(path, { headers: { ...spelling, 'If-None-Match': sent } }));
+        if (hit === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
+        if (hit.status !== 200 || hit.headers.get('etag') === sent) break; // 304, or the real violation: decided below
+        await new Promise((r) => setTimeout(r, 500)); // 200 with a DIFFERENT tag: the representation moved; the tag sent was honestly stale
+      }
+      if (hit === null || etag === null) return softSkip('blocked', 'no conditional GET was made');
+      if (hit.status === 200 && hit.headers.get('etag') !== etag) {
+        return softSkip('blocked', `the snapshot of a TERMINAL run kept changing across four reads (last tag sent ${etag}, answered 200 with ${String(hit.headers.get('etag'))}) — the 304 rule cannot be witnessed against a representation that never holds still`);
+      }
+      expect(hit.status, req(ID, DOC, `under ${label(spelling)}, a request whose If-None-Match matches the CURRENT ETag MUST receive 304 — got ${hit.status} while the response still carried the same tag ${etag}`)).toBe(304);
+      expect(hit.text.length, req(ID, DOC, `under ${label(spelling)}, the 304 MUST carry no body (got ${hit.text.length} byte(s))`)).toBe(0);
+      expect(hit.headers.get('openwop-version'), req(ID, 'spec/v2/core/versioning.md §1.4', `under ${label(spelling)}, every response carries OpenWOP-Version, the 304 included`)).not.toBeNull();
     }
-    expect(hit.status, req(ID, DOC, `a request whose If-None-Match matches the CURRENT ETag MUST receive 304 — got ${hit.status} while the response still carried the same tag ${etag}`)).toBe(304);
-    expect(hit.text.length, req(ID, DOC, `the 304 MUST carry no body (got ${hit.text.length} byte(s))`)).toBe(0);
-    expect(hit.headers.get('openwop-version'), req(ID, 'spec/v2/core/versioning.md §1.4', 'every response carries OpenWOP-Version, the 304 included')).not.toBeNull();
     const miss = await http(() => driver.get(path, { headers: { 'If-None-Match': '"openwop-conformance-no-such-tag"' } }));
     if (miss === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
     expect(miss.status, req(ID, DOC, `a non-matching If-None-Match MUST receive 200 with the body — got ${miss.status} (a host answering 304 to any conditional request is not honouring the tag)`)).toBe(200);

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);
+});