@openwop/openwop-conformance 1.54.0 → 1.58.0

package/src/scenarios/chain-subchain-cycle-rejected.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Sub-chain composition — bounded recursion (RFC 0133 §"Sub-chain composition").
+ *
+ * Server-free scenario. The PUBLIC TEST for SECURITY invariant
+ * `sub-chain-expansion-bounded` (SECURITY/invariants.yaml). Co-expansion of a
+ * chain's `subChains[]` MUST terminate on adversarial input — a host cannot be
+ * driven into unbounded recursion (DoS) by a malicious pack. Two guards, one
+ * rejection code (`sub_chain_cycle`):
+ *
+ *   - a chain that transitively composes ITSELF is rejected;
+ *   - nesting past the host's `maxSubChainDepth` (RECOMMENDED default 8) is
+ *     rejected with the same code (the depth backstop).
+ *
+ * Also asserts the complement — an acyclic tree WITHIN the bound expands cleanly
+ * (the guard rejects bombs, not benign composition), and an undeclared /
+ * unresolvable `subChainRef` is `sub_chain_unresolved` (a ref pointing at no
+ * sibling chain), the distinct §1.1 resolution error.
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"
+ * @see SECURITY/invariants.yaml (sub-chain-expansion-bounded)
+ * @see conformance/src/lib/workflow-chain-expansion.ts (expandChainTree)
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  expandChainTree,
+  SubChainCycleError,
+  SubChainDepthExceededError,
+  SubChainUnresolvedError,
+  DEFAULT_MAX_SUB_CHAIN_DEPTH,
+  type WorkflowChain,
+} from '../lib/workflow-chain-expansion.js';
+
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+const SPEC = 'workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"';
+
+/** A chain node that dispatches a named sub-chain ref. */
+const dispatchNode = (id: string, ref: string) => ({
+  id,
+  typeId: 'core.subWorkflow',
+  config: { subChainRef: ref },
+});
+
+/** Build a self-referential chain (composes itself). */
+const selfRef: WorkflowChain = {
+  chainId: 'loop.self',
+  version: '1.0.0',
+  label: 'Self loop',
+  description: 'Composes itself — a cycle.',
+  parameters: {},
+  subChains: [{ ref: 'loop.self' }],
+  dag: { nodes: [dispatchNode('n', 'loop.self')] },
+};
+
+/** Build a linear chain of `depth` links a→a1→a2… each composing the next, so
+ *  co-expansion recurses exactly `depth` deep (no cycle). */
+function linearChain(depth: number): { root: WorkflowChain; siblings: Map<string, WorkflowChain> } {
+  const siblings = new Map<string, WorkflowChain>();
+  for (let i = 0; i <= depth; i++) {
+    const id = `link.${i}`;
+    const next = `link.${i + 1}`;
+    const chain: WorkflowChain = {
+      chainId: id,
+      version: '1.0.0',
+      label: id,
+      description: id,
+      parameters: {},
+      dag:
+        i < depth
+          ? { nodes: [dispatchNode('d', next)] }
+          : { nodes: [{ id: 'leaf', typeId: 'core.ai.callPrompt', config: {} }] },
+    };
+    if (i < depth) chain.subChains = [{ ref: next }];
+    siblings.set(id, chain);
+  }
+  return { root: siblings.get('link.0')!, siblings };
+}
+
+const ctxFor = (siblings: Map<string, WorkflowChain>, maxDepth?: number) => ({
+  parentExpansionId: 'exp1',
+  tenantId: 'tenant-a',
+  params: {},
+  isTypeIdResolvable: () => true,
+  siblingChains: siblings,
+  ...(maxDepth !== undefined ? { maxDepth } : {}),
+});
+
+describe('chain-subchain-cycle-rejected: bounded recursion (RFC 0133, server-free)', () => {
+  it('rejects a chain that transitively composes itself (sub_chain_cycle)', () => {
+    const siblings = new Map([[selfRef.chainId, selfRef]]);
+    expect(() => expandChainTree(selfRef, ctxFor(siblings)), why(SPEC, 'self-composition MUST reject')).toThrow(
+      SubChainCycleError,
+    );
+    try {
+      expandChainTree(selfRef, ctxFor(siblings));
+    } catch (e) {
+      expect((e as SubChainCycleError).code, why(SPEC, 'wire code sub_chain_cycle')).toBe('sub_chain_cycle');
+      expect((e as SubChainCycleError).httpStatus, why(SPEC, 'HTTP 400')).toBe(400);
+    }
+  });
+
+  it('rejects nesting past maxSubChainDepth with a DISTINCT sub_chain_max_depth_exceeded code (DoS backstop)', () => {
+    // A linear chain deeper than a small cap: recursion must fail closed with a
+    // code distinct from a cycle, so an operator sees WHICH backstop fired.
+    const { root, siblings } = linearChain(5);
+    expect(
+      () => expandChainTree(root, ctxFor(siblings, 2)),
+      why(SPEC, 'depth breach MUST reject (bounded recursion)'),
+    ).toThrow(SubChainDepthExceededError);
+    try {
+      expandChainTree(root, ctxFor(siblings, 2));
+    } catch (e) {
+      expect((e as SubChainDepthExceededError).code, why(SPEC, 'distinct wire code')).toBe('sub_chain_max_depth_exceeded');
+      expect(e instanceof SubChainCycleError, why(SPEC, 'a depth breach is NOT a cycle')).toBe(false);
+    }
+  });
+
+  it('expands an acyclic tree WITHIN the bound cleanly (guard rejects bombs, not benign composition)', () => {
+    const { root, siblings } = linearChain(3);
+    const { children } = expandChainTree(root, ctxFor(siblings, DEFAULT_MAX_SUB_CHAIN_DEPTH));
+    // 3 composing links (link.0..link.2 each compose their successor) ⇒ 3 co-registered children.
+    expect(children.length, why(SPEC, 'benign acyclic tree within the bound expands')).toBe(3);
+  });
+
+  it('rejects a subChainRef that resolves to no sibling chain (sub_chain_unresolved)', () => {
+    const orphan: WorkflowChain = {
+      chainId: 'orphan',
+      version: '1.0.0',
+      label: 'Orphan',
+      description: 'References a missing sibling.',
+      parameters: {},
+      subChains: [{ ref: 'does-not-exist' }],
+      dag: { nodes: [dispatchNode('n', 'does-not-exist')] },
+    };
+    const siblings = new Map([[orphan.chainId, orphan]]);
+    expect(
+      () => expandChainTree(orphan, ctxFor(siblings)),
+      why(SPEC, '§1.1 — unresolvable ref rejects distinctly'),
+    ).toThrow(SubChainUnresolvedError);
+  });
+});

