@openwop/openwop-conformance 1.68.1 → 1.70.2

package/fixtures/conformance-agent-pack-handoff-schema-validation.json

@@ -2,7 +2,7 @@
   "id": "conformance-agent-pack-handoff-schema-validation",
   "name": "Conformance: Agent Pack Handoff Schema Validation",
   "version": "1.0",
-  "description": "Phase 2 / HV-1. The fixture itself is a no-op workflow — the scenario verifies host behavior at the agent-dispatch surface for `core.openwop.agent-examples.structured-fixture` (the canonical handoff-schema fixture agent). The agent's manifest carries `handoff.taskSchemaRef` + `handoff.returnSchemaRef`; the host MUST validate dispatch payloads against the task schema (RFC 0003 §D) BEFORE invoking the agent, and return payloads against the return schema BEFORE persistence. The test drives the dispatch surface directly with three scenario branches (valid-task / invalid-task / mock-return-violation) per agentPackHandoffSchemaValidation.test.ts.",
+  "description": "Phase 2 / HV-1. A real workflow whose `metadata.requiresAgentId` binds `core.openwop.agent-examples.structured-fixture` (the canonical handoff-schema fixture agent, whose manifest carries `handoff.taskSchemaRef` + `handoff.returnSchemaRef`). The workflow executor fires the handoff gate off that binding BEFORE any node runs (RFC 0003 §D), so the single `core.identity` node is deliberately trivial — the gate, not the node, is under test. The host MUST validate run inputs against the task schema before dispatch and the agent's return against the return schema before persistence. Driven by plain `POST /v1/runs { workflowId, inputs }` with three branches (valid task → completed; invalid task → `handoff_task_schema_violation`; `scenario: mock-return-violation` → `handoff_return_schema_violation`) per agentPackHandoffSchemaValidation.test.ts.",
   "nodes": [
     {
       "id": "noop",
@@ -24,7 +24,7 @@
     "tags": ["conformance", "multi-agent", "phase-2", "handoff-validation"],
     "requiresInstalledPack": "core.openwop.agent-examples",
     "requiresAgentId": "core.openwop.agent-examples.structured-fixture",
-    "notes": "Test invokes the agent-dispatch surface directly with three scenarios per inputs.scenario; the workflow is a noop placeholder so it validates against workflow-definition.schema.json without requiring a dispatch typeId not yet in the in-tree node catalog."
+    "notes": "The gate is a no-op unless the host RESOLVES `requiresAgentId` off its agent registry with compiled handoff validators — i.e. `core.openwop.agent-examples` must be MOUNTED. A host that cannot resolve the agent MUST NOT advertise this fixture (the scenario skips on `isFixtureAdvertised`); a host that mounts the pack but does not advertise `agents.manifestRuntime.handoffValidation` runs HV-1a only (HV-1b/1c gate on that capability). The `core.identity` node is deliberately trivial: the gate fires pre-node off `requiresAgentId`, NOT off any dispatch typeId."
   },
   "settings": { "timeout": 5000 }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "1.68.1",
+  "version": "1.70.2",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",

package/schemas/capabilities.schema.json

@@ -1773,6 +1773,67 @@
         }
       }
     },
