@openwop/openwop-conformance 2.45.15 → 2.45.16

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

package/src/scenarios/v2-ui-plugins-advertisement.test.ts

@@ -0,0 +1,85 @@
+/**
+ * v2 — the `uiPlugins` advertisement (`spec/v2/core/packs.md` §Front-end plugin packs): the front-end plugin pack claim. The v1 twin is
+ * `frontend-plugin-packs`;
+ * the legs live in `lib/family-advert-witness.ts` (witness wave 3).
+ *
+ *   record         the record validates against its capabilities-schema seat;
+ *   isolation-model uiPlugins.isolation is a closed mechanism or an x-host value;
+ *   surfaces-closed uiPlugins.surfaces are unique members of the closed surface set;
+ *   host-api-closed uiPlugins.hostApi are unique members of the ui-plugin/1 method set;
+ *   max-entry-bytes uiPlugins.maxEntryBytes is a positive integer;
+ *
+ * Not here: isolation, egress, the RPC allow-list and the no-BYOK rule are seam-gated and v2 mounts no plugin seam; they need a normative observation path (TODO §8).
+ *
+ * Dispositions: discovery unreadable ⇒ `blocked`; `uiPlugins` absent, or the
+ * facet a leg reads absent ⇒ `inapplicable`.
+ *
+ * @see spec/v2/core/packs.md §Front-end plugin packs
+ */
+
+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, uiPluginsHostApiLeg, uiPluginsIsolationLeg, uiPluginsMaxEntryBytesLeg, uiPluginsSurfacesLeg } from '../lib/family-advert-witness.js';
+
+const PROFILE = majorProfile(2);
+const DOC = 'packs.md §Front-end plugin packs';
+const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
+const ID_RECORD = 'openwop.requirement.ui-plugins.advert-record-schema';
+const ID_ISOLATION_MODEL = 'openwop.requirement.ui-plugins.isolation-model';
+const ID_SURFACES_CLOSED = 'openwop.requirement.ui-plugins.surfaces-closed';
+const ID_HOST_API_CLOSED = 'openwop.requirement.ui-plugins.host-api-closed';
+const ID_MAX_ENTRY_BYTES = 'openwop.requirement.ui-plugins.max-entry-bytes';
+
+async function discovery(): Promise<Record<string, unknown> | null> {
+  try { return await v2Discovery(); } catch { return null; }
+}
+
+describe('v2 uiPlugins advertisement (packs.md §Front-end plugin packs)', () => {
+  it('the uiPlugins record validates against its capabilities-schema seat', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('uiPlugins'))) return softSkip('inapplicable', 'the host does not advertise uiPlugins');
+    const out = recordSchemaLeg(PROFILE, doc, 'uiPlugins', 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('uiPlugins.isolation is a closed mechanism or an x-host value', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('uiPlugins'))) return softSkip('inapplicable', 'the host does not advertise uiPlugins');
+    const out = uiPluginsIsolationLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_ISOLATION_MODEL, x.doc, x.message)).toBe(true);
+  });
+
+  it('uiPlugins.surfaces are unique members of the closed surface set', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('uiPlugins'))) return softSkip('inapplicable', 'the host does not advertise uiPlugins');
+    const out = uiPluginsSurfacesLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_SURFACES_CLOSED, x.doc, x.message)).toBe(true);
+  });
+
+  it('uiPlugins.hostApi are unique members of the ui-plugin/1 method set', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('uiPlugins'))) return softSkip('inapplicable', 'the host does not advertise uiPlugins');
+    const out = uiPluginsHostApiLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_HOST_API_CLOSED, x.doc, x.message)).toBe(true);
+  });
+
+  it('uiPlugins.maxEntryBytes is a positive integer', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', UNREADABLE);
+    if (!(await familyAdvertised('uiPlugins'))) return softSkip('inapplicable', 'the host does not advertise uiPlugins');
+    const out = uiPluginsMaxEntryBytesLeg(PROFILE, doc);
+    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+    for (const x of out.findings) expect(x.ok, req(ID_MAX_ENTRY_BYTES, x.doc, x.message)).toBe(true);
+  });
+});