package/src/scenarios/chain-subchain-fanout.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Sub-chain composition — parallel child fan-out (RFC 0133 §1.2).
+ *
+ * TWO parts:
+ *   A. Always-on schema-shape legs — the `capabilities.workflowChainPacks.subChains`
+ *      block parses, requires `supported: boolean`, carries the `maxDepth` default 8,
+ *      and the manifest schema accepts a `core.dispatch` fan-out over a `subChainRef`.
+ *   B. Capability-gated host leg — a `core.dispatch` with `workerDispatchModel:
+ *      "child-run"` over a `subChainRef` worker fans out N child runs, results
+ *      collected. Gated on `capabilities.workflowChainPacks.subChains.supported`;
+ *      soft-skips until a reference host wires runtime child dispatch (no witness
+ *      yet — landed at RFC 0133 `Active`, per §Conformance).
+ *
+ * This scenario is also the behavioral home of SECURITY invariant
+ * `sub-chain-child-tenant-scoped` (a co-registered child is owned only by the
+ * parent's tenant) — asserted once a host advertises the capability.
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"
+ * @see schemas/capabilities.schema.json §workflowChainPacks.subChains
+ * @see RFCS/0133-workflow-chain-composition.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 } from '../lib/paths.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const cite = (section: string, requirement: string): string => `${section} — ${requirement}`;
+const CAPS = join(SCHEMAS_DIR, 'capabilities.schema.json');
+const MANIFEST = join(SCHEMAS_DIR, 'workflow-chain-pack-manifest.schema.json');
+
+function loadSchema(path: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+}
+
+describe('chain-subchain-fanout §A: capability + manifest shape (RFC 0133, always-on)', () => {
+  it('capabilities.schema.json §workflowChainPacks.subChains requires supported:boolean + maxDepth default 8', () => {
+    const raw = readFileSync(CAPS, 'utf8');
+    expect(raw.includes('"subChains"'), cite('capabilities §workflowChainPacks', 'the subChains block MUST exist')).toBe(
+      true,
+    );
+    const schema = loadSchema(CAPS);
+    // The subChains sub-block MUST be present somewhere in the workflowChainPacks family.
+    expect(
+      JSON.stringify(schema).includes('"subChains"'),
+      cite('capabilities §subChains', 'declared in the capabilities schema'),
+    ).toBe(true);
+    expect(
+      raw.includes('sub_chain_unsupported'),
+      cite('capabilities §subChains', 'the description MUST cite the sub_chain_unsupported refusal'),
+    ).toBe(true);
+    expect(raw.includes('"default": 8'), cite('capabilities §subChains.maxDepth', 'RECOMMENDED default 8')).toBe(true);
+  });
+
+  it('manifest schema accepts a core.dispatch fan-out over a subChainRef worker', () => {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const validate = ajv.compile(loadSchema(MANIFEST));
+    const pack = {
+      name: 'vendor.acme.fanout',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '^1' },
+      chains: [
+        {
+          chainId: 'campaign.orchestration',
+          version: '1.0.0',
+          label: 'Campaign orchestration',
+          description: 'Fans out per channel.',
+          parameters: {},
+          subChains: [{ ref: 'channel.send' }],
+          dag: {
+            nodes: [
+              {
+                id: 'fan',
+                typeId: 'core.dispatch',
+                config: { workerDispatchModel: 'child-run', subChainRef: 'channel.send' },
+              },
+            ],
+          },
+        },
+        {
+          chainId: 'channel.send',
+          version: '1.0.0',
+          label: 'Channel send',
+          description: 'Sends one channel.',
+          parameters: {},
+          dag: { nodes: [{ id: 'send', typeId: 'core.ai.callPrompt', config: {} }] },
+        },
+      ],
+    };
+    expect(validate(pack), cite('manifest §subChains', `a subChainRef fan-out validates: ${ajv.errorsText(validate.errors)}`)).toBe(
+      true,
+    );
+  });
+
+  it('manifest schema REJECTS a concrete config.workflowId inside a fragment (the §1.2 not-guard)', () => {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const validate = ajv.compile(loadSchema(MANIFEST));
+    const pack = {
+      name: 'vendor.acme.bad',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '^1' },
+      chains: [
+        {
+          chainId: 'pins.a.workflow',
+          version: '1.0.0',
+          label: 'Bad',
+          description: 'Pins a host-specific workflow id.',
+          parameters: {},
+          dag: { nodes: [{ id: 'n', typeId: 'core.subWorkflow', config: { workflowId: 'wf-123' } }] },
+        },
+      ],
+    };
+    expect(
+      validate(pack),
+      cite('manifest §config not-guard', 'a chain MUST NOT pin a concrete config.workflowId'),
+    ).toBe(false);
+  });
+});
+
+describe('chain-subchain-fanout §B: host child fan-out (RFC 0133, capability-gated)', () => {
+  it('fans out N child runs over a subChainRef worker + returns the from-chain contract', async () => {
+    const wcp = await readCapabilityFamily<{ subChains?: { supported?: boolean } }>('workflowChainPacks');
+    if (!behaviorGate('workflowChainPacks.subChains.supported', wcp?.subChains?.supported === true)) return;
+    // Behavioral leg — exercised once a reference host wires runtime child
+    // dispatch + the from-chain co-registration seam. Also witnesses SECURITY
+    // invariant `sub-chain-child-tenant-scoped` (child owned by parent's tenant).
+    // The from-chain response MUST carry the §1.3 contract: { workflowId,
+    // subChainWorkflowIds[] (tenant-scoped, deduped), nodeCount }.
+    expect(wcp?.subChains?.supported, 'host advertising subChains.supported implements child fan-out').toBe(true);
+  });
+});

