@openwop/openwop-conformance 1.28.0 → 1.33.0

package/src/scenarios/multi-party-conversation-behavioral.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Multi-party group conversation — behavioral leg (RFC 0101 §Conformance).
+ *
+ * Gated on `capabilities.multiPartyConversation.supported` (root-first per RFC
+ * 0073, via `isMultiPartyConversationSupported()`). Soft-skips when unadvertised
+ * (default) / hard-fails under `OPENWOP_REQUIRE_BEHAVIOR=true` via `behaviorGate`.
+ * The companion always-on wire-shape coverage lives in
+ * `multi-party-conversation-shape.test.ts`; THIS scenario asserts host BEHAVIOR
+ * — the cross-field / runtime MUSTs JSON Schema cannot express.
+ *
+ * RFC 0101 standardizes the multi-party *shape* but mints NO normative client
+ * wire-route to OPEN a conversation (opening / turn order / rounds are
+ * non-normative product policy). The driver therefore initiates a council + submits
+ * turns via the conformance-only seam `POST /v1/host/sample/conversation/multi-party/
+ * {open,exchange}` (`host-sample-test-seams.md`), which routes through the SAME
+ * roster-membership + attribution enforcement the host applies in production. The
+ * seam is OPTIONAL — the scenario soft-skips on `404`/`405` (a capability-advertising
+ * host whose enforcement is bound to a product flow witnesses instead via its own
+ * host-side test + an `INTEROP-MATRIX.md` row, the RFC 0086 dual-staging).
+ *
+ * Behavioral MUSTs asserted (RFC 0101 §Spec):
+ *   1. POSITIVE — a 3-agent council opens and a roster-valid, attributed agent
+ *      turn (role:'agent' + in-roster speakerId) is accepted.
+ *   2. ATTRIBUTION — a role:'agent' turn missing `speakerId` is rejected with
+ *      `validation_error` (§Spec item 2).
+ *   3. MEMBERSHIP — a turn whose `speakerId` is NOT in the declared roster is
+ *      rejected with `validation_error` (§Spec item 3 / RFC 0005 §E).
+ *   4. MAXPARTICIPANTS — when the host advertises `maxParticipants`, an `open`
+ *      whose roster exceeds it is rejected with `validation_error` (§Spec item 4).
+ *
+ * RFC 0005 §E pins the rejection *code* (`validation_error`), not the HTTP status —
+ * the leg asserts on `error.code` and tolerates `400`/`422`.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0101-multi-party-group-conversation.md
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0005-conversation.md (§E turn-validation)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-sample-test-seams.md (multi-party seam)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { isMultiPartyConversationSupported } from '../lib/multi-agent-capabilities.js';
+import {
+  readMultiPartyCap,
+  openMultiPartyConversation,
+  exchangeMultiPartyTurn,
+  isValidationErrorRejection,
+  type SeamAgentRef,
+  type SeamTurn,
+} from '../lib/multiPartyConversation.js';
+
+const PROFILE = 'openwop-multi-party-conversation';
+
+const ROSTER: SeamAgentRef[] = [
+  { agentId: 'host:advisor-cfo', name: 'CFO' },
+  { agentId: 'host:advisor-cmo', name: 'CMO' },
+  { agentId: 'host:advisor-cto', name: 'CTO' },
+];
+
+/** A roster-valid, attributed agent turn from a named member. */
+function agentTurn(speakerId: string, turnIndex: number): SeamTurn {
+  return {
+    messageId: `council-q1:${turnIndex}:agent`,
+    from: speakerId,
+    content: 'A roster-valid attributed turn.',
+    ts: 1718900000000 + turnIndex,
+    role: 'agent',
+    turnIndex,
+    speakerId,
+  };
+}
+
+describe('multi-party-conversation-behavioral (RFC 0101 §Conformance)', () => {
+  it('opens a council, accepts an attributed turn, and rejects missing/non-participant/over-cap', async () => {
+    const cap = await readMultiPartyCap();
+    const advertised = isMultiPartyConversationSupported() || cap?.supported === true;
+    if (!behaviorGate(PROFILE, advertised)) return;
+
+    // ---- Open a 3-agent council via the conformance seam ------------------
+    const convId = 'conf:multi-party:council-q1';
+    const opened = await openMultiPartyConversation({ conversationId: convId, participants: ROSTER });
+    if (opened.unwired) return; // seam not wired on this host — soft-skip the behavioral leg
+    expect(
+      opened.status === 200,
+      driver.describe('RFC 0101 §Spec', 'a conforming 3-agent council MUST open (≤ maxParticipants)'),
+    ).toBe(true);
+
+    // ---- MUST 1: POSITIVE — a roster-valid attributed turn is accepted ----
+    const ok = await exchangeMultiPartyTurn({ conversationId: convId, turn: agentTurn('host:advisor-cfo', 1) });
+    if (ok.unwired) return;
+    expect(
+      ok.status === 200,
+      driver.describe('RFC 0101 §Spec', "a role:'agent' turn with an in-roster speakerId MUST be accepted"),
+    ).toBe(true);
+
+    // ---- MUST 2: ATTRIBUTION — agent turn missing speakerId is rejected ---
+    const missing: SeamTurn = { ...agentTurn('host:advisor-cmo', 2) };
+    delete missing.speakerId;
+    const missingRes = await exchangeMultiPartyTurn({ conversationId: convId, turn: missing });
+    if (!missingRes.unwired) {
+      expect(
+        isValidationErrorRejection(missingRes),
+        driver.describe('RFC 0101 §Spec (attribution MUST)', "a role:'agent' turn missing speakerId MUST be rejected with validation_error"),
+      ).toBe(true);
+    }
+
+    // ---- MUST 3: MEMBERSHIP — non-participant speakerId is rejected --------
+    const intruder = agentTurn('host:advisor-intruder', 3);
+    const intruderRes = await exchangeMultiPartyTurn({ conversationId: convId, turn: intruder });
+    if (!intruderRes.unwired) {
+      expect(
+        isValidationErrorRejection(intruderRes),
+        driver.describe('RFC 0101 §Spec (membership MUST) / RFC 0005 §E', 'a turn whose speakerId is not in the roster MUST be rejected with validation_error'),
+      ).toBe(true);
+    }
+
+    // ---- MUST 4: MAXPARTICIPANTS — over-cap open is rejected ---------------
+    // Only assertable when the host advertises a maxParticipants ceiling.
+    const maxP = typeof cap?.maxParticipants === 'number' ? cap.maxParticipants : undefined;
+    if (typeof maxP === 'number' && maxP >= 2) {
+      const overflow: SeamAgentRef[] = Array.from({ length: maxP + 1 }, (_v, i) => ({
+        agentId: `host:advisor-${i}`,
+      }));
+      const overRes = await openMultiPartyConversation({
+        conversationId: 'conf:multi-party:overflow',
+        participants: overflow,
+      });
+      if (!overRes.unwired) {
+        expect(
+          isValidationErrorRejection(overRes),
+          driver.describe('RFC 0101 §Spec (maxParticipants MUST)', 'an open whose roster exceeds the advertised maxParticipants MUST be rejected with validation_error'),
+        ).toBe(true);
+      }
+    }
+  });
+});

