@openwop/openwop-conformance 1.1.0 → 1.2.0

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

@@ -0,0 +1,366 @@
+/**
+ * Workflow-chain expansion semantics — `workflow-chain-packs.md` §"Expansion semantics (normative)"
+ * + reference impl at `conformance/src/lib/workflow-chain-expansion.ts` (closes RFC 0013 Phase 3).
+ *
+ * Server-free scenario. Exercises the 9-step expansion algorithm
+ * through the reference library. Asserts:
+ *
+ *   - Step 5: `{{params.<name>}}` placeholders substitute literally,
+ *     recursively into nested string fields of `config` / `inputs`.
+ *   - Step 6: node id rewriting — same chainId expanded TWICE in one
+ *     parent workflow MUST produce non-colliding ids (the load-bearing
+ *     property — without it, multi-expansion DAGs would have id
+ *     duplicates that violate workflow-definition.schema.json).
+ *   - Step 8: capability propagation — chain-level `capabilities[]`
+ *     copy into every expanded node's `capabilities[]` so existing
+ *     side-effect / streamable gates apply uniformly post-expansion.
+ *   - Edge rewriting — `from`/`to` endpoints that reference fragment
+ *     nodes get the chain prefix; refs to nodes OUTSIDE the fragment
+ *     pass through unchanged so the parent workflow's adjacent wiring
+ *     stays intact.
+ *   - Output shape — the expanded fragment contains ONLY concrete
+ *     typeIds (no chain reference survives to runtime).
+ *
+ * Capability-gated (logical sense): a host that ships chain expansion
+ * advertises `capabilities.workflowChainPacks.supported: true`. This
+ * scenario runs unconditionally because the reference library is
+ * black-box logic — the spec is the spec regardless of host adoption.
+ * Host-side end-to-end expansion gates on the capability flag.
+ *
+ * @see spec/v1/workflow-chain-packs.md §"Expansion semantics (normative)"
+ * @see conformance/src/lib/workflow-chain-expansion.ts
+ * @see RFCS/0013-workflow-chain-packs.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { expandChain, type WorkflowChain } from '../lib/workflow-chain-expansion.js';
+
+/** Index helper that narrows away the `T | undefined` from `noUncheckedIndexedAccess`
+ *  with an actionable error message — replaces `arr[i]!` non-null assertions so a
+ *  shape mismatch surfaces as a real diagnostic instead of a TypeError-on-property-access. */
+function at<T>(arr: ReadonlyArray<T>, i: number, label: string): T {
+  const value = arr[i];
+  if (value === undefined) {
+    throw new Error(`${label}[${i}] expected to be defined (length=${arr.length})`);
+  }
+  return value;
+}
+
+/** Canonical sample chain used across multiple cases — mirrors the
+ *  spec doc's "Positive: 1-node chain" example, kept tight so each
+ *  assertion is focused on one rule. */
+const SAMPLE_CHAIN: WorkflowChain = {
+  chainId: 'vendor.acme.generatePRD',
+  version: '1.0.0',
+  label: 'Generate PRD',
+  description: 'Single-node AI call.',
+  parameters: {
+    type: 'object',
+    required: ['productIdea'],
+    properties: {
+      productIdea: { type: 'string' },
+      targetAudience: { type: 'string', default: '' },
+    },
+  },
+  dag: {
+    nodes: [
+      {
+        id: 'prd-call',
+        typeId: 'core.ai.callPrompt',
+        name: 'Generate PRD',
+        config: {
+          systemPrompt: 'Write a PRD for: {{params.productIdea}}\nAudience: {{params.targetAudience}}',
+          envelopeType: 'prd.create',
+          provider: 'anthropic',
+        },
+      },
+    ],
+    edges: [],
+  },
+};
+
+/** Resolver helper — accepts every typeId. Used when typeId resolution
+ *  isn't the property under test. The unresolvable-typeid scenario lives
+ *  in its own file. */
+const RESOLVE_ALL = (_typeId: string): boolean => true;
+
+describe('category: workflow-chain expansion — placeholder substitution', () => {
+  it('substitutes {{params.x}} placeholders literally in config strings', () => {
+    const fragment = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'a8f3',
+      params: { productIdea: 'AI-powered toaster', targetAudience: 'restaurant chains' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(fragment.nodes).toHaveLength(1);
+    const config = at(fragment.nodes, 0, 'fragment.nodes').config as { systemPrompt: string };
+    expect(
+      config.systemPrompt,
+      'Per workflow-chain-packs.md §"Parameter substitution": placeholders MUST be substituted literally at expansion time.',
+    ).toBe('Write a PRD for: AI-powered toaster\nAudience: restaurant chains');
+  });
+
+  it('recurses into nested object structures in config', () => {
+    const chain: WorkflowChain = {
+      ...SAMPLE_CHAIN,
+      dag: {
+        nodes: [
+          {
+            id: 'n',
+            typeId: 'core.identity',
+            config: {
+              outer: {
+                middle: {
+                  message: 'Hello {{params.who}}',
+                  tags: ['static', '{{params.who}}-tag'],
+                },
+              },
+            },
+          },
+        ],
+        edges: [],
+      },
+    };
+    const fragment = expandChain(chain, {
+      expansionId: 'x1',
+      params: { who: 'world' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    const config = at(fragment.nodes, 0, 'fragment.nodes').config as {
+      outer: { middle: { message: string; tags: string[] } };
+    };
+    expect(
+      config.outer.middle.message,
+      'Recursive substitution MUST walk into nested objects (per spec §Parameter substitution: "Substitution MUST recurse into nested string values within `config` and `inputs`").',
+    ).toBe('Hello world');
+    expect(
+      config.outer.middle.tags,
+      'Recursive substitution MUST also walk into array elements when those elements are strings.',
+    ).toEqual(['static', 'world-tag']);
+  });
+
+  it('leaves non-placeholder strings untouched', () => {
+    const fragment = expandChain(
+      {
+        ...SAMPLE_CHAIN,
+        dag: {
+          nodes: [
+            {
+              id: 'n',
+              typeId: 'core.identity',
+              config: { literal: 'no placeholders here', empty: '' },
+            },
+          ],
+          edges: [],
+        },
+      },
+      { expansionId: 'x', params: {}, isTypeIdResolvable: RESOLVE_ALL },
+    );
+    const config = at(fragment.nodes, 0, 'fragment.nodes').config as { literal: string; empty: string };
+    expect(config.literal).toBe('no placeholders here');
+    expect(config.empty).toBe('');
+  });
+
+  it('substitutes the same placeholder name in multiple positions', () => {
+    const fragment = expandChain(
+      {
+        ...SAMPLE_CHAIN,
+        dag: {
+          nodes: [
+            {
+              id: 'n',
+              typeId: 'core.identity',
+              config: { a: '{{params.who}}', b: '{{params.who}}', joined: 'hi {{params.who}}, hi again {{params.who}}' },
+            },
+          ],
+          edges: [],
+        },
+      },
+      { expansionId: 'x', params: { who: 'Ada' }, isTypeIdResolvable: RESOLVE_ALL },
+    );
+    const config = at(fragment.nodes, 0, 'fragment.nodes').config as { a: string; b: string; joined: string };
+    expect(config.a).toBe('Ada');
+    expect(config.b).toBe('Ada');
+    expect(config.joined).toBe('hi Ada, hi again Ada');
+  });
+});
+
+describe('category: workflow-chain expansion — node id collision avoidance', () => {
+  it('same chain expanded TWICE in one parent workflow produces non-colliding node ids', () => {
+    const first = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'a8f3',
+      params: { productIdea: 'first', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    const second = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'b9e4',
+      params: { productIdea: 'second', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(first.nodes, 0, 'first.nodes').id,
+      'Per spec §"Expansion semantics" step 6: each expansion MUST use a unique `expansionId` prefix so multi-expansion DAGs do not collide.',
+    ).not.toBe(at(second.nodes, 0, 'second.nodes').id);
+    expect(at(first.nodes, 0, 'first.nodes').id).toBe('vendor_acme_generatePRD_a8f3_prd-call');
+    expect(at(second.nodes, 0, 'second.nodes').id).toBe('vendor_acme_generatePRD_b9e4_prd-call');
+  });
+
+  it('rewritten ids replace dots in chainId with underscores for storage-key safety', () => {
+    const fragment = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'x',
+      params: { productIdea: 'p', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(fragment.nodes, 0, 'fragment.nodes').id,
+      'chainId `vendor.acme.generatePRD` MUST be slugged (dots → underscores) so the resulting id is safe to use in storage backends that reserve `.` for hierarchical keys.',
+    ).toMatch(/^vendor_acme_generatePRD_/);
+    expect(at(fragment.nodes, 0, 'fragment.nodes').id).not.toMatch(/\./);
+  });
+
+  it('exposes idMap so the caller can wire parent-workflow edges into the expansion', () => {
+    const fragment = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'a8f3',
+      params: { productIdea: 'p', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      fragment.idMap.get('prd-call'),
+      'The expansion contract MUST surface the original-id → rewritten-id map so the caller can route adjacent parent-workflow edges to the right expanded node.',
+    ).toBe('vendor_acme_generatePRD_a8f3_prd-call');
+  });
+});
+
+describe('category: workflow-chain expansion — edge rewriting', () => {
+  const MULTI_NODE: WorkflowChain = {
+    chainId: 'vendor.acme.twoStep',
+    version: '1.0.0',
+    label: 'Two-step',
+    description: 'Two nodes connected by an edge.',
+    parameters: {},
+    dag: {
+      nodes: [
+        { id: 'first', typeId: 'core.identity', config: {} },
+        { id: 'second', typeId: 'core.identity', config: {} },
+      ],
+      edges: [{ from: 'first', to: 'second' }],
+    },
+  };
+
+  it('rewrites `from` and `to` ids that reference fragment nodes', () => {
+    const fragment = expandChain(MULTI_NODE, {
+      expansionId: 'e1',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(fragment.edges).toHaveLength(1);
+    expect(
+      at(fragment.edges, 0, 'fragment.edges').from,
+      'Edge `from` ids that match fragment node ids MUST be rewritten with the same prefix as the nodes themselves.',
+    ).toBe('vendor_acme_twoStep_e1_first');
+    expect(at(fragment.edges, 0, 'fragment.edges').to).toBe('vendor_acme_twoStep_e1_second');
+  });
+
+  it('preserves port-name suffix (`nodeId.portName`) when rewriting edge refs', () => {
+    const withPorts: WorkflowChain = {
+      ...MULTI_NODE,
+      dag: {
+        ...MULTI_NODE.dag,
+        edges: [{ from: 'first.out', to: 'second.in' }],
+      },
+    };
+    const fragment = expandChain(withPorts, {
+      expansionId: 'e2',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(fragment.edges, 0, 'fragment.edges').from,
+      'Port-name suffix (after the `.`) MUST be preserved verbatim during id rewriting.',
+    ).toBe('vendor_acme_twoStep_e2_first.out');
+    expect(at(fragment.edges, 0, 'fragment.edges').to).toBe('vendor_acme_twoStep_e2_second.in');
+  });
+
+  it('leaves edge refs alone when they don\'t match a fragment node id', () => {
+    // Refs to OUTSIDE the fragment let the parent-workflow host splice
+    // in adjacent wiring. Critical for the "this chain plugs into
+    // node-X-of-parent-workflow" use case.
+    const withExternalRefs: WorkflowChain = {
+      ...MULTI_NODE,
+      dag: {
+        ...MULTI_NODE.dag,
+        edges: [
+          { from: 'parent-upstream', to: 'first' },
+          { from: 'second', to: 'parent-downstream' },
+        ],
+      },
+    };
+    const fragment = expandChain(withExternalRefs, {
+      expansionId: 'e3',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(fragment.edges, 0, 'fragment.edges').from,
+      'Edge refs to nodes OUTSIDE the fragment MUST pass through unchanged so the parent host can wire adjacent edges post-splice.',
+    ).toBe('parent-upstream');
+    expect(at(fragment.edges, 0, 'fragment.edges').to).toBe('vendor_acme_twoStep_e3_first');
+    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');
+  });
+});
+
+describe('category: workflow-chain expansion — capability propagation', () => {
+  it('copies chain.capabilities[] into every expanded node\'s capabilities[]', () => {
+    const chainWithCaps: WorkflowChain = {
+      ...SAMPLE_CHAIN,
+      capabilities: ['side-effectful', 'cacheable'],
+      dag: {
+        nodes: [
+          { id: 'n1', typeId: 'core.identity', config: {} },
+          { id: 'n2', typeId: 'core.identity', config: {} },
+        ],
+        edges: [{ from: 'n1', to: 'n2' }],
+      },
+    };
+    const fragment = expandChain(chainWithCaps, {
+      expansionId: 'c1',
+      params: {},
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    for (const node of fragment.nodes) {
+      expect(
+        node.capabilities,
+        'Per spec §"Expansion semantics" step 8: chain-level `capabilities[]` MUST be copied to every expanded node so existing capability gates (side-effect, streamable) apply uniformly.',
+      ).toEqual(['side-effectful', 'cacheable']);
+    }
+  });
+
+  it('omits capabilities[] on expanded nodes when the chain declares none', () => {
+    const fragment = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'c2',
+      params: { productIdea: 'p', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    expect(
+      at(fragment.nodes, 0, 'fragment.nodes').capabilities,
+      'When the chain declares no `capabilities[]`, expanded nodes MUST NOT carry an empty array (preserves wire-shape minimality).',
+    ).toBeUndefined();
+  });
+});
+
+describe('category: workflow-chain expansion — runtime-invariance contract', () => {
+  it('expanded fragment carries ONLY concrete typeIds (no chain reference survives)', () => {
+    const fragment = expandChain(SAMPLE_CHAIN, {
+      expansionId: 'r1',
+      params: { productIdea: 'p', targetAudience: '' },
+      isTypeIdResolvable: RESOLVE_ALL,
+    });
+    for (const node of fragment.nodes) {
+      expect(
+        node.typeId,
+        'Per workflow-chain-packs.md §"What hosts dispatch": dispatching runtimes see only concrete `core.*`/published-vendor typeIds — the chain reference MUST NOT be preserved at runtime.',
+      ).not.toMatch(/^vendor\.acme\.generatePRD$/);
+      expect(node.typeId).toBe('core.ai.callPrompt');
+    }
+  });
+});

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

@@ -0,0 +1,232 @@
+/**
+ * Workflow-chain pack manifest validation — `workflow-chain-packs.md` §Manifest format
+ * + `schemas/workflow-chain-pack-manifest.schema.json` (closes RFC 0013 Phase 1).
+ *
+ * Server-free schema-validation scenario. Exercises the new
+ * `workflow-chain-pack-manifest.schema.json` with a positive sample and
+ * two negative samples derived from the RFC's Negative examples:
+ *
+ *   1. Positive: a valid `kind: "workflow-chain"` manifest with a single
+ *      `chains[]` entry validates cleanly.
+ *   2. Negative — kind/contents mismatch: a manifest carrying BOTH
+ *      `chains[]` AND `nodes[]` is rejected. Surface-level outcome at
+ *      the registry HTTP API is `pack_kind_invalid` per the spec;
+ *      schema-level outcome is an `additionalProperties` violation on
+ *      `nodes` (the workflow-chain schema does not declare that field).
+ *   3. Negative — invalid `chainId`: a chain entry whose `chainId` does
+ *      not match the reverse-DNS pattern is rejected with a `pattern`
+ *      violation.
+ *
+ * Capability-gated scenarios for end-to-end expansion
+ * (`workflow-chain-expansion.test.ts`) and signature verification
+ * (`workflow-chain-pack-signature-verification.test.ts`) are deferred
+ * to Phase 2/3 per the RFC.
+ *
+ * @see spec/v1/workflow-chain-packs.md
+ * @see schemas/workflow-chain-pack-manifest.schema.json
+ * @see RFCS/0013-workflow-chain-packs.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import type { ErrorObject } from 'ajv';
+import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
+
+const SCHEMA_PATH = join(SCHEMAS_DIR, 'workflow-chain-pack-manifest.schema.json');
+// In-repo example pack — proves the schema validates a non-trivial
+// real-world-shaped manifest (closes RFC 0013 Phase 4 in-tree path).
+// Resolved relative to the repo root (V1_DIR is non-null in the repo
+// layout AND in any in-tree mirror; null under the published-tarball
+// layout where examples/ isn't bundled). Skipped cleanly when unavailable.
+const REPO_ROOT = V1_DIR ? dirname(dirname(V1_DIR)) : null;
+const EXAMPLE_PACK_PATH = REPO_ROOT
+  ? join(REPO_ROOT, 'examples/packs/workflow-chain-sample/pack.json')
+  : null;
+
+describe('category: workflow-chain-pack manifest validation', () => {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
+  const validate = ajv.compile(schema);
+
+  it('positive: a valid workflow-chain pack manifest validates cleanly', () => {
+    const manifest = {
+      name: 'vendor.acme.editor-presets',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      description: 'Author-time editor presets.',
+      engines: { openwop: '>=1.0.0 <2.0.0' },
+      chains: [
+        {
+          chainId: 'vendor.acme.generatePRD',
+          version: '1.0.0',
+          label: 'Generate PRD',
+          description: 'Single-node AI call with PRD authoring prompt.',
+          parameters: {
+            type: 'object',
+            required: ['productIdea'],
+            properties: {
+              productIdea: { type: 'string' },
+              targetAudience: { type: 'string', default: '' },
+            },
+          },
+          dag: {
+            nodes: [
+              {
+                id: 'prd-call',
+                typeId: 'core.ai.callPrompt',
+                config: {
+                  systemPrompt: 'Write a PRD for: {{params.productIdea}}',
+                  envelopeType: 'prd.create',
+                  provider: 'anthropic',
+                },
+              },
+            ],
+            edges: [],
+          },
+          outputs: {
+            prdId: { type: 'string', description: 'Created PRD artifact id.' },
+          },
+          capabilities: ['side-effectful'],
+        },
+      ],
+    };
+    const ok = validate(manifest);
+    const errs = (validate.errors ?? [])
+      .map((e: ErrorObject) => `${e.instancePath || '/'}: ${e.message}`)
+      .join('\n');
+    expect(
+      ok,
+      `Positive sample MUST validate against workflow-chain-pack-manifest.schema.json — got:\n${errs}`,
+    ).toBe(true);
+  });
+
+  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).
+    // Manifests containing both MUST be rejected at manifest validation with
+    // error code pack_kind_invalid." The schema-level enforcement is via
+    // additionalProperties: false (the workflow-chain schema does not declare
+    // a `nodes` property, so its presence triggers the violation).
+    const manifest = {
+      name: 'vendor.acme.mixed',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '>=1.0.0' },
+      nodes: [
+        { typeId: 'vendor.acme.foo', version: '1.0.0', category: 'data', role: 'pure' },
+      ],
+      chains: [
+        {
+          chainId: 'vendor.acme.bar',
+          version: '1.0.0',
+          label: 'Bar',
+          description: 'x',
+          parameters: {},
+          dag: { nodes: [{ id: 'n', typeId: 'core.identity' }], edges: [] },
+        },
+      ],
+    };
+    const ok = validate(manifest);
+    expect(
+      ok,
+      'Manifest with both nodes[] and chains[] MUST fail workflow-chain schema validation (pack_kind_invalid at the registry surface).',
+    ).toBe(false);
+    const hasAdditionalPropertiesErr = (validate.errors ?? []).some(
+      (e: ErrorObject) => e.keyword === 'additionalProperties',
+    );
+    expect(
+      hasAdditionalPropertiesErr,
+      'Expected an `additionalProperties` violation flagging the unexpected `nodes` field.',
+    ).toBe(true);
+  });
+
+  it('negative: chain entry with invalid chainId is rejected (pattern violation)', () => {
+    // Per workflow-chain-packs.md §Chain entry shape: chainId MUST match the
+    // reverse-DNS pattern `^[a-z][a-zA-Z0-9._-]*$`. An empty string, leading
+    // digit, or any other shape violating the pattern fails validation.
+    const manifest = {
+      name: 'vendor.acme.editor-presets',
+      version: '1.0.0',
+      kind: 'workflow-chain',
+      engines: { openwop: '>=1.0.0' },
+      chains: [
+        {
+          // INVALID — leading digit, contains uppercase that breaks the
+          // first-char rule, AND a slash that no chainId is allowed to carry.
+          chainId: '9Bad/Id',
+          version: '1.0.0',
+          label: 'Bad',
+          description: 'x',
+          parameters: {},
+          dag: { nodes: [{ id: 'n', typeId: 'core.identity' }], edges: [] },
+        },
+      ],
+    };
+    const ok = validate(manifest);
+    expect(
+      ok,
+      'Manifest with invalid chainId MUST fail workflow-chain schema validation.',
+    ).toBe(false);
+    const hasPatternErr = (validate.errors ?? []).some(
+      (e: ErrorObject) =>
+        e.keyword === 'pattern' && (e.instancePath ?? '').includes('chainId'),
+    );
+    expect(
+      hasPatternErr,
+      'Expected a `pattern` violation on the chains[].chainId field.',
+    ).toBe(true);
+  });
+
+  it('positive: the in-repo example pack at examples/packs/workflow-chain-sample/ validates against the schema', () => {
+    if (!EXAMPLE_PACK_PATH || !existsSync(EXAMPLE_PACK_PATH)) {
+      // Published-tarball layout doesn't ship examples/; skip cleanly.
+      return;
+    }
+    const manifest = JSON.parse(readFileSync(EXAMPLE_PACK_PATH, 'utf8'));
+    const ok = validate(manifest);
+    const errs = (validate.errors ?? [])
+      .map((e: ErrorObject) => `${e.instancePath || '/'}: ${e.message}`)
+      .join('\n');
+    expect(
+      ok,
+      `examples/packs/workflow-chain-sample/pack.json MUST validate against workflow-chain-pack-manifest.schema.json (closes RFC 0013 Phase 4 in-tree path). Errors:\n${errs}`,
+    ).toBe(true);
+    // Spot-check the structural claims the example README makes:
+    expect(manifest.kind, 'example pack MUST declare kind: "workflow-chain"').toBe(
+      'workflow-chain',
+    );
+    expect(
+      Array.isArray(manifest.chains) && manifest.chains.length === 2,
+      'example pack MUST ship exactly 2 chains (1-node + 2-node shapes) per its README contract',
+    ).toBe(true);
+  });
+
+  it('negative: omitting kind field rejects (kind is required)', () => {
+    // Defensive — the workflow-chain schema makes `kind` REQUIRED so a
+    // node-pack-shape manifest can't accidentally validate against it.
+    const manifest = {
+      name: 'vendor.acme.editor-presets',
+      version: '1.0.0',
+      engines: { openwop: '>=1.0.0' },
+      chains: [
+        {
+          chainId: 'vendor.acme.x',
+          version: '1.0.0',
+          label: 'X',
+          description: 'x',
+          parameters: {},
+          dag: { nodes: [{ id: 'n', typeId: 'core.identity' }], edges: [] },
+        },
+      ],
+    };
+    const ok = validate(manifest);
+    expect(
+      ok,
+      'Manifest without kind: "workflow-chain" MUST fail this schema (the other path is node-pack-manifest.schema.json).',
+    ).toBe(false);
+  });
+});