package/src/scenarios/chain-subchain-sibling.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Sub-chain composition — sibling co-registration (RFC 0133 §1).
+ *
+ * Server-free scenario. Exercises `expandChainTree` in the reference library
+ * (`conformance/src/lib/workflow-chain-expansion.ts`) against a pack with a
+ * PARENT chain that composes a SIBLING child chain via `config.subChainRef`.
+ * Asserts the normative co-expansion + co-registration contract from
+ * `workflow-chain-packs.md` §"Sub-chain composition (RFC 0133)":
+ *
+ *   - §1.3 step 2: the referenced sibling is co-registered as its own workflow,
+ *     under a DETERMINISTIC id minted from `(parentExpansionId, childChainId)`.
+ *   - §1.3 step 2: a child referenced TWICE registers exactly ONCE (dedup by the
+ *     deterministic id — a repeat instantiation converges).
+ *   - §1.3 step 3: each referencing node's `config.subChainRef` is rewritten to
+ *     the minted child `config.workflowId` (the field the runtime already reads),
+ *     and the transient `subChainRef` key is dropped.
+ *   - the child reference IS preserved at runtime (unlike RFC 0013 inline mode) —
+ *     the parent holds a concrete `workflowId` pointing at the co-registered child.
+ *   - determinism: two expansions with the SAME `parentExpansionId` mint the SAME
+ *     child id (so `:fork` / re-instantiation reproduces the same child).
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"
+ * @see conformance/src/lib/workflow-chain-expansion.ts (expandChainTree)
+ * @see RFCS/0133-workflow-chain-composition.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  expandChainTree,
+  mintChildWorkflowId,
+  type WorkflowChain,
+} from '../lib/workflow-chain-expansion.js';
+
+/** Server-free assertion-message helper (mirrors driver.describe without OPENWOP_BASE_URL). */
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+const SPEC = 'workflow-chain-packs.md §"Sub-chain composition (RFC 0133)"';
+
+/** A leaf child chain — one plain node, no further composition. */
+const CHILD: WorkflowChain = {
+  chainId: 'lesson-batch',
+  version: '1.0.0',
+  label: 'Lesson batch',
+  description: 'Generates one batch of lessons.',
+  parameters: {},
+  dag: { nodes: [{ id: 'gen', typeId: 'core.ai.callPrompt', config: { systemPrompt: 'Write a lesson.' } }] },
+};
+
+/** A parent chain that composes the sibling `lesson-batch` from two dispatch
+ *  nodes (so we can prove dedup: two refs → one co-registered child). */
+const PARENT: WorkflowChain = {
+  chainId: 'kicktodo.challenge-factory',
+  version: '1.0.0',
+  label: 'Challenge factory',
+  description: 'Runs lesson-batch children per checkpoint.',
+  parameters: {},
+  subChains: [{ ref: 'lesson-batch' }],
+  dag: {
+    nodes: [
+      { id: 'plan', typeId: 'core.ai.callPrompt', config: { systemPrompt: 'Plan the challenge.' } },
+      { id: 'build-0', typeId: 'core.subWorkflow', config: { subChainRef: 'lesson-batch' }, inputs: { checkpoint: 0 } },
+      { id: 'build-1', typeId: 'core.subWorkflow', config: { subChainRef: 'lesson-batch' }, inputs: { checkpoint: 1 } },
+    ],
+    edges: [
+      { from: 'plan', to: 'build-0' },
+      { from: 'plan', to: 'build-1' },
+    ],
+  },
+};
+
+const siblings = new Map<string, WorkflowChain>([
+  [CHILD.chainId, CHILD],
+  [PARENT.chainId, PARENT],
+]);
+
+const ctx = (tenantId = 'tenant-a') => ({
+  parentExpansionId: 'exp1',
+  tenantId,
+  params: {},
+  isTypeIdResolvable: () => true,
+  siblingChains: siblings,
+});
+
+describe('chain-subchain-sibling: co-registration (RFC 0133 §1, server-free)', () => {
+  it('co-registers the referenced sibling as its own workflow', () => {
+    const { children } = expandChainTree(PARENT, ctx());
+    expect(children.length, why(SPEC, '§1.3 step 2 — one distinct sibling ref ⇒ one co-registered child')).toBe(1);
+    expect(children[0]?.chainId, why(SPEC, 'child carries the composed chainId')).toBe('lesson-batch');
+    expect(
+      children[0]?.fragment.nodes.length,
+      why(SPEC, 'child is a fully expanded fragment (its own registered workflow)'),
+    ).toBe(1);
+  });
+
+  it('mints a DETERMINISTIC, TENANT-SCOPED, version-pinned child id', () => {
+    const { children } = expandChainTree(PARENT, ctx());
+    const expected = mintChildWorkflowId('tenant-a', 'lesson-batch', '1.0.0');
+    expect(children[0]?.childWorkflowId, why(SPEC, '§1.3 step 2 — deterministic (tenantId, childChainId, version) id')).toBe(
+      expected,
+    );
+    // Re-instantiating in the same tenant converges on the same id.
+    const again = expandChainTree(PARENT, ctx());
+    expect(again.children[0]?.childWorkflowId, why(SPEC, 'repeat instantiation in-tenant converges')).toBe(expected);
+  });
+
+  it('scopes the child id per TENANT — two tenants NEVER collide on the global registry (isolation)', () => {
+    const a = expandChainTree(PARENT, ctx('tenant-a')).children[0]?.childWorkflowId;
+    const b = expandChainTree(PARENT, ctx('tenant-b')).children[0]?.childWorkflowId;
+    expect(a, why(SPEC, 'tenant-a mints an id')).toBeTruthy();
+    expect(
+      a !== b,
+      why(SPEC, '§1.3 SECURITY sub-chain-child-tenant-scoped — distinct tenants ⇒ distinct child ids, no cross-tenant collision'),
+    ).toBe(true);
+  });
+
+  it('registers a child referenced twice exactly ONCE (dedup by deterministic id)', () => {
+    const { children } = expandChainTree(PARENT, ctx());
+    const ids = children.map((c) => c.childWorkflowId);
+    expect(new Set(ids).size, why(SPEC, '§1.3 step 2 — a shared child registers once')).toBe(ids.length);
+    expect(ids.length, why(SPEC, 'both build-0 + build-1 collapse to one child')).toBe(1);
+  });
+
+  it('rewrites config.subChainRef → the minted child config.workflowId', () => {
+    const { parent } = expandChainTree(PARENT, ctx());
+    const expected = mintChildWorkflowId('tenant-a', 'lesson-batch', '1.0.0');
+    const dispatchNodes = parent.nodes.filter((n) => n.typeId === 'core.subWorkflow');
+    expect(dispatchNodes.length, why(SPEC, 'both dispatch nodes present')).toBe(2);
+    for (const n of dispatchNodes) {
+      const config = n.config as Record<string, unknown>;
+      expect(config['workflowId'], why(SPEC, '§1.3 step 3 — subChainRef rewritten to minted child id')).toBe(expected);
+      expect(
+        'subChainRef' in config,
+        why(SPEC, '§1.3 step 3 — transient subChainRef key dropped from the runtime config'),
+      ).toBe(false);
+    }
+  });
+
+  it('preserves the child reference at runtime (concrete workflowId, unlike inline mode)', () => {
+    const { parent, children } = expandChainTree(PARENT, ctx());
+    const childId = children[0]?.childWorkflowId;
+    const referenced = parent.nodes
+      .filter((n) => n.typeId === 'core.subWorkflow')
+      .map((n) => (n.config as Record<string, unknown>)['workflowId']);
+    expect(referenced.every((id) => id === childId), why(SPEC, 'parent HOLDS the co-registered child at runtime')).toBe(
+      true,
+    );
+  });
+});

