@openwop/openwop-conformance 1.48.0 → 1.52.0

package/src/scenarios/workflow-chain-deferred-parameters.test.ts

@@ -0,0 +1,298 @@
+/**
+ * Deferred-parameter expansion — `workflow-chain-packs.md` §"Deferred-parameter
+ * expansion (RFC 0124)" + §Security. RFC 0124 (WCP4) lets a workflow-chain
+ * pack's `{{params.*}}` stay overridable per run WITHOUT the non-portable
+ * app-private runtime tokens RFC 0013 forbids: at drop time the host
+ * materializes the chain `parameters` into top-level `variables[]` (author value
+ * → `defaultValue`) and rewrites each token into an already-spec'd runtime
+ * binding (PromptTemplate `{{varName}}` with `source:"variable"`, or a
+ * variable-sourced PortValue), so the persisted fragment carries ZERO
+ * `{{params.*}}` tokens.
+ *
+ * §Security (amended 2026-07-04): a `x-openwop-sensitive` parameter MUST
+ * materialize as a `source:"secret"` PromptVariable (BYOK, `[REDACTED]`, never
+ * bagged), is deferrable ONLY in a prompt-body position, and FAILS CLOSED
+ * (`sensitive_param_not_deferrable`, 422) in a whole-value `node.inputs` /
+ * embedded non-prompt config / host lacking `secrets` support. Per-run supply of
+ * a sensitive param is a `credentialRef` string, never plaintext (a plaintext
+ * `configurable` for a sensitive param ⇒ `validation_error`).
+ *
+ * Two layers:
+ *   A. Always-on, server-free legs against the spec-authoritative reference
+ *      `conformance/src/lib/workflow-chain-expansion.ts` (`expandChainDeferred`)
+ *      + the capabilities/manifest schema shapes. These pin the deferred-
+ *      expansion + §Security MUSTs (the new fail-closed error path has no other
+ *      public test).
+ *   B. Capability-gated host legs (`workflowChainPacks.deferredParameters.
+ *      supported`) over the `workflow-chain-host-expansion` seam — override,
+ *      fork-replay, untrusted-fence, and `[REDACTED]` sensitive compose;
+ *      soft-skip until a host advertises (openwop-app is the single witness via
+ *      its own #1281 gated leg; a second PromptTemplate-compose witness is the
+ *      tracked follow-up per gap G6).
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Deferred-parameter expansion (RFC 0124)"
+ * @see schemas/capabilities.schema.json §workflowChainPacks.deferredParameters
+ * @see schemas/workflow-chain-pack-manifest.schema.json (x-openwop-sensitive)
+ * @see RFCS/0124-portable-per-run-parameter-deferral.md
+ * @see SECURITY/invariants.yaml id: prompt-composed-secret-redaction
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+import {
+  expandChainDeferred,
+  SensitiveParamNotDeferrableError,
+  type WorkflowChain,
+  type DeferredExpansionContext,
+} from '../lib/workflow-chain-expansion.js';
+
+const CAPS = join(SCHEMAS_DIR, 'capabilities.schema.json');
+const MANIFEST = join(SCHEMAS_DIR, 'workflow-chain-pack-manifest.schema.json');
+const CHAIN_DOC = join(SCHEMAS_DIR, '..', 'spec', 'v1', 'workflow-chain-packs.md');
+
+/** Spec-cited assertion message. Unlike `driver.describe`, this does NOT load
+ *  env, so it is safe in always-on server-free legs (no OPENWOP_BASE_URL). */
+const cite = (section: string, requirement: string): string => `${section} — ${requirement}`;
+
+const resolvable = () => true;
+const HOST_FULL = { promptVariableSource: true, secretsSupported: true };
+
+/** A minimal chain builder for the deferred-expansion legs. */
+function chain(
+  nodes: WorkflowChain['dag']['nodes'],
+  parameters: object,
+): WorkflowChain {
+  return {
+    chainId: 'test.deferred',
+    version: '1.0.0',
+    label: 'Deferred test',
+    description: 'x',
+    parameters,
+    dag: { nodes },
+  };
+}
+
+function deferCtx(
+  params: Record<string, unknown>,
+  parameterSchema: DeferredExpansionContext['parameterSchema'],
+  host = HOST_FULL,
+): DeferredExpansionContext {
+  return { expansionId: 'a1b2', params, parameterSchema, isTypeIdResolvable: resolvable, host };
+}
+
+/** Deep scan for any residual `{{params.*}}` token in the expanded fragment. */
+function hasResidualToken(frag: unknown): boolean {
+  return /\{\{params\./.test(JSON.stringify(frag));
+}
+
+describe('workflow-chain-deferred: non-sensitive deferral (server-free, RFC 0124)', () => {
+  it('materializes variables[] with defaultValue+type and leaves ZERO {{params.*}} tokens (R3)', () => {
+    const c = chain(
+      [
+        { id: 'n1', typeId: 'core.agent', config: { systemPrompt: 'Hello {{params.topic}}' } },
+        { id: 'n2', typeId: 'core.transform', inputs: { limit: '{{params.count}}' } },
+      ],
+      {
+        properties: {
+          topic: { type: 'string', description: 'the topic' },
+          count: { type: 'number' },
+        },
+      },
+    );
+    const out = expandChainDeferred(c, deferCtx({ topic: 'sales', count: 5 }, c.parameters as never));
+
+    expect(
+      hasResidualToken({ nodes: out.nodes, edges: out.edges }),
+      cite('workflow-chain-packs.md §Deferred-parameter expansion', 'the persisted fragment MUST contain zero {{params.*}} tokens (R3 portability)'),
+    ).toBe(false);
+
+    const topicVar = out.variables.find((v) => v.name === 'topic');
+    expect(topicVar, 'topic MUST be materialized as a top-level variable').toBeDefined();
+    expect(topicVar!.defaultValue, 'author input becomes defaultValue').toBe('sales');
+    expect(topicVar!.type, 'type copied from the parameter schema').toBe('string');
+
+    // prompt token → {{varName}} + source:"variable"
+    expect((out.nodes[0].config as { systemPrompt: string }).systemPrompt).toBe('Hello {{topic}}');
+    expect(out.promptVariables.find((p) => p.name === 'topic')?.source).toBe('variable');
+  });
+
+  it('a whole-value input token becomes a variable-sourced PortValue (WCP2 raw-typed)', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.transform', inputs: { limit: '{{params.count}}' } }],
+      { properties: { count: { type: 'number' } } },
+    );
+    const out = expandChainDeferred(c, deferCtx({ count: 5 }, c.parameters as never));
+    expect(
+      out.nodes[0].inputs!.limit,
+      cite('workflow-chain-packs.md §Deferred-parameter expansion', 'a whole-value {{params.x}} input rewrites to a variable-sourced PortValue, not a stringified token'),
+    ).toEqual({ source: 'variable', variable: 'count' });
+  });
+
+  it('the bare param name is the override key in the auto-generated configurableSchema (R6)', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.agent', config: { systemPrompt: '{{params.topic}}' } }],
+      { properties: { topic: { type: 'string' } } },
+    );
+    const out = expandChainDeferred(c, deferCtx({ topic: 't' }, c.parameters as never));
+    expect(
+      out.configurableSchema.properties.topic,
+      cite('workflow-chain-packs.md §Override key + variable naming', 'the bare parameter name is the normative override key'),
+    ).toEqual({ type: 'string' });
+  });
+});
+
+describe('workflow-chain-deferred: §Security sensitive-parameter MUSTs (server-free, RFC 0124)', () => {
+  const sensitiveSchema = { properties: { apiKey: { type: 'string', 'x-openwop-sensitive': true } } };
+
+  it('a sensitive param in a prompt body materializes as source:"secret" — NO plaintext default persisted', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.agent', config: { systemPrompt: 'key={{params.apiKey}}' } }],
+      sensitiveSchema,
+    );
+    const out = expandChainDeferred(c, deferCtx({ apiKey: 'sk-PLAINTEXT-SECRET' }, sensitiveSchema));
+
+    expect(
+      out.promptVariables.find((p) => p.name === 'apiKey')?.source,
+      cite('workflow-chain-packs.md §Security', 'a sensitive prompt-body param MUST bind source:"secret" (not source:"variable")'),
+    ).toBe('secret');
+    // The plaintext secret MUST appear NOWHERE — not as a variable defaultValue, not in the fragment.
+    expect(
+      JSON.stringify(out).includes('sk-PLAINTEXT-SECRET'),
+      cite('workflow-chain-packs.md §Security', 'the sensitive value MUST NOT be materialized into variables[] or the persisted fragment (never bagged, SR-1)'),
+    ).toBe(false);
+    expect(out.variables.find((v) => v.name === 'apiKey'), 'sensitive param is NOT a plaintext top-level variable').toBeUndefined();
+  });
+
+  it('a sensitive param in a whole-value node.input FAILS CLOSED (sensitive_param_not_deferrable, 422)', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.transform', inputs: { secret: '{{params.apiKey}}' } }],
+      sensitiveSchema,
+    );
+    let err: unknown;
+    try {
+      expandChainDeferred(c, deferCtx({ apiKey: 'sk-x' }, sensitiveSchema));
+    } catch (e) {
+      err = e;
+    }
+    expect(err, 'a sensitive whole-value input MUST throw, not defer').toBeInstanceOf(SensitiveParamNotDeferrableError);
+    expect(
+      (err as SensitiveParamNotDeferrableError).code,
+      cite('workflow-chain-packs.md §Security', 'a sensitive param outside a prompt body MUST fail closed with sensitive_param_not_deferrable'),
+    ).toBe('sensitive_param_not_deferrable');
+    expect((err as SensitiveParamNotDeferrableError).httpStatus).toBe(422);
+  });
+
+  it('a sensitive prompt-body param on a host WITHOUT secrets support FAILS CLOSED (422)', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.agent', config: { systemPrompt: '{{params.apiKey}}' } }],
+      sensitiveSchema,
+    );
+    let err: unknown;
+    try {
+      expandChainDeferred(c, deferCtx({ apiKey: 'sk-x' }, sensitiveSchema, { promptVariableSource: true, secretsSupported: false }));
+    } catch (e) {
+      err = e;
+    }
+    expect(
+      err,
+      cite('workflow-chain-packs.md §Security', 'a host lacking capabilities.secrets MUST NOT plaintext-defer a sensitive param — fail closed'),
+    ).toBeInstanceOf(SensitiveParamNotDeferrableError);
+  });
+
+  it('negative capability: no prompts.variable source ⇒ prompt token falls back to expansion-time (G5)', () => {
+    const c = chain(
+      [{ id: 'n1', typeId: 'core.agent', config: { systemPrompt: 'Hi {{params.topic}}' } }],
+      { properties: { topic: { type: 'string' } } },
+    );
+    const out = expandChainDeferred(
+      c,
+      deferCtx({ topic: 'sales' }, c.parameters as never, { promptVariableSource: false, secretsSupported: true }),
+    );
+    // Fallback resolves the token at expansion time — no {{topic}} slot, value inlined, still zero {{params.*}}.
+    expect((out.nodes[0].config as { systemPrompt: string }).systemPrompt).toBe('Hi sales');
+    expect(hasResidualToken({ nodes: out.nodes }), 'no residual {{params.*}} even on the fallback path').toBe(false);
+  });
+});
+
+describe('workflow-chain-deferred: schema + spec surface (always-on, server-free)', () => {
+  it('capabilities.schema.json §workflowChainPacks.deferredParameters requires supported:boolean', () => {
+    const raw = readFileSync(CAPS, 'utf8');
+    // The deferredParameters block MUST parse as part of the capabilities schema.
+    expect(() => JSON.parse(raw), 'capabilities.schema.json MUST be valid JSON').not.toThrow();
+    expect(raw.includes('"deferredParameters"'), 'the deferredParameters capability block MUST exist').toBe(true);
+    expect(
+      raw.includes('sensitive_param_not_deferrable'),
+      cite('capabilities.schema.json §deferredParameters', 'the capability description MUST reference the fail-closed sensitive rule'),
+    ).toBe(true);
+  });
+
+  it('workflow-chain-pack-manifest.schema.json documents x-openwop-sensitive with the source:"secret" MUST', () => {
+    const raw = readFileSync(MANIFEST, 'utf8');
+    expect(raw.includes('x-openwop-sensitive'), 'the manifest schema MUST recognize x-openwop-sensitive').toBe(true);
+    expect(
+      raw.includes('source:"secret"') || raw.includes('source:\\"secret\\"'),
+      cite('workflow-chain-pack-manifest.schema.json', 'the x-openwop-sensitive description MUST reflect the amended source:"secret" MUST, not the stale plaintext-variable wording'),
+    ).toBe(true);
+  });
+
+  it('the spec pins the error code + the per-run credentialRef (not plaintext) supply shape', () => {
+    const spec = readFileSync(CHAIN_DOC, 'utf8');
+    expect(spec.includes('sensitive_param_not_deferrable'), 'error code MUST be documented').toBe(true);
+    expect(
+      spec.includes('credentialRef'),
+      cite('workflow-chain-packs.md §Security', 'per-run supply of a sensitive param MUST be a credentialRef, not plaintext'),
+    ).toBe(true);
+  });
+});
+
+describe('workflow-chain-deferred: host behavior (capability-gated, RFC 0124)', () => {
+  it('a deferred round-trip: bare-param configurable override changes the value; :fork replays it', async () => {
+    const wcp = await readCapabilityFamily<{ deferredParameters?: { supported?: boolean } }>('workflowChainPacks');
+    if (!behaviorGate('workflowChainPacks.deferredParameters.supported', wcp?.deferredParameters?.supported === true)) return;
+
+    const res = await driver.post('/v1/host/sample/chain/deferred-expand', {
+      chainId: 'conformance.deferred',
+      params: { topic: 'default-topic' },
+      override: { topic: 'run-topic' },
+      fork: true,
+    });
+    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+
+    const body = res.json as { resolved?: string; forkResolved?: string; contentTrust?: string } | undefined;
+    expect(
+      body?.resolved,
+      cite('workflow-chain-packs.md §Deferred-parameter expansion', 'a bare-param configurable override rebinds the resolved value'),
+    ).toBe('run-topic');
+    expect(
+      body?.forkResolved,
+      cite('replay.md §Determinism', ':fork replays the same bound value (RunSnapshot.variables byte-equivalence, R4)'),
+    ).toBe('run-topic');
+    expect(
+      body?.contentTrust,
+      cite('workflow-chain-packs.md §Deferred-parameter expansion step 4', 'a deferred-variable prompt binding composes contentTrust:"untrusted" (R1)'),
+    ).toBe('untrusted');
+  });
+
+  it('a sensitive param composes as [REDACTED:<credentialRef>] and the plaintext appears nowhere', async () => {
+    const wcp = await readCapabilityFamily<{ deferredParameters?: { supported?: boolean } }>('workflowChainPacks');
+    if (!behaviorGate('workflowChainPacks.deferredParameters.supported', wcp?.deferredParameters?.supported === true)) return;
+
+    const res = await driver.post('/v1/host/sample/chain/deferred-expand', {
+      chainId: 'conformance.deferred-sensitive',
+      sensitiveParam: 'apiKey',
+      credentialRef: 'cred-123',
+    });
+    if (res.status === 404 || res.status === 403) return; // seam unwired — soft-skip
+
+    const body = res.json as { composed?: string } | undefined;
+    expect(
+      body?.composed?.includes('[REDACTED'),
+      cite('workflow-chain-packs.md §Security', 'a source:"secret" sensitive var MUST redact to [REDACTED:<credentialRef>] in prompt.composed'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/workflow-chain-expansion.test.ts

@@ -307,6 +307,55 @@ describe('category: workflow-chain expansion — edge rewriting', () => {
     expect(at(fragment.edges, 1, 'fragment.edges').from).toBe('vendor_acme_twoStep_e3_second');
     expect(at(fragment.edges, 1, 'fragment.edges').to).toBe('parent-downstream');
   });
+
+  it('preserves edge `condition` and `triggerRule` onto the expanded WorkflowEdge (RFC 0013 amendment #818 + RFC 0125)', () => {
+    // A fragment edge carrying content-routing (`condition`) + fan-in
+    // (`triggerRule`) MUST survive expansion — otherwise the scheduler never
+    // sees them and the fields are silently ignored (the failure mode the
+    // RFC 0013 `condition` amendment and RFC 0125 both call out).
+    const withEdgeFields: WorkflowChain = {
+      ...MULTI_NODE,
+      dag: {
+        ...MULTI_NODE.dag,
+        edges: [
+          {
+            from: 'first',
+            to: 'second',
+            condition: { type: 'equals', left: 'status', right: 'ok' },
+            triggerRule: 'all_complete',
+          },
+        ],
+      },
+    };
+    const fragment = expandChain(withEdgeFields, {
+      expansionId: 'e4',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    const edge = at(fragment.edges, 0, 'fragment.edges');
+    expect(edge.from).toBe('vendor_acme_twoStep_e4_first');
+    expect(edge.to).toBe('vendor_acme_twoStep_e4_second');
+    expect(
+      edge.condition,
+      'Per RFC 0013 amendment (2026-07-03): a present `FragmentEdge.condition` MUST be carried onto the expanded WorkflowEdge (not dropped at expansion).',
+    ).toEqual({ type: 'equals', left: 'status', right: 'ok' });
+    expect(
+      edge.triggerRule,
+      'Per RFC 0125 / workflow-chain-packs.md §"Expansion semantics": expansion MUST preserve `FragmentEdge.triggerRule` onto the resulting WorkflowEdge so the scheduler honors the fan-in / error-routing rule.',
+    ).toBe('all_complete');
+  });
+
+  it('omits triggerRule on the expanded edge when the fragment edge declares none (default all_success semantics)', () => {
+    const fragment = expandChain(MULTI_NODE, {
+      expansionId: 'e5',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(fragment.edges, 0, 'fragment.edges').triggerRule,
+      'When a fragment edge declares no `triggerRule`, the expanded edge MUST NOT carry one — omission is identical to the `all_success` default (preserves wire-shape minimality + prior behavior).',
+    ).toBeUndefined();
+  });
 });
 
 describe('category: workflow-chain expansion — capability propagation', () => {

package/src/scenarios/workflow-chain-host-expansion.test.ts

@@ -1,52 +1,79 @@
 /**
  * Workflow-chain pack expansion — live-host gate (RFC 0013 Phase 3).
  *
- * Capability-gated scenario. Skips when the host doesn't advertise
- * `capabilities.workflowChainPacks.supported: true`. Asserts the host's
- * vendor-prefixed expansion endpoint (`POST /v1/host/sample/workflow-
- * chain:expand` — vendor prefix per `host-extensions.md` §"Canonical
- * prefixes") returns expanded fragments equivalent to the spec-
- * authoritative `expandChain()` reference library.
+ * Capability-gated scenario. **RFC 0013 erratum (2026-07-05):** gates on the
+ * OPTIONAL test-seam sub-flag `capabilities.workflowChainPacks.hostExpansionSeam:
+ * true` — NOT on the semantic `workflowChainPacks.supported` claim, which is
+ * witnessed server-free by `workflow-chain-expansion.test.ts`. This decouples a
+ * host's honest `supported` / RFC 0124 `deferredParameters` advertisement from
+ * this scenario's `vendor.openwop.workflow-chain-sample` fixture.
  *
- * Why this exists: the four server-free chain scenarios
- * (manifest-validation, signature-verification, expansion,
- * unresolvable-typeid) cover the pure logic. This scenario proves a
- * reference host wraps the algorithm correctly — fetch + verify +
- * locate + expand — and emits the same wire shape any consumer
- * implementing the spec would. Without it, the RFC's "reference host
- * implements expansion" acceptance criterion cannot be verified
- * end-to-end against an actual deployment.
+ * **A-lite follow-up (2026-07-05):** the `vendor.openwop.workflow-chain-sample`
+ * pack is now **bundled into the conformance package** at
+ * `fixtures/pack-manifests/workflow-chain-sample.pack.json` (host-syncable), and
+ * this scenario **LOADS it + derives the expected expansion from the
+ * spec-authoritative reference library** (`expandChain()`) instead of hardcoding
+ * expected strings — so the published pack is the single source of truth and the
+ * assertions can't drift from it. A serving host resolves the SAME bundled pack
+ * and MUST produce the SAME expansion the reference library computes.
+ *
+ * Asserts the host's vendor-prefixed expansion endpoint (`POST /v1/host/sample/
+ * workflow-chain:expand` — vendor prefix per `host-extensions.md` §"Canonical
+ * prefixes") returns expanded fragments equivalent to `expandChain()` for the
+ * same pack + parameters + host-chosen `expansionId`.
  *
  * Coverage:
- *   1. Discovery advertises the capability (precondition for the rest).
- *   2. Positive — 1-node chain expands; substituted config + rewritten
- *      id + propagated capabilities match the pure-library output for
- *      the same input.
- *   3. Positive — 2-node chain with edges expands; edge endpoints
- *      reference the rewritten ids.
+ *   1. Discovery advertises `hostExpansionSeam` (precondition for the rest).
+ *   2. Positive — 1-node chain expands; host output == reference expansion
+ *      (substituted config + rewritten id + propagated `cacheable`).
+ *   3. Positive — 2-node chain with edges expands; host output == reference
+ *      expansion (rewritten edge endpoints + propagated `side-effectful`).
  *   4. Negative — unknown packName → 404 `pack_not_found`.
  *   5. Negative — known pack, unknown chainId → 404 `chain_not_found`.
  *   6. Negative — malformed body (no chainId) → 422 `invalid_request`.
  *
  * @see spec/v1/workflow-chain-packs.md §"Expansion semantics (normative)"
- * @see capabilities.md §workflowChainPacks
+ * @see conformance/src/lib/workflow-chain-expansion.ts (the reference library)
  * @see RFCS/0013-workflow-chain-packs.md (Phase 3)
  */
 
 import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 
 import { driver } from '../lib/driver.js';
 import { loadEnv } from '../lib/env.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
+import { FIXTURES_DIR } from '../lib/paths.js';
+import { expandChain, type WorkflowChain } from '../lib/workflow-chain-expansion.js';
+
+const PROFILE = 'workflowChainPacks.hostExpansionSeam';
+const EXPAND_PATH = '/v1/host/sample/workflow-chain:expand';
 
-const PROFILE = 'workflowChainPacks';
-const SAMPLE_PACK = 'vendor.openwop.workflow-chain-sample';
+// The pack fixture is bundled with the conformance package (ships in `files`),
+// so a host can sync the IDENTICAL pack and this scenario loads it as the
+// contract source of truth (no hardcoded expansion).
+interface SamplePack {
+  name: string;
+  version: string;
+  chains: Array<WorkflowChain>;
+}
+const PACK = JSON.parse(
+  readFileSync(join(FIXTURES_DIR, 'pack-manifests', 'workflow-chain-sample.pack.json'), 'utf8'),
+) as SamplePack;
+const SAMPLE_PACK = PACK.name; // vendor.openwop.workflow-chain-sample
 const CHAIN_1_NODE = 'vendor.openwop.workflow-chain-sample.summarize-text';
 const CHAIN_2_NODE = 'vendor.openwop.workflow-chain-sample.fetch-and-summarize';
-const EXPAND_PATH = '/v1/host/sample/workflow-chain:expand';
+
+function chainById(chainId: string): WorkflowChain {
+  const c = PACK.chains.find((x) => x.chainId === chainId);
+  if (!c) throw new Error(`fixture missing chain ${chainId}`);
+  return c;
+}
 
 interface ChainCaps {
   supported?: boolean;
+  hostExpansionSeam?: boolean;
 }
 
 async function isExpansionAdvertised(): Promise<boolean> {
@@ -54,11 +81,20 @@ async function isExpansionAdvertised(): Promise<boolean> {
   const caps =
     (disco.json as { capabilities?: { workflowChainPacks?: ChainCaps } }).capabilities
       ?.workflowChainPacks ?? {};
-  return caps.supported === true;
+  return caps.hostExpansionSeam === true;
+}
+
+interface ExpandResponse {
+  expansionId: string;
+  chainId: string;
+  packName: string;
+  packVersion: string;
+  nodes: Array<{ id: string; typeId: string; config?: Record<string, unknown>; capabilities?: string[] }>;
+  edges: Array<{ from: string; to: string }>;
 }
 
 describe('workflow-chain-host-expansion: live host wraps expansion algorithm correctly', () => {
-  it('host discovery advertises workflowChainPacks.supported when expansion is implemented', async () => {
+  it('host discovery advertises workflowChainPacks.hostExpansionSeam when the expand seam is served', async () => {
     loadEnv();
     if (!behaviorGate(PROFILE, await isExpansionAdvertised())) return;
 
@@ -69,99 +105,89 @@ describe('workflow-chain-host-expansion: live host wraps expansion algorithm cor
       caps,
       driver.describe(
         'capabilities.md §workflowChainPacks',
-        'host advertising the capability MUST set `supported: true` in the discovery block',
+        'a host serving the RFC 0013 host-expansion test seam MUST set `hostExpansionSeam: true` (and, being a chain-pack consumer, `supported: true`) in the discovery block',
       ),
     ).toBeDefined();
+    expect(caps?.hostExpansionSeam).toBe(true);
     expect(caps?.supported).toBe(true);
   });
 
-  it('positive — 1-node chain expansion via the host returns substituted config + rewritten id', async () => {
+  it('positive — 1-node chain expansion matches the reference library for the bundled pack', async () => {
     if (!behaviorGate(PROFILE, await isExpansionAdvertised())) return;
 
-    const res = await driver.post(EXPAND_PATH, {
-      packName: SAMPLE_PACK,
-      chainId: CHAIN_1_NODE,
-      parameters: {
-        sourceText: 'The quick brown fox jumps over the lazy dog.',
-        targetLength: 'one-sentence',
-        tone: 'casual',
-      },
-    });
-
-    expect(res.status).toBe(200);
-    const body = res.json as {
-      expansionId: string;
-      chainId: string;
-      packName: string;
-      packVersion: string;
-      nodes: Array<{
-        id: string;
-        typeId: string;
-        config?: { systemPrompt?: string };
-        capabilities?: string[];
-      }>;
-      edges: Array<unknown>;
+    const parameters = {
+      sourceText: 'The quick brown fox jumps over the lazy dog.',
+      targetLength: 'one-sentence',
+      tone: 'casual',
     };
+    const res = await driver.post(EXPAND_PATH, { packName: SAMPLE_PACK, chainId: CHAIN_1_NODE, parameters });
+    expect(res.status).toBe(200);
+    const body = res.json as ExpandResponse;
 
     expect(body.chainId).toBe(CHAIN_1_NODE);
     expect(body.packName).toBe(SAMPLE_PACK);
-    expect(body.packVersion).toBe('1.0.0');
-    expect(body.nodes).toHaveLength(1);
-    expect(body.edges).toHaveLength(0);
+    expect(body.packVersion).toBe(PACK.version);
     expect(typeof body.expansionId).toBe('string');
     expect(body.expansionId.length).toBeGreaterThan(0);
 
+    // Derive the expected fragment from the reference library using the HOST's
+    // own expansionId — the host MUST reproduce the same algorithm output.
+    const expected = expandChain(chainById(CHAIN_1_NODE), {
+      expansionId: body.expansionId,
+      params: parameters,
+      isTypeIdResolvable: () => true,
+    });
+
+    expect(body.nodes).toHaveLength(expected.nodes.length);
+    expect(body.edges).toHaveLength(expected.edges.length);
+
     const node = body.nodes[0]!;
-    // Step 6: id rewriting — chainId's dots become underscores +
-    // expansionId suffix + original fragment id.
-    expect(node.id).toMatch(
-      /^vendor_openwop_workflow-chain-sample_summarize-text_[a-f0-9]+_summarize-call$/,
-    );
-    expect(node.typeId).toBe('core.ai.callPrompt');
-
-    // Step 5: literal substitution.
-    const sysPrompt = node.config?.systemPrompt ?? '';
-    expect(sysPrompt).toContain('a one-sentence summary');
-    expect(sysPrompt).toContain('a casual tone');
-    expect(sysPrompt).toContain('The quick brown fox jumps over the lazy dog.');
-
-    // Step 8: capability propagation.
-    expect(node.capabilities).toEqual(['cacheable']);
+    const ref = expected.nodes[0]!;
+    expect(
+      node.id,
+      driver.describe('workflow-chain-packs.md §Expansion semantics', 'host rewrites the node id exactly as the reference library (chainId dots → underscores + expansionId prefix)'),
+    ).toBe(ref.id);
+    expect(node.typeId).toBe(ref.typeId);
+    expect(
+      node.config?.systemPrompt,
+      driver.describe('workflow-chain-packs.md §Expansion semantics', 'host performs the same literal {{params.*}} substitution as the reference library'),
+    ).toBe((ref.config as { systemPrompt?: string } | undefined)?.systemPrompt);
+    expect(
+      node.capabilities,
+      driver.describe('workflow-chain-packs.md §Capability propagation', 'chain capabilities propagate to the expanded node'),
+    ).toEqual(ref.capabilities);
   });
 
-  it('positive — 2-node chain with edges expands with rewritten edge endpoints', async () => {
+  it('positive — 2-node chain matches the reference library (edge rewrite + capability propagation)', async () => {
     if (!behaviorGate(PROFILE, await isExpansionAdvertised())) return;
 
-    const res = await driver.post(EXPAND_PATH, {
-      packName: SAMPLE_PACK,
-      chainId: CHAIN_2_NODE,
-      parameters: {
-        url: 'https://example.com/article',
-        targetLength: 'executive-summary',
-      },
-    });
+    const parameters = { url: 'https://example.com/article', targetLength: 'executive-summary' };
+    const res = await driver.post(EXPAND_PATH, { packName: SAMPLE_PACK, chainId: CHAIN_2_NODE, parameters });
     expect(res.status).toBe(200);
+    const body = res.json as ExpandResponse;
 
-    const body = res.json as {
-      expansionId: string;
-      nodes: Array<{ id: string; typeId: string; capabilities?: string[] }>;
-      edges: Array<{ from: string; to: string }>;
-    };
-    expect(body.nodes).toHaveLength(2);
-    expect(body.edges).toHaveLength(1);
+    const expected = expandChain(chainById(CHAIN_2_NODE), {
+      expansionId: body.expansionId,
+      params: parameters,
+      isTypeIdResolvable: () => true,
+    });
+
+    expect(body.nodes).toHaveLength(expected.nodes.length); // 2
+    expect(body.edges).toHaveLength(expected.edges.length); // 1
 
-    // Both expanded nodes get the same prefix; the edge's `from`/`to`
-    // refer to fragment node ids and so get rewritten with the same
-    // prefix (port suffix preserved).
     const edge = body.edges[0]!;
-    const prefix = `vendor_openwop_workflow-chain-sample_fetch-and-summarize_${body.expansionId}_`;
-    expect(edge.from).toBe(`${prefix}fetch.body`);
-    expect(edge.to).toBe(`${prefix}summarize.sourceText`);
-
-    // side-effectful capability propagated to BOTH expanded nodes.
-    for (const node of body.nodes) {
-      expect(node.capabilities, `node ${node.id} inherits chain capability`).toEqual(['side-effectful']);
-    }
+    const refEdge = expected.edges[0]!;
+    expect(
+      { from: edge.from, to: edge.to },
+      driver.describe('workflow-chain-packs.md §Expansion semantics', 'host rewrites fragment-internal edge endpoints (port suffix preserved) exactly as the reference library'),
+    ).toEqual({ from: refEdge.from, to: refEdge.to });
+
+    // side-effectful capability propagated to BOTH expanded nodes (per the ref).
+    const refCaps = expected.nodes.map((n) => n.capabilities);
+    expect(
+      body.nodes.map((n) => n.capabilities),
+      driver.describe('workflow-chain-packs.md §Capability propagation', 'chain capability propagates uniformly to every expanded node'),
+    ).toEqual(refCaps);
   });
 
   it('negative — unknown pack returns 404 pack_not_found', async () => {
@@ -192,10 +218,7 @@ describe('workflow-chain-host-expansion: live host wraps expansion algorithm cor
     if (!behaviorGate(PROFILE, await isExpansionAdvertised())) return;
 
     // Missing chainId.
-    const res = await driver.post(EXPAND_PATH, {
-      packName: SAMPLE_PACK,
-      parameters: {},
-    });
+    const res = await driver.post(EXPAND_PATH, { packName: SAMPLE_PACK, parameters: {} });
     expect(res.status).toBe(422);
     expect((res.json as { error: string }).error).toBe('invalid_request');
   });