@openwop/openwop-conformance 1.47.0 → 1.51.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,12 +1,18 @@
 /**
  * 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 (never bundled
+ * into `@openwop/openwop-conformance`, so no host has been handed it — the
+ * scenario soft-skips everywhere until a serving host advertises the seam).
+ * 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.
  *
  * Why this exists: the four server-free chain scenarios
  * (manifest-validation, signature-verification, expansion,
@@ -39,7 +45,7 @@ import { driver } from '../lib/driver.js';
 import { loadEnv } from '../lib/env.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 
-const PROFILE = 'workflowChainPacks';
+const PROFILE = 'workflowChainPacks.hostExpansionSeam';
 const SAMPLE_PACK = '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';
@@ -47,18 +53,25 @@ const EXPAND_PATH = '/v1/host/sample/workflow-chain:expand';
 
 interface ChainCaps {
   supported?: boolean;
+  hostExpansionSeam?: boolean;
 }
 
+// RFC 0013 erratum (2026-07-05): this live-host scenario witnesses the OPTIONAL
+// `POST /v1/host/sample/workflow-chain:expand` TEST SEAM, gated on its own
+// `workflowChainPacks.hostExpansionSeam` sub-flag — NOT on the semantic
+// `workflowChainPacks.supported` claim (which is witnessed server-free by
+// `workflow-chain-expansion.test.ts`). This decouples the RFC 0124
+// `deferredParameters` flip from the unpublished RFC 0013 sample-pack fixture.
 async function isExpansionAdvertised(): Promise<boolean> {
   const disco = await driver.get('/.well-known/openwop');
   const caps =
     (disco.json as { capabilities?: { workflowChainPacks?: ChainCaps } }).capabilities
       ?.workflowChainPacks ?? {};
-  return caps.supported === true;
+  return caps.hostExpansionSeam === true;
 }
 
 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,9 +82,10 @@ 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);
   });
 

package/src/scenarios/workflow-chain-pack-manifest-validation.test.ts

@@ -104,6 +104,65 @@ describe('category: workflow-chain-pack manifest validation', () => {
     ).toBe(true);
   });
 
+  it('positive: a FragmentEdge condition takes the top-level EdgeCondition shape (RFC 0013 safety-fix 2026-07-03)', () => {
+    // §edges: "Same shape as in a top-level workflow definition." An edge
+    // condition therefore MUST be the EdgeCondition object {type,left,right},
+    // not a bare string — this is what lets a chain express content routing.
+    const conditionalChain = {
+      name: 'vendor.acme.router',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '>=1.0.0' },
+      chains: [
+        {
+          chainId: 'vendor.acme.route',
+          version: '1.0.0',
+          label: 'Route',
+          description: 'Router with a conditional branch.',
+          parameters: { type: 'object', properties: {} },
+          dag: {
+            nodes: [
+              { id: 'route', typeId: 'core.flow.router' },
+              { id: 'urgent', typeId: 'core.identity' },
+            ],
+            edges: [
+              { from: 'route', to: 'urgent', condition: { type: 'contains', left: 'branches', right: 'urgent' } },
+            ],
+          },
+        },
+      ],
+    };
+    const ok = validate(conditionalChain);
+    const errs = (validate.errors ?? []).map((e: ErrorObject) => `${e.instancePath || '/'}: ${e.message}`).join('\n');
+    expect(ok, `Object-shaped edge condition MUST validate — got:\n${errs}`).toBe(true);
+  });
+
+  it('negative: a bare-string FragmentEdge condition is rejected (the pre-2026-07-03 shape)', () => {
+    const stringCondition = {
+      name: 'vendor.acme.legacy',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '>=1.0.0' },
+      chains: [
+        {
+          chainId: 'vendor.acme.legacy',
+          version: '1.0.0',
+          label: 'Legacy',
+          description: 'x',
+          parameters: { type: 'object', properties: {} },
+          dag: {
+            nodes: [
+              { id: 'a', typeId: 'core.identity' },
+              { id: 'b', typeId: 'core.identity' },
+            ],
+            edges: [{ from: 'a', to: 'b', condition: 'output.approved == true' }],
+          },
+        },
+      ],
+    };
+    expect(validate(stringCondition), 'A string edge condition MUST NOT validate under the corrected schema').toBe(false);
+  });
+
   it('negative: manifest mixing chains[] AND nodes[] is rejected (pack_kind_invalid)', () => {
     // Per workflow-chain-packs.md §Pack kind discriminator: "Manifests MUST
     // have exactly one of nodes[] (kind=node) OR chains[] (kind=workflow-chain).