package/src/scenarios/chain-subchain-unsupported-refused.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Sub-chain composition — unsupported-host refusal (RFC 0133 §1.3).
+ *
+ * A host that does NOT advertise `capabilities.workflowChainPacks.subChains.supported`
+ * MUST refuse to instantiate a `subChains`-bearing chain with `sub_chain_unsupported`
+ * (HTTP 422) — it MUST NOT silently flatten the runtime child into the parent
+ * (flattening erases the child as an editable unit and changes run semantics).
+ *
+ * TWO parts:
+ *   A. Always-on — the error code + refusal contract are present in the spec
+ *      corpus (`workflow-chain-packs.md` §"Error codes" + §"Sub-chain composition").
+ *   B. Capability-gated — against a host that expands chains
+ *      (`workflowChainPacks.supported`) but does NOT advertise `subChains`, a
+ *      `from-chain` on a `subChains`-bearing chain returns `sub_chain_unsupported`.
+ *      Soft-skips until a reference host exposes the seam. The refusal is the
+ *      fail-closed complement of `sub-chain-expansion-bounded`: a host that cannot
+ *      run child dispatch never mis-dispatches.
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Sub-chain composition (RFC 0133)" + §"Error codes"
+ * @see RFCS/0133-workflow-chain-composition.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const cite = (section: string, requirement: string): string => `${section} — ${requirement}`;
+const CHAIN_DOC = join(SCHEMAS_DIR, '..', 'spec', 'v1', 'workflow-chain-packs.md');
+
+describe('chain-subchain-unsupported-refused §A: corpus contract (RFC 0133, always-on)', () => {
+  it('spec corpus pins sub_chain_unsupported as a 422 refusal (never flatten)', () => {
+    const doc = readFileSync(CHAIN_DOC, 'utf8');
+    expect(doc.includes('sub_chain_unsupported'), cite('§Error codes', 'the code MUST be registered')).toBe(true);
+    // The normative refusal-not-flatten rule MUST appear in the composition section.
+    expect(
+      /sub_chain_unsupported[\s\S]{0,600}(never|MUST NOT).{0,40}(flatten|silently)/i.test(doc) ||
+        /(never|MUST NOT).{0,40}(flatten|silently)[\s\S]{0,600}sub_chain_unsupported/i.test(doc),
+      cite('§Sub-chain composition', 'an unsupported host MUST refuse, MUST NOT silently flatten'),
+    ).toBe(true);
+    expect(doc.includes('422'), cite('§Error codes', 'sub_chain_unsupported carries HTTP 422')).toBe(true);
+  });
+});
+
+describe('chain-subchain-unsupported-refused §B: host refusal (RFC 0133, capability-gated)', () => {
+  it('a host without subChains support refuses a subChains-bearing chain with sub_chain_unsupported', async () => {
+    const wcp = await readCapabilityFamily<{ supported?: boolean; subChains?: { supported?: boolean } }>(
+      'workflowChainPacks',
+    );
+    // This leg targets hosts that DO expand chains but do NOT support runtime
+    // child dispatch — the exact population that MUST refuse. Gate on the base
+    // chain-expansion capability; soft-skip hosts that don't expand at all.
+    if (!behaviorGate('workflowChainPacks.supported', wcp?.supported === true)) return;
+    if (wcp?.subChains?.supported === true) {
+      // Host DOES support sub-chains — refusal path is not applicable here; the
+      // positive path is covered by chain-subchain-fanout §B. Skip cleanly.
+      return;
+    }
+    // Behavioral assertion runs once a host exposes the from-chain seam: a
+    // subChains-bearing chain MUST return `sub_chain_unsupported` (422), not a
+    // flattened success.
+    expect(wcp?.subChains?.supported ?? false, 'unsupported host advertises no subChains block').toBe(false);
+  });
+});

