@openwop/openwop-conformance 1.29.0 → 1.34.0

package/schemas/registry-version-manifest.schema.json

@@ -4,10 +4,26 @@
   "title": "RegistryVersionManifest",
   "description": "Registry-augmented version manifest served at `/v1/packs/{name}/-/{version}.json`. Extends the bare pack manifest (`node-pack-manifest.schema.json`) with registry-side metadata (integrity hash, publishedAt timestamp, signed-blob URLs, lifecycle flags). This is the shape clients receive when they GET a specific pack version; the bare manifest is what publishers commit inside the tarball.\n\n**Why two schemas?** The bare manifest is the authoring contract — what a vendor writes in their pack source tree. The registry-augmented version is the SERVING contract — what `packs.openwop.dev` produces after `build-index.mjs` computes integrity hashes + adds URL templates. Validating both surfaces independently catches drift between authored content and served metadata.",
   "type": "object",
-  "required": ["name", "version", "engines", "runtime", "integrity"],
+  "required": ["name", "version", "engines", "integrity"],
   "anyOf": [
     { "properties": { "nodes": { "type": "array", "minItems": 1 } }, "required": ["nodes"] },
-    { "properties": { "agents": { "type": "array", "minItems": 1 } }, "required": ["agents"] }
+    { "properties": { "agents": { "type": "array", "minItems": 1 } }, "required": ["agents"] },
+    { "properties": { "artifactTypes": { "type": "array", "minItems": 1 } }, "required": ["artifactTypes"] },
+    { "required": ["provider"] },
+    { "properties": { "chains": { "type": "array", "minItems": 1 } }, "required": ["chains"] },
+    { "properties": { "prompts": { "type": "array", "minItems": 1 } }, "required": ["prompts"] },
+    { "properties": { "cards": { "type": "array", "minItems": 1 } }, "required": ["cards"] }
+  ],
+  "allOf": [
+    {
+      "$comment": "RFC 0107 — runtime is required for EXECUTABLE kinds (node, or kind absent) and MUST be absent for DECLARATIVE kinds (artifact-type, connection, workflow-chain, prompt, chat-card).",
+      "if": {
+        "properties": { "kind": { "enum": ["artifact-type", "connection", "workflow-chain", "prompt", "chat-card"] } },
+        "required": ["kind"]
+      },
+      "then": { "not": { "required": ["runtime"] } },
+      "else": { "required": ["runtime"] }
+    }
   ],
   "properties": {
     "name": {
@@ -40,6 +56,37 @@
       },
       "additionalProperties": { "type": "string" }
     },