+    "artifactTypes": {
+      "type": "object",
+      "description": "RFC 0071, amended by RFC 0075; declared by RFC 0144. Host artifact-type surface — an advertisement (no `ctx.artifactTypes.*` method) that changes how the host treats the artifact references already on the wire (`nodes[].artifact.typeId`, `WorkflowNode.artifactType`, `artifact.created.artifactType`). Carries the corpus's only emission MUST: a host advertising `store: true` MUST persist registered artifacts and emit `artifact.created`. See `host-capabilities.md` §host.artifactTypes and `artifact-type-packs.md` §\"Host capability\". The discovery key is the PLAIN family name at the document root (RFC 0137 G16); `host.artifactTypes` is the capability IDENTIFIER used in pack `peerDependencies`, not this key.",
+      "additionalProperties": false,
+      "properties": {
+        "supported": { "type": "boolean", "description": "Host honors registered artifact types — validates an artifact whose type is registered (pack-installed or host-native) against that type's schema before emitting `artifact.created`, setting `registered: true` + `registrationSource`. Unregistered types stay accepted unvalidated with `registered: false`." },
+        "store": { "type": "boolean", "description": "`true` ⇒ the host persists artifacts of registered types AND emits `artifact.created`. Advertising this is a commitment to emit; RFC 0142 leg B is the witness." },
+        "render": { "type": "boolean", "description": "Advisory — the spec defines no rendering surface. A host advertising `false` for a type it can `store` MUST still accept and store the artifact and MUST NOT fail the run for lack of a renderer (the store-without-render negotiation guarantee)." },
+        "export": { "type": "array", "items": { "type": "string" }, "description": "Export-format identifiers the host can materialize, drawn from declared `exportFormats`. Advisory." },
+        "types": {
+          "type": "object",
+          "description": "RFC 0075 per-type facets, keyed by `artifactTypeId`. Each entry overrides the global object for that type; the global object is the fallback for any type not listed (absent ⇒ host-global semantics; any facet absent ⇒ the global default — additive).",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "validated": { "type": "boolean", "description": "The runtime validation guarantee — `true` ⇒ the host validates this type before emit, so emits `registered: true`. Decoupled from `schemaVersions`, which is a version DECLARATION only." },
+              "validation": { "type": "string", "enum": ["open", "closed"], "description": "Mirrors `ArtifactType.validation`, surfacing schema strictness in discovery so a consumer needn't fetch the schema. Default `\"open\"` per `COMPATIBILITY.md` §2.1." },
+              "schemaVersion": { "type": "integer", "minimum": 0 },
+              "registrationSource": { "type": "string", "enum": ["pack", "host"], "description": "RFC 0145. Provenance of this registered type: `pack` (an installed artifact-type pack backs it) or `host` (host-native, validated against a host-known schema with no pack). Mirrors `artifact.created.registrationSource` and MUST match what the host would emit for this type — the two surfaces MUST NOT disagree. OPTIONAL; absent ⇒ unspecified provenance, NOT a default of `pack`. Discloses which §\"Schema distribution\" regime applies: serving the canonical schema URL is a MUST for host-registered (no-pack) types and only a SHOULD for pack-backed ones, and nothing else in the advert reveals which. A host MUST NOT infer this from the identifier's shape — `vendor.*` is a registry namespace, not an installation claim." },
+              "store": { "type": "boolean" },
+              "render": { "type": "boolean" },
+              "export": { "type": "array", "items": { "type": "string" } }
+            }
+          }
+        }
+      }
+    },
+    "forms": {
+      "type": "object",
+      "description": "RFC 0137; declared by RFC 0144. Host form-content-pack surface — like `artifactTypes` it adds no `ctx.forms.*` method; it advertises that the host resolves registered form templates from installed `kind: \"form-content\"` packs and instantiates them through its own normal create path. See `host-capabilities.md` §host.forms and `form-content-packs.md`. The discovery key is the PLAIN family name at the document root (RFC 0137 G16); a host may additionally carry a deprecated dotted `\"host.forms\"` mirror during migration — root `additionalProperties` stays `true` so that document remains valid.",
+      "additionalProperties": false,
+      "properties": {
+        "contentPacks": { "type": "boolean", "description": "`true` ⇒ the host instantiates registered form templates. Normative consequences (`form-content-packs.md` §\"Instantiation\"): create through the SAME path a hand-authored form uses; degrade an unrecognized field type to a plain text input rather than failing; keep the instantiated form fully editable; execute nothing from the pack; sanitize/validate/authorize submissions exactly as hand-typed input. Pack-authored strings are UNTRUSTED and MUST propagate `meta.contentTrust: \"untrusted\"` into interpolated prompt segments (invariant `form-content-pack-string-trust-boundary`) — a signature proves authorship, not content safety." }
+      }
+    },
+    "aiEnvelope": {
+      "type": "object",
+      "description": "Declared by RFC 0144. Host typed-envelope generation surface (`ctx.aiEnvelope.generate`), routing the call through the host's BYOK provider layer. Opinionated about envelope shape, unlike the lower-level `aiProviders` capability which returns raw model output. See `host-capabilities.md` §host.aiEnvelope and `ai-envelope.md`.",
+      "additionalProperties": false,
+      "properties": {
+        "supported": { "type": "boolean", "description": "`true` ⇒ `ctx.aiEnvelope.generate` is exposed. Absent/`false` ⇒ packs binding this surface fail with `host_capability_missing`." },
+        "await": { "type": "boolean", "description": "`true` ⇒ `ctx.aiEnvelope.await` is ALSO exposed. `generate` is required whenever the family is advertised; `await` is required only when this sub-flag is." }
+      }
+    },
+    "promptLibrary": {
+      "type": "object",
+      "description": "Declared by RFC 0144. Host prompt-lookup surface (`ctx.promptLibrary.get`), returning a prompt pinned to a specific version so replay stays deterministic. Consumed by `core.ai.callPrompt`. See `host-capabilities.md` §host.promptLibrary.",
+      "additionalProperties": false,
+      "properties": {
+        "supported": { "type": "boolean", "description": "`true` ⇒ `ctx.promptLibrary.get(promptId)` resolves a `{ promptId, systemPrompt, version, envelopeType? }` record. The returned `version` MUST pin the prompt text for replay." }
+      }
+    },
+    "agentRuntime": {
+      "type": "object",
+      "description": "Declared by RFC 0144. The heavyweight swarm/consensus SUPERSET of the agent surface — spawn, delegate, consensus, message-send, skill-invoke, swarm-execute over RFC 0002/0003/0007 primitives. Advertising it IMPLIES `agents.manifestRuntime` (RFC 0070 §B), since `spawn({ manifestId })` instantiates a manifest agent; hosts needing only single-agent or crew dispatch advertise that floor and omit this family. Per-tool authorization, rate limiting, and the content-free tool-call audit trail live in the top-level `toolHooks` block, NOT under this family. See `host-capabilities.md` §host.agentRuntime.",
+      "additionalProperties": false,
+      "properties": {
+        "supported": { "type": "boolean", "description": "`true` ⇒ `ctx.agentRuntime.*` is exposed AND `agents.manifestRuntime` is implied (RFC 0070 §B). A multi-tenant host additionally advertises `agents.manifestRuntime.installScope: 'tenant'` (RFC 0074) so `GET /v1/agents` scopes to the caller's owner triple." }
+      }
+    },
     "deadLetter": {
       "type": "object",
       "description": "RFC 0053 (`Draft`). Run-level dead-letter sink for terminally-failed runs/nodes. On retry exhaustion (RFC 0009), the run is routed to a durable, inspectable sink and a `run.dead_lettered` event is emitted; dead-lettered runs remain fork-eligible (RFC 0011) for the retention window. Distinct from `queueBus.deadLetterSupported`, which dead-letters transport *messages*, not *runs*.",

package/schemas/workflow-definition.schema.json

@@ -284,6 +284,11 @@
           "type": "boolean",
           "default": false,
           "description": "When true, the engine masks this variable's value in persisted `variable.changed` events, `state.snapshot` projections, and `RunSnapshot.variables`. Reads inside NodeModule executors work normally; only persistence + external surfaces mask. See observability.md §Privacy classification (closes O5)."
+        },
+        "format": {
+          "type": "string",
+          "minLength": 1,
+          "description": "RFC 0136 (`Active`). ADVISORY presentational hint for a `type: \"string\"` variable, drawn from the JSON-Schema format vocabulary (`email`, `uri`, `date`, `date-time`, `time`, `duration` are the v1 recognised set). Hosts SHOULD use it to choose an input affordance (e.g. an email keyboard). It is NOT a validation contract: a host MUST NOT reject a run, refuse a variable write, or fail validation because a value does not match, and MUST NOT assume a value matches when reading it. DELIBERATELY NOT AN ENUM — an unrecognised value MUST round-trip and degrade to plain text rather than error (RFC 0136 requirement 2), which an enum would turn into a hard validation failure on a client-submitted (closed) shape. Ignored when `type` is not `\"string\"`. Orthogonal to `sensitive`: masking hides the VALUE on server-emitted surfaces, `format` describes the FIELD in the definition, so the two compose with no interaction."
         }
       },
       "additionalProperties": false

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