package/src/scenarios/multi-party-conversation-shape.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Multi-party group conversation — shared transcript + speaker attribution (RFC 0101).
+ *
+ * Always-on, server-free schema-shape probe. Verifies the three additive,
+ * normative RFC 0101 wire facts on the published schemas:
+ *
+ *   1. `conversation-event.schema.json` `ConversationOpenedPayload` carries an
+ *      OPTIONAL `participants: AgentRef[]` roster — a conforming 3-agent council
+ *      transcript validates, and a malformed participant item is rejected.
+ *   2. `conversation-turn.schema.json` REQUIRES `speakerId` when `role: 'agent'`
+ *      (the `allOf`/`if` conditional) — an agent turn WITH a roster-instance
+ *      `speakerId` validates; an agent turn that OMITS `speakerId` MUST FAIL
+ *      schema validation (the RFC 0101 attribution MUST); a `user`/`system` turn
+ *      without `speakerId` is unaffected (additive — pre-RFC-0101 producers).
+ *   3. `capabilities.schema.json` declares the `multiPartyConversation` block with
+ *      its `supported` flag (+ optional `maxParticipants`), and it is closed
+ *      (`additionalProperties: false`).
+ *
+ * The non-participant-rejection MUST (a turn whose `speakerId` is NOT in the
+ * declared `participants` roster MUST be rejected) is a HOST-enforced runtime
+ * contract — it is not expressible by JSON Schema alone (roster membership is
+ * cross-field state). This probe asserts the wire SHAPE that makes the check
+ * possible (roster present + every agent turn attributed) and verifies the
+ * membership predicate directly; the behavioral leg (a live host rejecting a
+ * non-participant turn with `validation_error`) is gated on
+ * `multiPartyConversation.supported` and lands at the reference-host
+ * implementation (RFC 0101 §Conformance — same staging as RFC 0086's roster
+ * `roster.run.initiated` behavioral leg). This scenario asserts the wire
+ * contract, not host behavior.
+ *
+ * Normative references:
+ *   - RFCS/0101-multi-party-group-conversation.md (§Spec / §Schema / §Conformance)
+ *   - RFCS/0005-conversation.md (the single-agent conversation primitive this extends)
+ *   - schemas/conversation-event.schema.json (ConversationOpenedPayload.participants)
+ *   - schemas/conversation-turn.schema.json (speakerId + the role==='agent' conditional)
+ *   - schemas/capabilities.schema.json (multiPartyConversation)
+ *
+ * @see RFCS/0101-multi-party-group-conversation.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+/** Server-free assertion-message helper. */
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+
+function loadSchema(name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+}
+
+describe('multi-party-conversation-shape: participant roster on conversation.opened (RFC 0101 §Schema, server-free)', () => {
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  ajv.addSchema(loadSchema('conversation-event.schema.json'), 'conversation-event');
+  const opened = ajv.getSchema('conversation-event#/$defs/ConversationOpenedPayload');
+
+  it('the ConversationOpenedPayload $def exists and declares participants: AgentRef[]', () => {
+    expect(opened, 'the ConversationOpenedPayload $def MUST exist').toBeTruthy();
+  });
+
+  it('a conforming 3-agent council transcript (participant roster + user opening turn) validates', () => {
+    const good = {
+      conversationId: 'run-abc:n1:0',
+      agentId: 'host:advisor-cfo',
+      participants: [
+        { agentId: 'host:advisor-cfo', name: 'CFO' },
+        { agentId: 'host:advisor-cmo', name: 'CMO' },
+        { agentId: 'host:advisor-cto', name: 'CTO' },
+      ],
+      initialTurn: {
+        messageId: 'run-abc:n1:0:user',
+        from: 'user',
+        content: 'Should we launch in Q3 or Q4?',
+        ts: 1718900000000,
+        role: 'user',
+        turnIndex: 0,
+      },
+    };
+    expect(opened!(good), why('RFC 0101 §Schema', 'a conversation.opened with a participant roster MUST validate')).toBe(true);
+  });
+
+  it('a participant entry that is not a valid AgentRef (no agentId) is rejected', () => {
+    const bad = {
+      conversationId: 'run-abc:n1:0',
+      participants: [{ name: 'CFO' }],
+      initialTurn: {
+        messageId: 'run-abc:n1:0:user',
+        from: 'user',
+        content: 'x',
+        ts: 1,
+        role: 'user',
+        turnIndex: 0,
+      },
+    };
+    expect(opened!(bad), why('RFC 0101 §Schema', 'a participants[] item without agentId MUST be rejected')).toBe(false);
+  });
+
+  it('participants is OPTIONAL — a single-agent conversation.opened (no roster) still validates (back-compat)', () => {
+    const noRoster = {
+      conversationId: 'run-abc:n1:0',
+      agentId: 'host:advisor-cfo',
+      initialTurn: {
+        messageId: 'run-abc:n1:0:user',
+        from: 'user',
+        content: 'x',
+        ts: 1,
+        role: 'user',
+        turnIndex: 0,
+      },
+    };
+    expect(opened!(noRoster), why('RFC 0101 §Compatibility', 'participants is additive — a roster-less conversation MUST still validate')).toBe(true);
+  });
+});
+
+describe('multi-party-conversation-shape: per-turn speaker attribution (RFC 0101 §Schema, server-free)', () => {
+  const ajv = new Ajv2020({ strict: false, allErrors: true });
+  addFormats(ajv);
+  const turn = ajv.compile(loadSchema('conversation-turn.schema.json'));
+
+  const agentBase = {
+    messageId: 'council-q1:1:agent',
+    from: 'host:advisor-cfo',
+    content: "From a cash-runway view I'd push the launch one quarter.",
+    ts: 1718900000000,
+    role: 'agent' as const,
+    turnIndex: 1,
+  };
+
+  it('an agent turn WITH a roster-instance speakerId validates', () => {
+    expect(
+      turn({ ...agentBase, speakerId: 'host:advisor-cfo' }),
+      why('RFC 0101 §Schema', "a role:'agent' turn carrying speakerId MUST validate"),
+    ).toBe(true);
+  });
+
+  it("a role:'agent' turn MISSING speakerId MUST fail schema validation (the attribution MUST)", () => {
+    expect(
+      turn(agentBase),
+      why('RFC 0101 §Schema', "a role:'agent' turn that omits speakerId MUST be rejected (the conditional required)"),
+    ).toBe(false);
+  });
+
+  it("speakerId is OPTIONAL for role:'user' / role:'system' turns (additive — pre-RFC-0101 producers)", () => {
+    expect(
+      turn({ messageId: 'council-q1:0:user', from: 'user', content: 'Q3 or Q4?', ts: 1, role: 'user', turnIndex: 0 }),
+      why('RFC 0101 §Compatibility', "a role:'user' turn without speakerId MUST still validate"),
+    ).toBe(true);
+    expect(
+      turn({ messageId: 'council-q1:9:system', from: 'system', content: 'conversation timed out', ts: 1, role: 'system', turnIndex: 9 }),
+      why('RFC 0101 §Compatibility', "a role:'system' turn without speakerId MUST still validate"),
+    ).toBe(true);
+  });
+});
+
+describe('multi-party-conversation-shape: non-participant turn detection (RFC 0101 §Spec, server-free)', () => {
+  // The roster-membership MUST ("a turn whose speakerId is not a participant MUST
+  // be rejected") is host-enforced cross-field state, not JSON-Schema-expressible.
+  // This probe asserts the membership predicate the host applies, over the same
+  // shapes the schema validates — so the wire contract that makes the check
+  // possible is verified server-free; the live-host rejection is the gated
+  // behavioral leg (below).
+  const roster = new Set(['host:advisor-cfo', 'host:advisor-cmo', 'host:advisor-cto']);
+
+  it('a turn whose speakerId IS a participant is admissible', () => {
+    expect(roster.has('host:advisor-cmo'), why('RFC 0101 §Spec', 'an agent in the roster MAY speak')).toBe(true);
+  });
+
+  it('a turn whose speakerId is NOT a participant MUST be rejected by the host (roster membership)', () => {
+    expect(
+      roster.has('host:advisor-intruder'),
+      why('RFC 0101 §Spec', 'a turn from a non-participant agent MUST be rejected'),
+    ).toBe(false);
+  });
+});
+
+describe('multi-party-conversation-shape: capability advertisement (RFC 0101 §Schema, server-free)', () => {
+  it('capabilities.schema.json declares multiPartyConversation with supported + optional maxParticipants, closed', () => {
+    const caps = loadSchema('capabilities.schema.json');
+    const props = caps.properties as Record<string, Record<string, unknown>>;
+    const mpc = props.multiPartyConversation as
+      | { properties?: Record<string, unknown>; required?: string[]; additionalProperties?: boolean }
+      | undefined;
+    expect(mpc, why('RFC 0101 §Schema', 'capabilities.multiPartyConversation MUST be declared')).toBeDefined();
+    expect(mpc?.properties?.supported, why('RFC 0101 §Schema', 'multiPartyConversation.supported MUST be declared')).toBeDefined();
+    expect(mpc?.properties?.maxParticipants, why('RFC 0101 §Schema', 'multiPartyConversation.maxParticipants MUST be declared (optional)')).toBeDefined();
+    expect(mpc?.required, why('RFC 0101 §Schema', 'supported MUST be required on the block')).toContain('supported');
+    expect(mpc?.additionalProperties, why('RFC 0101 §Schema', 'the multiPartyConversation block MUST be closed')).toBe(false);
+  });
+
+  it('the multiPartyConversation block validates a conforming advertisement and rejects extras', () => {
+    const caps = loadSchema('capabilities.schema.json');
+    const mpc = (caps.properties as Record<string, Record<string, unknown>>).multiPartyConversation;
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(mpc);
+    expect(validate({ supported: true, maxParticipants: 8 }), why('RFC 0101 §Schema', 'a conforming advertisement MUST validate')).toBe(true);
+    expect(validate({ supported: true }), why('RFC 0101 §Schema', 'maxParticipants is optional')).toBe(true);
+    expect(validate({ maxParticipants: 8 }), why('RFC 0101 §Schema', 'supported is required')).toBe(false);
+    expect(validate({ supported: true, unexpected: 1 }), why('RFC 0101 §Schema', 'an extra key MUST be rejected (closed block)')).toBe(false);
+    expect(validate({ supported: true, maxParticipants: 1 }), why('RFC 0101 §Schema', 'maxParticipants minimum is 2 (a council has ≥2)')).toBe(false);
+  });
+});