+    "kind": {
+      "type": "string",
+      "enum": ["node", "artifact-type", "connection", "workflow-chain", "prompt", "chat-card"],
+      "default": "node",
+      "description": "Pack-kind discriminator (RFC 0107). ABSENT ≡ `node` (the original, executable kind — backward compatible). Executable kinds (`node`) carry `runtime` + `nodes[]`/`agents[]`. DECLARATIVE kinds carry their own payload and NO `runtime`: `artifact-type` → `artifactTypes[]` (RFC 0075); `connection` → `provider` (RFC 0095); `workflow-chain` → `chains[]` (RFC 0013); `prompt` → `prompts[]`; `chat-card` → `cards[]`. The registry's runtime-support check (registry-operations.md §Validation flow #7) is skipped for declarative kinds."
+    },
+    "artifactTypes": {
+      "type": "array",
+      "description": "Present iff `kind == \"artifact-type\"` (RFC 0075). Mirrors `artifact-type-pack-manifest.schema.json` `artifactTypes[]` (each: `artifactTypeId`, `title`, `schema`, `export[]`). Carried loosely here (the source schema is authoritative); the registry denormalizes `artifactTypes[].artifactTypeId` into the per-pack index for discovery.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "provider": {
+      "type": "object",
+      "description": "Present iff `kind == \"connection\"` (RFC 0095). Mirrors `connection-pack-manifest.schema.json` `provider` (id, category, auth, reach, …). MUST NOT carry credential material (RFC 0095 §B.2 — enforced at source; a registry SHOULD re-scan). The registry denormalizes `provider.id` into the per-pack index.",
+      "additionalProperties": true
+    },
+    "chains": {
+      "type": "array",
+      "description": "Present iff `kind == \"workflow-chain\"` (RFC 0013). Carried loosely (the source schema is authoritative); the registry denormalizes `chains[].chainId` into the per-pack index.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "prompts": {
+      "type": "array",
+      "description": "Present iff `kind == \"prompt\"`. Carried loosely; source schema authoritative.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "cards": {
+      "type": "array",
+      "description": "Present iff `kind == \"chat-card\"`. Carried loosely; source schema authoritative.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
     "runtime": {
       "type": "object",
       "required": ["language"],

package/schemas/run-event-payloads.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://openwop.dev/spec/v1/run-event-payloads.schema.json",
   "title": "RunEventPayloads",
-  "description": "Per-RunEventType payload schemas. The base RunEventDoc shape (run-event.schema.json) leaves `payload` permissive for forward-compat. This schema defines the canonical payload contract for each known RunEventType. Consumers MAY pin strict payload validation via `$defs.<typeId>` and `ajv.validate(schema.$defs[event.type], event.payload)`. Unknown event types MUST be tolerated (no $defs match → fold best-effort).\n\n100 variants from `run-event.schema.json#$defs.RunEventType` are covered, grouped into ~20 shape families with shared $defs. Naming convention: camelCase keys mirror dotted RunEventType names (e.g., `run.started` → `runStarted`).",
+  "description": "Per-RunEventType payload schemas. The base RunEventDoc shape (run-event.schema.json) leaves `payload` permissive for forward-compat. This schema defines the canonical payload contract for each known RunEventType. Consumers MAY pin strict payload validation via `$defs.<typeId>` and `ajv.validate(schema.$defs[event.type], event.payload)`. Unknown event types MUST be tolerated (no $defs match → fold best-effort).\n\n107 variants from `run-event.schema.json#$defs.RunEventType` are covered, grouped into ~20 shape families with shared $defs. Naming convention: camelCase keys mirror dotted RunEventType names (e.g., `run.started` → `runStarted`).",
   "type": "object",
   "$defs": {
     "_typeIndex": {
@@ -109,10 +109,95 @@
         "proposal.activated":        { "$ref": "#/$defs/proposalActivated" },
         "goal.evaluated":            { "$ref": "#/$defs/goalEvaluated" },
         "goal.closed":               { "$ref": "#/$defs/goalClosed" },
-        "import.applied":            { "$ref": "#/$defs/importApplied" }
+        "import.applied":            { "$ref": "#/$defs/importApplied" },
+        "voice.speech_start":        { "$ref": "#/$defs/voiceSpeechStart" },
+        "voice.transcript":          { "$ref": "#/$defs/voiceTranscript" },
+        "voice.endpoint_candidate":  { "$ref": "#/$defs/voiceEndpointCandidate" },
+        "voice.turn_commit":         { "$ref": "#/$defs/voiceTurnCommit" },
+        "voice.synthesis_chunk":     { "$ref": "#/$defs/voiceSynthesisChunk" },
+        "voice.barge_in":            { "$ref": "#/$defs/voiceBargeIn" },
+        "voice.cancelled":           { "$ref": "#/$defs/voiceCancelled" }
       }
     },
 
+    "voiceSpeechStart": {
+      "description": "RFC 0106 §D. Emitted when inbound user speech onset is detected in a live voice session. Content-free (a timestamp only). MUST NOT be emitted unless `aiProviders.realtimeVoice.transcription: \"streaming\"` is advertised.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0, "description": "Session-relative onset timestamp (ms)." }
+      }
+    },
+    "voiceTranscript": {
+      "description": "RFC 0106 §B/§D. A settled or provisional transcript part for the current turn, emitted on the durable event log as the single canonical record (the `ctx.callTranscriber` Promise resolves separately at `turn_commit`). `text` is the recognized speech — UNTRUSTED input (anyone in acoustic range is an unauthenticated writer): it MUST carry `contentTrust: \"untrusted\"` and MUST NOT be promoted to system/developer authority (SECURITY invariant `voice-transcript-untrusted`). A part with `isFinal: false` is provisional and MUST NOT be persisted to durable memory / the replay log / RAG or drive a side-effecting tool call before it finalizes (`voice-interim-not-durable`).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["text", "isFinal", "atMs", "contentTrust"],
+      "properties": {
+        "text": { "type": "string", "description": "The current hypothesis for this segment (editable tail when `isFinal:false`)." },
+        "isFinal": { "type": "boolean", "description": "true ⇒ this segment's text is settled and will not change." },
+        "committedPrefix": { "type": "string", "description": "The leading portion the host guarantees will not change (Deepgram/Web-Speech model)." },
+        "stability": { "type": "number", "minimum": 0, "maximum": 1, "description": "Graded tail confidence (Google `stability`); omit/1.0 for immutable ASR." },
+        "formatted": { "type": "boolean", "description": "Punctuation/casing/ITN applied; absent ⇒ raw." },
+        "atMs": { "type": "integer", "minimum": 0 },
+        "contentTrust": { "const": "untrusted", "description": "MUST be `\"untrusted\"` — live transcript is untrusted ingress (`voice-transcript-untrusted`); never promote to higher authority." }
+      }
+    },
+    "voiceEndpointCandidate": {
+      "description": "RFC 0106 §B/§D. A silence boundary / likely end-of-turn appeared (only when `turnDetection: \"semantic\"`), DISTINCT from `voice.turn_commit` (Deepgram `UtteranceEnd` vs `speech_final`). Content-free.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1, "description": "Optional end-of-turn confidence." }
+      }
+    },
+    "voiceTurnCommit": {
+      "description": "RFC 0106 §B/§D. The user yielded the floor (turn boundary). This is where the `ctx.callTranscriber` Promise resolves. `finalText` is the settled transcript and is UNTRUSTED (it inherits the `voice.transcript` boundary).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs", "finalText"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "finalText": { "type": "string", "description": "The settled transcript for the committed turn (untrusted input)." }
+      }
+    },
+    "voiceSynthesisChunk": {
+      "description": "RFC 0106 §C. Announces a clause-boundary streaming-synthesis chunk. METADATA ONLY — the audio bytes are referenced by a session-scoped `streamRef`/`url`, NOT inlined on the event log past the host's inline cap (RFC 0055 256 KiB precedent; spill to a tenant-scoped `url`), so replay/`:fork` stays bounded over long sessions. MUST NOT be emitted unless `aiProviders.realtimeVoice.synthesis: \"streaming\"` is advertised.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["seq", "mimeType"],
+      "properties": {
+        "seq": { "type": "integer", "minimum": 0, "description": "Monotonic chunk sequence." },
+        "mimeType": { "type": "string", "minLength": 1, "description": "Audio chunk type (e.g. `audio/mpeg`)." },
+        "durationMs": { "type": "integer", "minimum": 0, "description": "Optional chunk duration." },
+        "url": { "type": "string", "description": "Tenant-scoped, SSRF-guarded (RFC 0076) reference to the chunk bytes." },
+        "streamRef": { "type": "string", "description": "Session-scoped live-stream handle for the chunk bytes." },
+        "base64": { "type": "string", "description": "OPTIONAL inline bytes, permitted ONLY while under the host's inline cap; past the cap the host MUST use `url`/`streamRef`." },
+        "final": { "type": "boolean", "description": "true on the terminal chunk." }
+      }
+    },
+    "voiceBargeIn": {
+      "description": "RFC 0106 §D. User speech overlapped active assistant playback (probable cut-in). A host advertising `realtimeVoice.bargeIn: \"supported\"` MUST emit this on detected overlap. Content-free. Distinct from `voice.cancelled` (a backchannel \"uh-huh\" MAY produce `barge_in` with no `cancelled`).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "voiceCancelled": {
+      "description": "RFC 0106 §D. Downstream LLM/TTS work was cancelled (barge-in or explicit). A cancellation MUST NOT emit partial tool outputs or partial un-guardrailed model output and MUST roll back or fully complete an in-flight side effect (SECURITY invariant `voice-bargein-no-partial-leak`). Content-free.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "reason": { "type": "string", "enum": ["barge-in", "explicit"], "description": "Why downstream work was cancelled." }
+      }
+    },
     "authorizationDecided": {
       "description": "RFC 0049 — emitted on a role-based authorization decision (allow or deny). Redaction-safe: `principal` is an opaque RFC 0048 id; `reason` carries no credential material. Every deny SHOULD be emitted and SHOULD feed the audit log (RFC 0009/0010). MUST NOT be emitted unless `capabilities.authorization.supported: true`.",
       "type": "object",

package/schemas/run-event.schema.json

@@ -171,7 +171,14 @@
         "proposal.activated",
         "goal.evaluated",
         "goal.closed",
-        "import.applied"
+        "import.applied",
+        "voice.speech_start",
+        "voice.transcript",
+        "voice.endpoint_candidate",
+        "voice.turn_commit",
+        "voice.synthesis_chunk",
+        "voice.barge_in",
+        "voice.cancelled"
       ]
     }
   }

