@openwop/openwop-conformance 1.68.2 → 1.71.0

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.2",
+  "version": "1.71.0",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",

package/schemas/capabilities.schema.json

@@ -1792,6 +1792,7 @@
               "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" } }

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,220 @@
+/**
+ * `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.
+ *
+ * LEG B (RFC 0145 G1) closes the gap this file originally carried open. It asserts a host's
+ * advertised `registrationSource` matches what it emits on `artifact.created` (requirement 3).
+ * It was deliberately NOT built at first: against a corpus where no host advertised the facet
+ * it would have gone green by finding nothing. A host now advertises it, so the leg has
+ * something real to compare and can no longer pass vacuously.
+ *
+ * PROFILE = 'openwop-artifact-type-store' is shared with RFC 0142 ON PURPOSE — see the gating
+ * note on leg B for why this leg deliberately does NOT add its own advertise-and-skip gate.
+ *
+ * @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';
+import { driver } from '../lib/driver.js';
+import { behaviorGatePresent } from '../lib/behavior-gate.js';
+import { readArtifactTypesCap } from '../lib/artifactTypes.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);
+  });
+});
+
+const PROFILE = 'openwop-artifact-type-store';
+
+/** True when this type emits at all — `store` at per-type scope, else the capability default. */
+function emitsForType(cap: Record<string, unknown> | null, id: string): boolean {
+  if (!cap) return false;
+  const entry = (cap['types'] as Record<string, unknown> | undefined)?.[id];
+  if (entry && typeof entry === 'object' && 'store' in (entry as Record<string, unknown>)) {
+    return (entry as Record<string, unknown>)['store'] === true;
+  }
+  return cap['store'] === true;
+}
+
+/**
+ * First per-type id advertising `registrationSource` AND emitting, else null.
+ *
+ * BOTH conditions are required, and the second is the subtle one: `registrationSource` is
+ * meaningful on a type the host never emits for (a consumer still learns which schema-resolution
+ * regime applies), but requirement 3 is a statement about AGREEMENT BETWEEN TWO SURFACES, and a
+ * type with no emission has only one. Asserting against it would red a host that is telling the
+ * truth on every surface it actually has.
+ */
+function comparableType(cap: Record<string, unknown> | null): { id: string; advertised: string } | null {
+  const types = cap?.['types'];
+  if (!types || typeof types !== 'object') return null;
+  for (const [id, t] of Object.entries(types as Record<string, unknown>)) {
+    if (!t || typeof t !== 'object') continue;
+    const advertised = (t as Record<string, unknown>)['registrationSource'];
+    if (typeof advertised !== 'string') continue;
+    if (!emitsForType(cap, id)) continue;
+    return { id, advertised };
+  }
+  return null;
+}
+
+describe('artifact-type-registration-source: the advert agrees with the event (RFC 0145 leg B, requirement 3)', () => {
+  it('the emitted registrationSource equals the advertised one for that type', async () => {
+    const cap = await readArtifactTypesCap();
+    const target = comparableType(cap);
+    // INAPPLICABLE, not gated. `registrationSource` is OPTIONAL (requirement 2) and strict mode
+    // must not coerce a host into advertising it — the same call RFC 0142 makes for `store`.
+    if (target === null) return;
+
+    const started = await driver.post('/v1/host/sample/artifacttypes/runproduce', {
+      artifactTypeId: target.id,
+    });
+    // DELIBERATELY NOT a behaviorGate on seam presence. Reaching here means the type advertises
+    // `store`, so `store: true` + no seam is ALREADY strict-red under RFC 0142 leg B — the
+    // scenario that owns that enforcement. Gating again here would double-report one defect,
+    // and gating on the seam for a 0145 advert would coerce hosts into wiring 0142's host-sample
+    // surface in order to advertise a facet that has nothing to do with it.
+    if (started.status === 404 || started.status === 405) return; // seam absent — 0142 reports it
+    expect(
+      started.status >= 200 && started.status < 300,
+      driver.describe('coverage.md §"Open seams"', 'runproduce starts a real run producing one artifact of the requested registered type'),
+    ).toBe(true);
+    const runId = (started.json as Record<string, unknown> | undefined)?.['runId'];
+    if (!behaviorGatePresent(PROFILE, typeof runId === 'string' ? runId : null)) return;
+
+    const events = await driver.get(`/v1/runs/${runId}/events/poll?timeout=5`);
+    expect(
+      events.status,
+      driver.describe('run-events surface', 'the run event log is readable over the standard poll endpoint'),
+    ).toBe(200);
+    const list = ((events.json as Record<string, unknown>)?.['events'] ?? []) as Array<Record<string, unknown>>;
+    const created = list.filter((e) => e['type'] === 'artifact.created');
+    // Emission itself is RFC 0142's MUST, reported by its own leg. Reaching here without an
+    // event means that leg is already red; don't restate its finding as a 0145 failure.
+    if (created.length === 0) return;
+
+    const payload = (created[0]?.['payload'] ?? created[0]?.['data'] ?? {}) as Record<string, unknown>;
+    expect(
+      payload['registrationSource'],
+      driver.describe(
+        'RFC 0145 requirement 3',
+        `the host advertises registrationSource: "${target.advertised}" for ${target.id}, so that is the value it MUST emit — an advert of one provenance against an event carrying another (or carrying none, which asserts UNSPECIFIED provenance and therefore disagrees) is a false advertisement, not a permitted divergence`,
+      ),
+    ).toBe(target.advertised);
+  });
+});

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;