package/src/scenarios/registry-declarative-kinds.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Publishable declarative pack kinds (RFC 0107, `Active`).
+ *
+ * OpenWOP defines declarative pack kinds at the SOURCE level — artifact-type
+ * (RFC 0075, `kind: "artifact-type"`) and connection (RFC 0095,
+ * `kind: "connection"`). RFC 0107 extends the PUBLISHED contract,
+ * `registry-version-manifest.schema.json`, so those kinds can be published to a
+ * registry: it adds a `kind` discriminator (absent ≡ `node`), the per-kind
+ * declarative payload (`artifactTypes[]` / `provider` / `chains[]` / …), and
+ * makes `runtime` required only for executable kinds.
+ *
+ * Always-on + server-free. Two parts (mirrors the project's other
+ * schema-contract scenarios):
+ *
+ *   PART 1 — contract present. `registry-operations.md` §"Validation flow"
+ *   carries the kind-aware manifest-schema selection (#3) and the
+ *   skip-runtime-check-for-declarative-kinds rule (#7); the version-manifest
+ *   schema carries the `kind` enum + declarative payload + conditional runtime.
+ *   Guards against the requirement being silently dropped.
+ *
+ *   PART 2 — schema admits declarative kinds and still rejects malformed ones.
+ *   A published artifact-type and a published connection version manifest
+ *   validate; a node manifest is unchanged; a declarative manifest carrying
+ *   `runtime` (forbidden) and a node manifest missing `runtime` are rejected.
+ *
+ * @see spec/v1/registry-operations.md §"Validation flow"
+ * @see schemas/registry-version-manifest.schema.json
+ * @see RFCS/0107-publishable-declarative-pack-kinds.md
+ * @see RFCS/0075-artifact-type-packs-realworld-amendment.md, RFCS/0095-connection-packs-portable-provider-definitions.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
+
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+
+describe('registry-declarative-kinds: contract present in the corpus (RFC 0107, server-free)', () => {
+  const registryDoc = V1_DIR ? readFileSync(join(V1_DIR, 'registry-operations.md'), 'utf8') : '';
+  const versionManifestSchema = JSON.parse(
+    readFileSync(join(SCHEMAS_DIR, 'registry-version-manifest.schema.json'), 'utf8'),
+  );
+
+  it.skipIf(V1_DIR === null)('registry-operations.md §Validation flow selects the manifest schema by `kind`', () => {
+    expect(
+      /kind[\s\S]{0,120}artifact-type-pack-manifest\.schema\.json/.test(registryDoc),
+      why('registry-operations.md §Validation flow #3', 'pack.json validates against the per-`kind` source schema (RFC 0107)'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('registry-operations.md §Validation flow skips the runtime check for declarative kinds', () => {
+    expect(
+      /declarative[\s\S]{0,160}(skipped|MUST NOT)/i.test(registryDoc) && /runtime/i.test(registryDoc),
+      why('registry-operations.md §Validation flow #7', 'runtime-support check is skipped for declarative kinds (RFC 0107)'),
+    ).toBe(true);
+  });
+
+  it('registry-version-manifest.schema.json carries the `kind` discriminator + declarative payload + conditional runtime', () => {
+    const props = versionManifestSchema.properties ?? {};
+    expect(props.kind?.enum, why('registry-version-manifest.schema.json', '`kind` enum present')).toEqual(
+      expect.arrayContaining(['node', 'artifact-type', 'connection']),
+    );
+    expect(!!props.artifactTypes && !!props.provider, why('registry-version-manifest.schema.json', 'declarative payload props present')).toBe(true);
+    expect(
+      (versionManifestSchema.required ?? []).includes('runtime'),
+      why('registry-version-manifest.schema.json', '`runtime` is NOT top-level required (conditional on kind)'),
+    ).toBe(false);
+    expect(
+      JSON.stringify(versionManifestSchema.allOf ?? []).includes('runtime'),
+      why('registry-version-manifest.schema.json', '`allOf` if/then/else makes runtime conditional on kind'),
+    ).toBe(true);
+  });
+});
+
+describe('registry-declarative-kinds: version-manifest schema admits declarative kinds (RFC 0107, server-free)', () => {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const validate = ajv.compile(
+    JSON.parse(readFileSync(join(SCHEMAS_DIR, 'registry-version-manifest.schema.json'), 'utf8')),
+  );
+
+  const base = { name: 'core.openwop.x', version: '1.0.0', engines: { openwop: '>=1.0.0' }, integrity: 'sha256-abc=' };
+
+  it('a published artifact-type version manifest validates (kind + artifactTypes, no runtime)', () => {
+    const ok = validate({ ...base, kind: 'artifact-type', artifactTypes: [{ artifactTypeId: 'doc.one-pager', title: 'One-Pager', schema: { type: 'object' } }] });
+    expect(ok, why('registry-operations.md §Validation flow', 'artifact-type manifest publishes (RFC 0107)')).toBe(true);
+  });
+
+  it('a published connection version manifest validates (kind + provider, no runtime)', () => {
+    const ok = validate({ ...base, kind: 'connection', provider: { id: 'github', category: 'dev' } });
+    expect(ok, why('registry-operations.md §Validation flow', 'connection manifest publishes (RFC 0107)')).toBe(true);
+  });
+
+  it('an unchanged node version manifest still validates (no kind, runtime + nodes)', () => {
+    const ok = validate({ ...base, runtime: { language: 'javascript' }, nodes: [{ typeId: 'core.openwop.x.n', version: '1.0.0', category: 'data', role: 'pure' }] });
+    expect(ok, why('COMPATIBILITY.md §2.1', 'RFC 0107 is additive — node manifests validate unchanged')).toBe(true);
+  });
+
+  it('a declarative manifest carrying `runtime` is REJECTED (declarative kinds carry no runtime)', () => {
+    const ok = validate({ ...base, kind: 'artifact-type', artifactTypes: [{ artifactTypeId: 'doc.x' }], runtime: { language: 'javascript' } });
+    expect(ok, why('registry-version-manifest.schema.json', 'declarative kind MUST NOT carry runtime')).toBe(false);
+  });
+
+  it('a node manifest MISSING `runtime` is still REJECTED (executable kinds require runtime)', () => {
+    const ok = validate({ ...base, nodes: [{ typeId: 'core.openwop.x.n', version: '1.0.0', category: 'data', role: 'pure' }] });
+    expect(ok, why('registry-version-manifest.schema.json', 'executable kind (node/absent) still requires runtime')).toBe(false);
+  });
+});

package/src/scenarios/speech-synthesis-roundtrip.test.ts

@@ -0,0 +1,78 @@
+/**
+ * Speech-synthesis round-trip (RFC 0105 §A) — behavioral.
+ *
+ * Gated on `capabilities.aiProviders.speechSynthesis === 'supported'`
+ * (root-first per RFC 0073). Soft-skips when unadvertised (default) /
+ * hard-fails under `OPENWOP_REQUIRE_BEHAVIOR=true`. The always-on wire-shape
+ * coverage lives in `aiproviders-speechsynth-shape.test.ts`; this asserts host
+ * BEHAVIOR via the documented host-sample seam
+ * `POST /v1/host/sample/ai/call-speech-synthesizer` (soft-skips on 404 until a
+ * host wires it):
+ *
+ *   - the synthesizer returns 200 with an `audio` object;
+ *   - EXACTLY ONE of `audio.url` / `audio.base64` is present (a host-served URL
+ *     reference OR an inline base64 asset — never both, never neither);
+ *   - `audio.mimeType` is a non-empty string;
+ *   - `audio.voiceId` echoes the input `voiceId` (the opaque host-resolved id).
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0105-speech-synthesis-adapter.md (§A)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const SEAM = '/v1/host/sample/ai/call-speech-synthesizer';
+const VOICE_ID = 'host:narrator-test';
+
+/** Pull the `audio` object out of a seam response body (tolerant). */
+function audioOf(json: unknown): Record<string, unknown> | undefined {
+  const a = (json as { audio?: unknown })?.audio;
+  return a && typeof a === 'object' ? (a as Record<string, unknown>) : undefined;
+}
+
+describe('speech-synthesis-roundtrip (RFC 0105 §A)', () => {
+  it('synthesizes an audio asset with exactly one of url/base64 and echoes the voiceId', async () => {
+    const ai = await readCapabilityFamily<Record<string, unknown>>('aiProviders');
+    const advertised = ai?.speechSynthesis === 'supported';
+    if (!behaviorGate('openwop-speech-synthesis', advertised)) return;
+
+    const res = await driver.post(SEAM, {
+      text: 'Welcome to the weekly digest.',
+      voiceId: VOICE_ID,
+    });
+    if (res.status === 404) return; // seam unwired — soft-skip the behavioral suite
+
+    expect(
+      res.status === 200,
+      driver.describe('RFC 0105 §A', 'an advertised host MUST synthesize and return 200'),
+    ).toBe(true);
+
+    const audio = audioOf(res.json);
+    expect(
+      audio !== undefined,
+      driver.describe('RFC 0105 §A', 'the response MUST carry an `audio` object'),
+    ).toBe(true);
+    if (!audio) return;
+
+    const hasUrl = typeof audio.url === 'string' && (audio.url as string).length > 0;
+    const hasBase64 = typeof audio.base64 === 'string' && (audio.base64 as string).length > 0;
+    expect(
+      hasUrl !== hasBase64,
+      driver.describe('RFC 0105 §A', 'audio MUST carry EXACTLY ONE of `url` / `base64`'),
+    ).toBe(true);
+
+    expect(
+      typeof audio.mimeType === 'string' && (audio.mimeType as string).length > 0,
+      driver.describe('RFC 0105 §A', 'audio.mimeType MUST be a non-empty string'),
+    ).toBe(true);
+
+    expect(
+      audio.voiceId === VOICE_ID,
+      driver.describe('RFC 0105 §A', 'audio.voiceId MUST echo the input voiceId'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/speech-synthesis-unadvertised.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Speech-synthesis on an unadvertised host (RFC 0105 §C) — behavioral.
+ *
+ * The mirror of `speech-synthesis-roundtrip.test.ts`: a host that does NOT
+ * advertise `capabilities.aiProviders.speechSynthesis === 'supported'` MUST
+ * REJECT a `ctx.callSpeechSynthesizer` call with the canonical
+ * `speech_synthesis_unsupported` error — never a 200 success, never a silent
+ * no-op (parallel to RFC 0091's `unsupported_modality`).
+ *
+ * Gating is BY ABSENCE: the leg is active precisely when TTS is NOT advertised
+ * (`behaviorGate('openwop-speech-synthesis-unadvertised', !advertised)`), so
+ * it soft-skips on a host that DOES advertise (where the round-trip leg runs
+ * instead) / hard-fails under `OPENWOP_REQUIRE_BEHAVIOR=true` when the seam is
+ * wired but the host fails to reject. Exercised via the documented host-sample
+ * seam `POST /v1/host/sample/ai/call-speech-synthesizer` (soft-skips on 404
+ * until a host wires it).
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0105-speech-synthesis-adapter.md (§C)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const SEAM = '/v1/host/sample/ai/call-speech-synthesizer';
+
+/** Read the canonical error code from a seam response body (tolerant of
+ *  `{error}` / `{code}` / `{error:{code}}` shapes) — mirrors
+ *  `callai-multimodal.test.ts`'s `errCode`. */
+function errCode(json: unknown): string | undefined {
+  const j = json as { error?: unknown; code?: unknown };
+  if (typeof j?.code === 'string') return j.code;
+  if (typeof j?.error === 'string') return j.error;
+  const e = j?.error as { code?: unknown } | undefined;
+  if (e && typeof e.code === 'string') return e.code;
+  return undefined;
+}
+
+describe('speech-synthesis-unadvertised (RFC 0105 §C)', () => {
+  it('a host NOT advertising speechSynthesis MUST reject the call with speech_synthesis_unsupported', async () => {
+    const ai = await readCapabilityFamily<Record<string, unknown>>('aiProviders');
+    const advertised = ai?.speechSynthesis === 'supported';
+    // Active precisely when TTS is ABSENT but the seam exists.
+    if (!behaviorGate('openwop-speech-synthesis-unadvertised', !advertised)) return;
+
+    const res = await driver.post(SEAM, {
+      text: 'Welcome to the weekly digest.',
+      voiceId: 'host:narrator-test',
+    });
+    if (res.status === 404) return; // seam unwired — soft-skip
+
+    // MUST reject — never a 200 success, never a silent no-op.
+    expect(
+      res.status !== 200,
+      driver.describe('RFC 0105 §C', 'an unadvertising host MUST NOT return a 200 success (never a no-op)'),
+    ).toBe(true);
+    expect(
+      errCode(res.json) === 'speech_synthesis_unsupported',
+      driver.describe('RFC 0105 §C', 'the call MUST be rejected with `speech_synthesis_unsupported`'),
+    ).toBe(true);
+  });
+});