package/src/lib/multi-agent-capabilities.ts

@@ -1,10 +1,14 @@
 /**
  * Multi-Agent Shift capability-gating helper.
  *
- * Reads the host's `/.well-known/openwop` `capabilities.agents` block
- * + `capabilities.conversationPrimitive` flag at suite init and caches
- * them as discrete predicates. Sibling to `lib/fixtures.ts` — same
- * pattern, different surface.
+ * Reads the host's `/.well-known/openwop` `agents` block + the
+ * `conversationPrimitive` flag — both at the document ROOT (RFC 0073
+ * root-first; `setMultiAgentCapabilities` reads `body.agents` /
+ * `body.conversationPrimitive`, NOT a nested `.capabilities` object) —
+ * at suite init and caches them as discrete predicates. A host that
+ * advertises these only under a `.capabilities` wrapper resolves to
+ * `false` and its gated scenarios skip vacuously. Sibling to
+ * `lib/fixtures.ts` — same pattern, different surface.
  *
  * Why: Multi-Agent Shift scenarios (Phases 1-6) gate on per-phase
  * capability flags. Mirrors the fixture-gating pattern from RFC 0003
@@ -46,6 +50,7 @@ interface AgentCaps {
 
 let _agentCaps: AgentCaps | null = null;
 let _conversationPrimitive = false;
+let _multiPartyConversation = false;
 
 function asBoolean(value: unknown): boolean {
   return value === true;
@@ -68,6 +73,7 @@ export function setMultiAgentCapabilities(c: DiscoveryPayload | null | undefined
   if (!c || typeof c !== 'object') {
     _agentCaps = null;
     _conversationPrimitive = false;
+    _multiPartyConversation = false;
     return;
   }
 
@@ -105,6 +111,12 @@ export function setMultiAgentCapabilities(c: DiscoveryPayload | null | undefined
   }
 
   _conversationPrimitive = asBoolean((c as { conversationPrimitive?: unknown }).conversationPrimitive);
+
+  // RFC 0101 — root-first read of the `multiPartyConversation` block (sibling
+  // of `conversationPrimitive`), matching the root-first convention above.
+  const mpcRaw = (c as { multiPartyConversation?: unknown }).multiPartyConversation;
+  _multiPartyConversation =
+    !!mpcRaw && typeof mpcRaw === 'object' && asBoolean((mpcRaw as Record<string, unknown>).supported);
 }
 
 /** Phase 1 master switch. */