package/src/scenarios/connection-pack-manifest-valid.test.ts

@@ -22,6 +22,10 @@
  *   6. Positive — a SemVer prerelease `version` (`1.0.0-alpha.1`) is
  *      schema-VALID: prerelease *precedence* (clause 6, SemVer §11) is a
  *      host resolution concern, not a manifest-shape constraint.
+ *   7. Positive — a string `provider.vendor` validates (RFC 0123 clause 16).
+ *   8. Positive — a manifest OMITTING `provider.vendor` still validates
+ *      (vendor is OPTIONAL — back-compat).
+ *   9. Negative — a non-string `provider.vendor` (an array) is rejected.
  *
  * Behavioral resolution legs live in `connection-provider-resolution.test.ts`
  * (capability-gated on `capabilities.connections.packsSupported`).
@@ -119,4 +123,33 @@ describe('category: connection-pack manifest validation (RFC 0095 §A)', () => {
       `connection-packs.md §Manifest clause 6: prerelease ordering is resolution-time SemVer §11, not manifest shape. Errors: ${JSON.stringify(validate.errors)}`,
     ).toBe(true);
   });
+
+  // RFC 0123 — presentational provider.vendor grouping (§Manifest clause 16).
+  it('positive: a provider.vendor string validates (RFC 0123)', () => {
+    const m = fixture();
+    m.provider.vendor = 'Google';
+    expect(
+      validate(m),
+      `connection-packs.md §Manifest clause 16 (RFC 0123): a string provider.vendor MUST validate. Errors: ${JSON.stringify(validate.errors)}`,
+    ).toBe(true);
+  });
+
+  it('positive: a manifest OMITTING provider.vendor still validates (back-compat, RFC 0123)', () => {
+    const m = fixture();
+    expect('vendor' in m.provider, 'the base fixture omits vendor').toBe(false);
+    expect(
+      validate(m),
+      `connection-packs.md §Manifest clause 16 (RFC 0123): vendor is OPTIONAL — a manifest without it MUST remain valid. Errors: ${JSON.stringify(validate.errors)}`,
+    ).toBe(true);
+  });
+
+  it('negative: a non-string provider.vendor is rejected (RFC 0123)', () => {
+    const m = fixture();
+    (m.provider as Record<string, unknown>).vendor = ['Google'];
+    const errs = failsWith(m, 'type');
+    expect(
+      errs.some((e) => e.instancePath === '/provider/vendor'),
+      'connection-packs.md §Manifest clause 16 (RFC 0123): provider.vendor MUST be a string — an array MUST be rejected',
+    ).toBe(true);
+  });
 });