@@ -37,6 +37,13 @@ interface AgentCaps {
   memoryBackends: ReadonlySet<string>;
   orchestrator: boolean;
   dispatch: boolean;
+  /** RFC 0070 §B / RFC 0003 §D. `agents.manifestRuntime.handoffValidation`:
+   *  the host validates inbound task payloads against `handoff.taskSchemaRef`
+   *  before dispatch and outbound results against `handoff.returnSchemaRef`
+   *  before persistence. When false/absent, manifests carrying handoff
+   *  schemas are dispatched with OPAQUE payloads by design — so a scenario
+   *  asserting a rejection MUST gate on this, not on coarse `supported`. */
+  handoffValidation: boolean;
   reasoning:
     | {
         verbosity: 'summary' | 'full' | 'off' | undefined;
@@ -104,6 +111,15 @@ export function setMultiAgentCapabilities(c: DiscoveryPayload | null | undefined
       memoryBackends: asStringSet(a.memoryBackends),
       orchestrator: asBoolean(a.orchestrator),
       dispatch: asBoolean(a.dispatch),
+      // RFC 0070 §B — nested read of `agents.manifestRuntime.handoffValidation`
+      // (default false per capabilities.schema.json). A host advertising
+      // `agents.supported: true` may still dispatch opaque payloads unless this
+      // is true; keeping it distinct from `supported` is what lets HV-1b/1c gate
+      // honestly instead of reddening a conformant opaque-dispatch host.
+      handoffValidation: (() => {
+        const mr = a.manifestRuntime;
+        return !!mr && typeof mr === 'object' && asBoolean((mr as Record<string, unknown>).handoffValidation);
+      })(),
       reasoning,
     };
   } else {
@@ -171,6 +187,18 @@ export function isDispatchSupported(): boolean {
   return _agentCaps?.dispatch === true;
 }
 
+/** RFC 0070 §B / RFC 0003 §D — host validates handoff task/return payloads
+ *  against the manifest's `handoff.*SchemaRef` (`agents.manifestRuntime
+ *  .handoffValidation: true`). A host without this dispatches opaque payloads
+ *  by design, so the HV-1b/HV-1c rejection legs MUST gate on it — asserting a
+ *  rejection against an opaque-dispatch host is a false red (the conformance-tier
+ *  form of "a normative claim asserted without gating on the capability that
+ *  declares its enforcement surface"). HV-1a (valid → completes) does NOT gate
+ *  on it: a valid payload completes whether or not validation runs. */
+export function hasHandoffValidation(): boolean {
+  return _agentCaps?.handoffValidation === true;
+}
+
 /** Diagnostic — returns the cached state or `null` if not yet set. */
 export function getCachedAgentCaps(): AgentCaps | null {
   return _agentCaps;

package/src/scenarios/agentPackHandoffSchemaValidation.test.ts

@@ -13,134 +13,143 @@
  * persistence and surface a structured error rather than silently storing
  * an off-contract result.
  *
- * Capability-gated: skips when host doesn't advertise
- * `capabilities.agents.supported: true` AND `capabilities.agents.dispatch: true`.
- * Fixture-gated: requires `conformance-agent-pack-handoff-schema-validation`.
+ * All three legs drive the WORKFLOW EXECUTOR via plain `POST /v1/runs`: the
+ * gate fires off `definition.metadata.requiresAgentId` naming an agent that
+ * declares `handoff.*SchemaRef`, BEFORE any node runs (the node is a trivial
+ * no-op; the gate is what's under test). The fixture references the existing
+ * `core.openwop.agent-examples.structured-fixture` agent — task schema
+ * `required: [text, extractionFields]`, return schema a success-XOR-error
+ * `oneOf` — so no schema authoring is needed suite-side; the host resolves the
+ * pack and compiles the validators at pack-load.
+ *
+ * Gating (two independent conditions, both necessary):
+ *   1. `isAgentSupported()` + `isFixtureAdvertised(FIXTURE)` — the host claims
+ *      the agent surface AND advertises this fixture. A host that does not mount
+ *      `core.openwop.agent-examples` cannot resolve the agent, so the gate would
+ *      no-op (ok:true) and the run would complete regardless — such a host MUST
+ *      NOT advertise the fixture, and the whole block skips cleanly.
+ *   2. HV-1b / HV-1c additionally gate on `hasHandoffValidation()`
+ *      (`agents.manifestRuntime.handoffValidation: true`). A host advertising
+ *      `agents.supported: true` but NOT `handoffValidation` dispatches opaque
+ *      payloads BY DESIGN (capabilities.schema.json §manifestRuntime) — asserting
+ *      a rejection there is a false red, the conformance-tier form of "a
+ *      normative claim asserted without gating on the capability that declares
+ *      its enforcement surface." HV-1a (valid → completes) does NOT gate on it.
+ *
+ * Non-vacuity: HV-1a asserts the valid payload is NOT rejected; HV-1b is the
+ * paired sabotage (same inputs minus the required `extractionFields` → the run
+ * MUST flip to `failed` with `handoff_task_schema_violation`). If HV-1b did not
+ * red on that removal, the gate is not firing and HV-1a is vacuous — so the two
+ * legs together prove the gate runs, not just that a no-op completed.
  *
  * @see RFCS/0003-agent-packs.md §D
  * @see schemas/agent-manifest.schema.json #/properties/handoff
- * @see packs/core.openwop.agent-examples/agents[structured-fixture]
+ * @see schemas/capabilities.schema.json #/properties/agents/properties/manifestRuntime
  */
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
-import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
+import { isAgentSupported, hasHandoffValidation } from '../lib/multi-agent-capabilities.js';
 
 const FIXTURE = 'conformance-agent-pack-handoff-schema-validation';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
 
+/** Poll a run to a terminal status (or timeout). */
+async function settle(runId: string, terminal = ['completed', 'failed', 'waiting-approval']): Promise<{ status: string } | undefined> {
+  for (let i = 0; i < 40; i++) {
+    const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
+    const body = res.json as { status: string };
+    if (terminal.includes(body.status)) return body;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return undefined;
+}
+
 describe.skipIf(SKIP)('agentPackHandoffSchemaValidation: handoff schema enforcement at dispatch', () => {
-  it('valid task payload that matches taskSchemaRef is dispatched and completes', async () => {
-    // The fixture workflow dispatches `core.openwop.agent-examples.structured-fixture`
-    // with a VALID task payload matching schemas/structured-fixture.task.schema.json
-    // (`{ text: string, extractionFields: string[], language?: string }`).
+  it('HV-1a: valid task payload that matches taskSchemaRef is dispatched and completes', async () => {
+    // Valid inputs for `structured-fixture` task schema (required: text,
+    // extractionFields). No `scenario` key → the gate takes the task probe,
+    // `validateTask(inputs)` passes, the gate is ok, the no-op node runs.
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE,
       inputs: {
-        scenario: 'valid-task',
-        text: 'Acme Corp invoiced $1,200 on 2026-04-15 for Q2 consulting.',
-        extractionFields: ['vendor', 'amount', 'date'],
+        text: 'Invoice 42 from Acme, total $1200',
+        extractionFields: ['vendor', 'total'],
       },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
-    let snap: { status: string } | undefined;
-    for (let i = 0; i < 40; i++) {
-      const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
-      const body = res.json as { status: string };
-      if (['completed', 'failed', 'waiting-approval'].includes(body.status)) {
-        snap = body;
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 100));
-    }
+    const snap = await settle(runId);
     expect(snap?.status, 'HV-1a: valid task payload should NOT be rejected by handoff-schema validation').toBe('completed');
   });
 
-  it('invalid task payload (missing required field) is rejected before dispatch with structured error', async () => {
-    const create = await driver.post('/v1/runs', {
-      workflowId: FIXTURE,
-      inputs: {
-        scenario: 'invalid-task',
-        // intentionally missing required `extractionFields`
-        text: 'Some input text',
-      },
-    });
-    expect(create.status).toBe(201);
-    const runId = (create.json as { runId: string }).runId;
-
-    let snap: { status: string } | undefined;
-    for (let i = 0; i < 40; i++) {
-      const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
-      const body = res.json as { status: string };
-      if (['completed', 'failed'].includes(body.status)) {
-        snap = body;
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 100));
-    }
-    expect(snap?.status, 'HV-1b: invalid task payload MUST cause the run to fail rather than silently dispatch off-contract').toBe('failed');
+  // HV-1b / HV-1c assert a REJECTION, which only a host performing handoff
+  // validation can produce — gate on the capability that declares that behavior.
+  describe.skipIf(!hasHandoffValidation())('rejection legs (agents.manifestRuntime.handoffValidation)', () => {
+    it('HV-1b: invalid task payload (missing required field) fails before dispatch with a structured violation', async () => {
+      // HV-1a's inputs minus the required `extractionFields` — the paired
+      // sabotage. `validateTask` fails `required` → the run MUST fail.
+      const create = await driver.post('/v1/runs', {
+        workflowId: FIXTURE,
+        inputs: { text: 'Invoice 42' },
+      });
+      expect(create.status).toBe(201);
+      const runId = (create.json as { runId: string }).runId;
 
-    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
-    const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> })
-      .events ?? [];
+      const snap = await settle(runId, ['completed', 'failed']);
+      expect(
+        snap?.status,
+        'HV-1b: invalid task payload MUST cause the run to fail rather than silently dispatch off-contract',
+      ).toBe('failed');
 
-    const validationFailure = list.find(
-      (e) =>
-        e.type === 'node.failed' &&
-        typeof e.payload?.error === 'object' &&
-        ((e.payload?.error as Record<string, unknown>)?.code === 'handoff_task_schema_violation' ||
-          (e.payload?.error as Record<string, unknown>)?.code === 'agent_dispatch_validation_failed'),
-    );
-    expect(
-      validationFailure,
-      'HV-1b: failure event payload MUST carry a recognizable handoff-validation error code',
-    ).toBeDefined();
-  });
-
-  it('agent return payload that fails returnSchemaRef is rejected before persistence', async () => {
-    // The fixture's `mock-return-violation` scenario causes the agent runtime
-    // to emit a return payload that violates schemas/structured-fixture.return.schema.json
-    // (e.g., omits the required `extracted` field while not declaring `error`).
-    const create = await driver.post('/v1/runs', {
-      workflowId: FIXTURE,
-      inputs: { scenario: 'mock-return-violation' },
+      const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+      const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> }).events ?? [];
+      const validationFailure = list.find(
+        (e) =>
+          e.type === 'node.failed' &&
+          typeof e.payload?.error === 'object' &&
+          ((e.payload?.error as Record<string, unknown>)?.code === 'handoff_task_schema_violation' ||
+            (e.payload?.error as Record<string, unknown>)?.code === 'agent_dispatch_validation_failed'),
+      );
+      expect(
+        validationFailure,
+        'HV-1b: failure event payload MUST carry a recognizable handoff-validation error code',
+      ).toBeDefined();
     });
-    expect(create.status).toBe(201);
-    const runId = (create.json as { runId: string }).runId;
 
-    let snap: { status: string } | undefined;
-    for (let i = 0; i < 40; i++) {
-      const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}`);
-      const body = res.json as { status: string };
-      if (['completed', 'failed'].includes(body.status)) {
-        snap = body;
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 100));
-    }
-    // Hosts MAY surface return-schema violations as either a failed run OR a
-    // run that completes with a flagged error envelope, but the persisted
-    // result MUST NOT carry an off-schema body. Tolerate both outcomes here;
-    // the strict assertion is that downstream readers can detect the violation.
-    expect(['completed', 'failed']).toContain(snap?.status);
+    it('HV-1c: agent return payload that fails returnSchemaRef surfaces a structured violation before persistence', async () => {
+      // `scenario: 'mock-return-violation'` routes to the return probe, which
+      // validates `{}` against the return schema's success-XOR-error `oneOf`
+      // (satisfies neither branch) → a return-schema violation.
+      const create = await driver.post('/v1/runs', {
+        workflowId: FIXTURE,
+        inputs: { scenario: 'mock-return-violation', text: 'x', extractionFields: ['a'] },
+      });
+      expect(create.status).toBe(201);
+      const runId = (create.json as { runId: string }).runId;
 
-    const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
-    const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> })
-      .events ?? [];
+      const snap = await settle(runId, ['completed', 'failed']);
+      // Hosts MAY surface return-schema violations as a failed run OR a run that
+      // completes with a flagged error envelope, but the persisted result MUST
+      // NOT carry an off-schema body. Tolerate both; the strict assertion is that
+      // downstream readers can detect the violation.
+      expect(['completed', 'failed']).toContain(snap?.status);
 
-    const returnViolation = list.find(
-      (e) =>
-        (e.type === 'node.failed' || e.type === 'agent.error') &&
-        typeof e.payload?.error === 'object' &&
-        ((e.payload?.error as Record<string, unknown>)?.code === 'handoff_return_schema_violation' ||
-          (e.payload?.error as Record<string, unknown>)?.code === 'agent_return_validation_failed'),
-    );
-    expect(
-      returnViolation,
-      'HV-1c: off-schema return payload MUST surface a structured violation event before persistence',
-    ).toBeDefined();
+      const events = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events`);
+      const list = (events.json as { events?: Array<{ type: string; payload?: Record<string, unknown> }> }).events ?? [];
+      const returnViolation = list.find(
+        (e) =>
+          (e.type === 'node.failed' || e.type === 'agent.error') &&
+          typeof e.payload?.error === 'object' &&
+          ((e.payload?.error as Record<string, unknown>)?.code === 'handoff_return_schema_violation' ||
+            (e.payload?.error as Record<string, unknown>)?.code === 'agent_return_validation_failed'),
+      );
+      expect(
+        returnViolation,
+        'HV-1c: off-schema return payload MUST surface a structured violation event before persistence',
+      ).toBeDefined();
+    });
   });
 });

package/src/scenarios/artifact-type-registration-source.test.ts

@@ -0,0 +1,133 @@
+/**
+ * `registrationSource` as a per-type artifact capability facet (RFC 0145).
+ *
+ * Always-on corpus legs only. The facet discloses which §"Schema distribution" regime a
+ * registered artifact type falls under: serving the canonical schema URL is a MUST for
+ * host-registered (no-pack) types and only a SHOULD for pack-backed ones, so the two carry
+ * different resolution guarantees — and before this RFC nothing in discovery said which.
+ *
+ * WHY THE ENUM IS LOAD-BEARING HERE, UNLIKE RFC 0136's `format`. `format` is deliberately
+ * NOT an enum: it is an advisory hint on a client-submitted closed shape, so an
+ * unrecognised value must degrade to plain text rather than fail a POST. `registrationSource`
+ * is the opposite on both axes — it has exactly two meanings, it appears on a SERVER-emitted
+ * discovery document, and a third value is not a hint to ignore but a host claiming a
+ * provenance the protocol does not define. Leg A2 pins that asymmetry.
+ *
+ * NOT BUILT (carried as RFC 0145 G1): a leg asserting a host's advertised
+ * `registrationSource` matches what it emits on `artifact.created` (requirement 3). It needs
+ * a host that advertises the facet AND emits a matching artifact; against a host advertising
+ * nothing it would be vacuously green, which is the failure mode this suite keeps finding.
+ *
+ * @see schemas/capabilities.schema.json §artifactTypes.types
+ * @see spec/v1/artifact-type-packs.md §"Per-type facets" + §"Schema distribution"
+ * @see RFCS/0145-registration-source-per-type-facet.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}`;
+const CAPS = join(SCHEMAS_DIR, 'capabilities.schema.json');
+const EVENT_PAYLOADS = join(SCHEMAS_DIR, 'run-event-payloads.schema.json');
+const readDoc = (name: string): string => (V1_DIR ? readFileSync(join(V1_DIR, name), 'utf8') : '');
+
+function loadSchema(path: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+}
+
+/** The per-type entry subschema — `artifactTypes.types.additionalProperties`. */
+function perTypeEntry(): Record<string, unknown> {
+  const caps = loadSchema(CAPS);
+  const props = caps.properties as Record<string, Record<string, unknown>>;
+  const types = (props.artifactTypes.properties as Record<string, Record<string, unknown>>).types;
+  return types.additionalProperties as Record<string, unknown>;
+}
+
+describe('artifact-type-registration-source (RFC 0145, always-on)', () => {
+  it('A1 — the per-type entry declares `registrationSource` as an OPTIONAL pack|host enum', () => {
+    const entry = perTypeEntry();
+    const props = entry.properties as Record<string, Record<string, unknown>>;
+
+    expect(props.registrationSource, why('§artifactTypes.types', 'facet is declared')).toBeDefined();
+    expect(
+      props.registrationSource.enum,
+      why('§artifactTypes.types', 'enum is exactly [pack, host]'),
+    ).toEqual(['pack', 'host']);
+    expect(
+      (entry.required as string[] | undefined)?.includes('registrationSource') ?? false,
+      why('§artifactTypes.types', 'facet is OPTIONAL — absent ⇒ unspecified provenance, not a default'),
+    ).toBe(false);
+  });
+
+  it('A2 — a valid provenance validates; an out-of-enum value does NOT', () => {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const validate = ajv.compile(perTypeEntry());
+
+    expect(
+      validate({ validated: true, registrationSource: 'host', schemaVersion: 1 }),
+      why('§artifactTypes.types', `"host" validates: ${JSON.stringify(validate.errors)}`),
+    ).toBe(true);
+    expect(
+      validate({ validated: true, registrationSource: 'pack' }),
+      why('§artifactTypes.types', `"pack" validates: ${JSON.stringify(validate.errors)}`),
+    ).toBe(true);
+    // Absent stays legal — requirement 2.
+    expect(
+      validate({ validated: true }),
+      why('§artifactTypes.types', `absent validates: ${JSON.stringify(validate.errors)}`),
+    ).toBe(true);
+    // A third provenance is a wire error, NOT a hint to ignore. This is where the facet
+    // parts company with RFC 0136's `format`, and the reason is in the docblock.
+    expect(
+      validate({ validated: true, registrationSource: 'registry' }),
+      why('§artifactTypes.types', 'an undefined provenance is REJECTED'),
+    ).toBe(false);
+  });
+
+  it('A3 — the facet mirrors the vocabulary `artifact.created` already carries', () => {
+    const payloads = loadSchema(EVENT_PAYLOADS);
+    const defs = payloads.$defs as Record<string, Record<string, unknown>>;
+    const eventProps = defs.artifactCreated.properties as Record<string, Record<string, unknown>>;
+    const entryProps = perTypeEntry().properties as Record<string, Record<string, unknown>>;
+
+    // Requirement 3 says the two surfaces MUST NOT disagree. They cannot even be compared
+    // unless they share a vocabulary, so pin that first — a drift here would let a host
+    // advertise a provenance it could never emit.
+    expect(
+      entryProps.registrationSource.enum,
+      why('RFC 0145 req 3', 'discovery enum matches artifact.created enum'),
+    ).toEqual(eventProps.registrationSource.enum);
+  });
+
+  it.skipIf(V1_DIR === null)('A4 — both prose sites list the facet, so schema and normative surface cannot drift', () => {
+    // The RFC 0144 defect, restated: a wire field with no prose behind it is exactly what
+    // this corpus keeps producing. Two docs carry the per-type facet list; both must name it.
+    for (const name of ['artifact-type-packs.md', 'host-capabilities.md']) {
+      const facetList = readDoc(name).match(
+        /validated, validation, schemaVersion, store, render, export[^}]*}/,
+      );
+      expect(facetList, why(`${name} §"Per-type facets"`, 'per-type facet list present')).not.toBeNull();
+      expect(
+        facetList?.[0].includes('registrationSource'),
+        why(`${name} §"Per-type facets"`, 'facet list names registrationSource'),
+      ).toBe(true);
+    }
+  });
+
+  it.skipIf(V1_DIR === null)('A5 — the spec states the MUST/SHOULD asymmetry the facet exists to disclose', () => {
+    const doc = readDoc('artifact-type-packs.md');
+    expect(
+      /Serving is a MUST for host-registered/.test(doc),
+      why('§Schema distribution', 'serving is a MUST for no-pack types'),
+    ).toBe(true);
+    expect(
+      /serving stays a SHOULD for them/.test(doc),
+      why('§Schema distribution', 'serving stays a SHOULD for pack-backed types'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/artifact-type-store-emission.test.ts

@@ -42,7 +42,7 @@ import { join } from 'node:path';
 import { driver } from '../lib/driver.js';
 import { behaviorGate, behaviorGatePresent } from '../lib/behavior-gate.js';
 import { readArtifactTypesCap } from '../lib/artifactTypes.js';
-import { SCHEMAS_DIR } from '../lib/paths.js';
+import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
 
 const PROFILE = 'openwop-artifact-type-store';
 
@@ -72,6 +72,49 @@ describe('artifact-type-store-emission: the payload fact is pinned always-on (RF
   });
 });
 
+describe('artifact-type-store-emission: what `store: true` claims is stated normatively (RFC 0142 scope ruling)', () => {
+  // Leg B can pass against a host on which only ONE path emits, if the seam happens to route
+  // through that path. What forecloses that is not a test but the scope of the advert itself,
+  // so the scope has to live in the document a host implements against — and be pinned, or a
+  // later edit quietly restores the permissive reading and leg B goes back to certifying a
+  // host the facet describes falsely.
+  const doc = V1_DIR ? readFileSync(join(V1_DIR, 'artifact-type-packs.md'), 'utf8') : '';
+
+  it.skipIf(V1_DIR === null)('the claim is quantified over artifacts of the type, not over the host\'s paths', () => {
+    expect(
+      /\*\*every\*\* path by which the host persists an artifact carrying that registered `artifactTypeId` MUST emit `artifact\.created`/.test(doc),
+      why(
+        'artifact-type-packs.md §"Sub-flags"',
+        'EVERY production path emits, not at least one — the permissive reading lets a host wire the leg-B seam through its single emitting path and pass while most of its production stays silent',
+      ),
+    ).toBe(true);
+    expect(
+      /MUST NOT advertise `store: true` for that type/.test(doc),
+      why('artifact-type-packs.md §"Sub-flags"', 'a host with a silent persistence path for the type is forbidden from advertising it, rather than merely discouraged'),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('the obligation is scoped to REGISTERED types, so the unregistered tier does not falsify an advert', () => {
+    expect(
+      /a path that persists only unregistered artifacts[^.]*is outside this facet and does not falsify the advert/.test(doc),
+      why(
+        'artifact-type-packs.md §"Sub-flags"',
+        'the narrowing is normative, not a courtesy — without it a host holds back an honest advert on account of a path the facet never bound',
+      ),
+    ).toBe(true);
+  });
+
+  it.skipIf(V1_DIR === null)('per-type is named as the instrument, including the case it cannot rescue', () => {
+    expect(
+      /cannot be advertised `store: true` at all until one of those two facts changes/.test(doc),
+      why(
+        'artifact-type-packs.md §"Sub-flags"',
+        'a single type produced through both an emitting and a non-emitting path is not advertisable — per-type resolves a heterogeneous fleet, not a heterogeneous type',
+      ),
+    ).toBe(true);
+  });
+});
+
 /** Reads the `store` facet at BOTH scopes: capability-level and per-type. */
 function storeAdvertised(cap: Record<string, unknown> | null): boolean {
   if (!cap) return false;