@@ -143,6 +155,12 @@ export function isConversationPrimitiveSupported(): boolean {
   return _conversationPrimitive;
 }
 
+/** RFC 0101 — host enforces the multi-party group-conversation roster +
+ *  speaker-attribution contract (`multiPartyConversation.supported: true`). */
+export function isMultiPartyConversationSupported(): boolean {
+  return _multiPartyConversation;
+}
+
 /** Phase 5 — host implements `core.orchestrator.supervisor` + CP-1. */
 export function isOrchestratorSupported(): boolean {
   return _agentCaps?.orchestrator === true;
@@ -162,4 +180,5 @@ export function getCachedAgentCaps(): AgentCaps | null {
 export function __resetForTests(): void {
   _agentCaps = null;
   _conversationPrimitive = false;
+  _multiPartyConversation = false;
 }

package/src/lib/multiPartyConversation.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared helpers for the RFC 0101 multi-party group-conversation behavioral
+ * scenario. Lives in lib/ (not a `*.test.ts`) so scenarios import it via
+ * `../lib/multiPartyConversation.js`.
+ *
+ * RFC 0101 standardizes the multi-party *shape* (a `participants` roster on
+ * `conversation.opened` + a REQUIRED-for-agent-turns `speakerId` + the
+ * `multiPartyConversation` capability) but mints NO normative client wire-route
+ * to *open* a conversation — opening, turn order, and round protocol are
+ * non-normative host product policy (RFC 0101 §"Non-normative product policy").
+ * A conformance driver therefore initiates a council and submits turns via the
+ * conformance-only **multi-party conversation test seam**
+ * (`POST /v1/host/sample/conversation/multi-party/{open,exchange}`,
+ * `host-sample-test-seams.md` §"Open seams") — the same `/v1/host/sample/*`
+ * convention every other capability-gated behavioral leg uses. The seam routes
+ * through the SAME roster-membership + attribution enforcement the host applies
+ * on its production conversation path; it is OPTIONAL and self-contained
+ * (it does NOT require the host to implement the full RFC 0005 conversation
+ * gate). Scenarios soft-skip on `404`/`405`.
+ *
+ * @see RFCS/0101-multi-party-group-conversation.md (§Spec / §Conformance)
+ * @see spec/v1/host-sample-test-seams.md (multi-party conversation seam)
+ * @see RFCS/0005-conversation.md §E (turn-validation rejection — validation_error)
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** A slim AgentRef the seam accepts in a participant roster (mirror of
+ *  `agent-ref.schema.json`; only `agentId` is load-bearing for membership). */
+export interface SeamAgentRef {
+  agentId: string;
+  name?: string;
+}
+
+/** A conversation turn as the seam accepts it (subset of
+ *  `conversation-turn.schema.json` + the RFC 0101 `speakerId`). */
+export interface SeamTurn {
+  messageId: string;
+  from: string;
+  content: string;
+  ts: number;
+  role: 'user' | 'agent' | 'system';
+  turnIndex: number;
+  speakerId?: string;
+  [k: string]: unknown;
+}
+
+export interface MultiPartyConversationCap {
+  supported?: boolean;
+  maxParticipants?: number;
+  [k: string]: unknown;
+}
+
+/** Reads the root-first `multiPartyConversation` capability block from
+ *  discovery (RFC 0073 root-first); null when unadvertised. */
+export async function readMultiPartyCap(): Promise<MultiPartyConversationCap | null> {
+  const mpc = await readCapabilityFamily<MultiPartyConversationCap>('multiPartyConversation');
+  return mpc && typeof mpc === 'object' ? mpc : null;
+}
+
+export interface SeamResult {
+  /** HTTP status. `0` when the seam is unwired (404/405 → soft-skip sentinel). */
+  status: number;
+  /** Decoded JSON body, when present. */
+  body: Record<string, unknown> | undefined;
+  /** True when the seam is absent (404/405) — caller soft-skips. */
+  unwired: boolean;
+}
+
+function toResult(res: { status: number; json: unknown }): SeamResult {
+  const unwired = res.status === 404 || res.status === 405;
+  return {
+    status: res.status,
+    body: res.json && typeof res.json === 'object' ? (res.json as Record<string, unknown>) : undefined,
+    unwired,
+  };
+}
+
+/** Open a multi-party council via the conformance seam. Returns `unwired:true`
+ *  on 404/405 so the scenario soft-skips. NOTE: a `validation_error` rejection
+ *  (e.g. roster exceeds maxParticipants) is a REAL 400/422 result, NOT unwired —
+ *  only 404/405 mean the seam is absent. */
+export async function openMultiPartyConversation(body: {
+  conversationId: string;
+  participants: SeamAgentRef[];
+  maxParticipants?: number;
+}): Promise<SeamResult> {
+  const res = await driver.post('/v1/host/sample/conversation/multi-party/open', body);
+  return toResult(res);
+}
+
+/** Submit one turn to an open council via the conformance seam. */
+export async function exchangeMultiPartyTurn(body: {
+  conversationId: string;
+  turn: SeamTurn;
+}): Promise<SeamResult> {
+  const res = await driver.post('/v1/host/sample/conversation/multi-party/exchange', body);
+  return toResult(res);
+}
+
+/** The canonical `error.code` an RFC 0101 rejection carries (RFC 0005 §E).
+ *  Tolerant of both `{ error: { code } }` and `{ error: '<code>' }` shapes. */
+export function errorCodeOf(body: Record<string, unknown> | undefined): string | undefined {
+  if (!body) return undefined;
+  const err = body.error;
+  if (typeof err === 'string') return err;
+  if (err && typeof err === 'object') {
+    const code = (err as Record<string, unknown>).code;
+    if (typeof code === 'string') return code;
+  }
+  const code = body.code;
+  return typeof code === 'string' ? code : undefined;
+}
+
+/** A rejection is RFC-0101-conformant when the status is a client error
+ *  (`400`/`422` — RFC 0005 §E pins the code, not the status) AND the body
+ *  carries `error.code === 'validation_error'`. */
+export function isValidationErrorRejection(r: SeamResult): boolean {
+  const clientError = r.status === 400 || r.status === 422;
+  return clientError && errorCodeOf(r.body) === 'validation_error';
+}

package/src/scenarios/aiproviders-realtimevoice-shape.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Real-time voice capability advertisement shape (RFC 0106 §A) — server-free.
+ *
+ * Always-on schema-shape probe for the RFC 0106 real-time voice profile. Verifies that:
+ *   - `capabilities.aiProviders.realtimeVoice` is an OBJECT sibling of `speechSynthesis`/
+ *     `input` in the `aiProviders` block, with the sub-flags `transcription`
+ *     (const `"streaming"`), `synthesis` (const `"streaming"`), `turnDetection`
+ *     (enum `vad|semantic`), and `bargeIn` (const `"supported"`).
+ *   - `realtimeVoice` is NOT in `aiProviders.required`: absence is the default (a host
+ *     WITHOUT live voice is a valid discovery doc).
+ *   - the §A closures hold via Ajv2020: `turnDetection`/`bargeIn` imply `transcription`
+ *     (`dependentRequired`), and `realtimeVoice.synthesis` implies
+ *     `aiProviders.speechSynthesis` (the if/then on the `aiProviders` block).
+ *
+ * Behavioral assertions (the live `ctx.callTranscriber` Promise-resolves-at-turn_commit
+ * + `voice.*` emission; the unadvertised-host reject; the streaming synthesis arm) are
+ * gated on `aiProviders.realtimeVoice.{transcription,synthesis}` and live in the gated
+ * `voice-transcription-streaming.test.ts` / `voice-transcription-unadvertised.test.ts` /
+ * `voice-synthesis-streaming.test.ts` scenarios. This scenario asserts the wire contract,
+ * not host behavior.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0106-realtime-voice-session-profile.md (§A, §B)
+ */
+
+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>;
+}
+
+function aiProvidersSchema(): Record<string, unknown> {
+  const caps = loadSchema('capabilities.schema.json');
+  return (caps.properties as Record<string, Record<string, unknown>>).aiProviders;
+}
+
+describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §A, server-free)', () => {
+  it('aiProviders.realtimeVoice is an object with the four sub-flags', () => {
+    const realtimeVoice = (aiProvidersSchema().properties as Record<string, { type?: unknown; properties?: Record<string, unknown> }>)
+      .realtimeVoice;
+    expect(
+      realtimeVoice,
+      why('host-capabilities.md §host.aiProviders', 'aiProviders.realtimeVoice MUST be declared'),
+    ).toBeDefined();
+    expect(realtimeVoice?.type, why('RFC 0106 §A', 'realtimeVoice MUST be an object')).toBe('object');
+    const props = realtimeVoice?.properties ?? {};
+    for (const flag of ['transcription', 'synthesis', 'turnDetection', 'bargeIn']) {
+      expect(
+        Object.prototype.hasOwnProperty.call(props, flag),
+        why('RFC 0106 §A', `realtimeVoice.${flag} MUST be declared`),
+      ).toBe(true);
+    }
+  });
+
+  it('realtimeVoice is NOT in aiProviders.required — absence (no live voice) is a valid default', () => {
+    const aiProviders = aiProvidersSchema() as { required?: unknown };
+    const required = Array.isArray(aiProviders.required) ? (aiProviders.required as string[]) : [];
+    expect(
+      required.includes('realtimeVoice'),
+      why('RFC 0106 §A', 'aiProviders.realtimeVoice MUST be optional (a host without live voice is valid)'),
+    ).toBe(false);
+  });
+
+  it('Ajv: the realtimeVoice subschema accepts the floor and enforces the turnDetection/bargeIn ⇒ transcription closure', () => {
+    const realtimeVoice = (aiProvidersSchema().properties as Record<string, Record<string, unknown>>).realtimeVoice;
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(realtimeVoice);
+
+    expect(
+      validate({ transcription: 'streaming', turnDetection: 'semantic', bargeIn: 'supported' }),
+      why('RFC 0106 §A', 'a full transcription advertisement MUST validate'),
+    ).toBe(true);
+    expect(validate({}), why('RFC 0106 §A', 'an empty realtimeVoice object MUST validate')).toBe(true);
+    expect(
+      validate({ turnDetection: 'semantic' }),
+      why('RFC 0106 §A', 'turnDetection without transcription MUST be rejected (dependentRequired)'),
+    ).toBe(false);
+    expect(
+      validate({ bargeIn: 'supported' }),
+      why('RFC 0106 §A', 'bargeIn without transcription MUST be rejected (dependentRequired)'),
+    ).toBe(false);
+    expect(
+      validate({ transcription: 'streaming', turnDetection: 'aggressive' }),
+      why('RFC 0106 §A', 'an out-of-enum turnDetection MUST be rejected'),
+    ).toBe(false);
+    expect(
+      validate({ transcription: true }),
+      why('RFC 0106 §A', 'transcription MUST be the string const "streaming", not a boolean'),
+    ).toBe(false);
+  });
+
+  it('Ajv: the aiProviders subschema enforces realtimeVoice.synthesis ⇒ speechSynthesis', () => {
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(aiProvidersSchema());
+
+    expect(
+      validate({ realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
+      why('RFC 0106 §A', 'streaming synthesis without speechSynthesis: "supported" MUST be rejected'),
+    ).toBe(false);
+    expect(
+      validate({ speechSynthesis: 'supported', realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
+      why('RFC 0106 §A', 'streaming synthesis WITH speechSynthesis: "supported" MUST validate'),
+    ).toBe(true);
+    expect(
+      validate({ realtimeVoice: { transcription: 'streaming' } }),
+      why('RFC 0106 §A', 'transcription-only (no synthesis) MUST validate without speechSynthesis'),
+    ).toBe(true);
+  });
+});

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