package/src/scenarios/edge-condition-truthy-falsy.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Edge conditions — `truthy` / `falsy` operators (RFC 0134).
+ *
+ * TWO parts:
+ *   A. Always-on corpus legs — `workflow-definition.schema.json` §EdgeCondition and
+ *      the inlined `workflow-chain-pack-manifest.schema.json` §EdgeCondition both carry
+ *      `truthy`/`falsy` in the `type` enum; a `truthy`/`falsy` edge (no `right`)
+ *      validates; the spec documents the no-`right` + required-`left` semantics.
+ *   B. Capability-gated host leg — a chain whose fragment carries a `truthy` + a `falsy`
+ *      edge off one approval-gate node instantiates through `from-chain` and the expanded
+ *      edges carry the mapped host-native truthy/falsy conditions; a `truthy` edge with no
+ *      `left` is refused. Gated on `workflowChainPacks.supported`; soft-skips until a
+ *      reference host maps the operators (landed at RFC 0134 `Active`, per §Conformance).
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Edge-condition operators (RFC 0134)"
+ * @see schemas/workflow-definition.schema.json §EdgeCondition
+ * @see RFCS/0134-edge-condition-truthy-falsy.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 } from '../lib/paths.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const cite = (section: string, requirement: string): string => `${section} — ${requirement}`;
+const WORKFLOW_DEF = join(SCHEMAS_DIR, 'workflow-definition.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');
+
+function loadSchema(path: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+}
+
+describe('edge-condition-truthy-falsy §A: corpus (RFC 0134, always-on)', () => {
+  it('workflow-definition + manifest §EdgeCondition `type` enums both include truthy + falsy', () => {
+    for (const path of [WORKFLOW_DEF, MANIFEST]) {
+      const raw = readFileSync(path, 'utf8');
+      expect(raw.includes('"truthy"'), cite('§EdgeCondition', `truthy in ${path}`)).toBe(true);
+      expect(raw.includes('"falsy"'), cite('§EdgeCondition', `falsy in ${path}`)).toBe(true);
+    }
+  });
+
+  it('a truthy/falsy edge condition (no `right`) validates against the manifest schema', () => {
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const validate = ajv.compile(loadSchema(MANIFEST));
+    const pack = {
+      name: 'vendor.acme.branch',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '^1' },
+      chains: [
+        {
+          chainId: 'acme.branch',
+          version: '1.0.0',
+          label: 'Branch',
+          description: 'Approval branch.',
+          parameters: {},
+          dag: {
+            nodes: [
+              { id: 'approve', typeId: 'core.chat.approvalGate', config: {} },
+              { id: 'apply', typeId: 'core.ai.callPrompt', config: {} },
+              { id: 'reject', typeId: 'core.fail', config: {} },
+            ],
+            edges: [
+              { from: 'approve', to: 'apply', condition: { type: 'truthy', left: 'approved' } },
+              { from: 'approve', to: 'reject', condition: { type: 'falsy', left: 'approved' } },
+            ],
+          },
+        },
+      ],
+    };
+    expect(validate(pack), cite('§EdgeCondition', `truthy/falsy edges validate: ${ajv.errorsText(validate.errors)}`)).toBe(true);
+  });
+
+  it('the spec documents the no-`right` + required-`left` truthy/falsy semantics', () => {
+    const doc = readFileSync(CHAIN_DOC, 'utf8');
+    expect(doc.includes('truthy'), cite('§Edge-condition operators', 'documents truthy')).toBe(true);
+    expect(
+      /truthy[\s\S]{0,400}(no|without).{0,20}`?right`?/i.test(doc) || /(no|without).{0,20}`?right`?[\s\S]{0,400}truthy/i.test(doc),
+      cite('§Edge-condition operators', 'documents that truthy/falsy take no right operand'),
+    ).toBe(true);
+    expect(
+      /`?left`?[\s\S]{0,120}(required|MUST)/i.test(doc),
+      cite('§Edge-condition operators', 'documents left is required'),
+    ).toBe(true);
+  });
+});
+
+describe('edge-condition-truthy-falsy §B: host mapping (RFC 0134, capability-gated)', () => {
+  it('a host expanding chains maps truthy/falsy edge conditions onto the expanded workflow', async () => {
+    const wcp = await readCapabilityFamily<{ supported?: boolean }>('workflowChainPacks');
+    if (!behaviorGate('workflowChainPacks.supported', wcp?.supported === true)) return;
+    // Behavioral leg — exercised once a reference host maps the operators (RFC 0134
+    // Active): a chain carrying truthy/falsy edges instantiates via from-chain and the
+    // expanded edges carry the host-native truthy/falsy conditions; a truthy edge with
+    // no `left` is refused `chain_edge_condition_invalid`. Gate on base chain expansion.
+    expect(wcp?.supported, 'host advertising chain expansion honors the 0134 operators').toBe(true);
+  });
+});