@openwop/openwop-conformance 1.152.0 → 1.154.0

package/src/scenarios/discovery-canonical-family-no-shadow.test.ts

@@ -1,219 +0,0 @@
-/**
- * RFC 0149 §E — a vendor extension MUST NOT shadow a canonical capability family.
- *
- * RFC 0073 put canonical families at the document root, and `host-extensions.md`
- * §"Canonical prefixes" puts vendor surface under `x-host-<vendor>-*`,
- * `vendor.<org>.*`, or `private.<host>.*`. Those two rules together are what make
- * discovery negotiable: a consumer reads the root for what the protocol defines
- * and treats a namespaced key as opaque.
- *
- * The gap is what happens when a canonical family name appears *inside* the
- * namespaced region — `vendor.acme.auth`, or an `x-host-acme-*` object carrying
- * its own `interrupts`. Nothing in the corpus forbade it, and a consumer that
- * merges vendor surface over the root before negotiating reads a vendor's
- * `auth` block as *the* auth contract. `host-extensions.md` already says clients
- * MUST treat extension surface as opaque, but "opaque" is a rule about the
- * consumer; it does not stop a host from publishing the collision, and the
- * consumer that gets it wrong is the one that most needed the guardrail.
- *
- * §E's second clause is separate and unconditional: no discovery example may
- * carry credentials or tenant data. Discovery is the one document a host serves
- * credential-free to anonymous callers (RFC 0100 requires `agentCardUrl` to GET-
- * resolve without credentials), so a secret pasted into an example is a secret
- * in the most-copied, least-guarded artifact in the corpus.
- *
- * Both legs are structural and server-free — they read the corpus, not a host.
- * `spec/v1/` and `RFCS/` are repository-only, so this self-skips under the
- * published tarball layout.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync, readdirSync } from 'node:fs';
-import { join, resolve as pathResolve } from 'node:path';
-import { V1_DIR } from '../lib/paths.js';
-
-const SCHEMA_PATH =
-  V1_DIR === null ? null : pathResolve(V1_DIR, '..', '..', 'schemas', 'capabilities.schema.json');
-
-/** The canonical families, read from the schema rather than hand-listed. */
-function canonicalFamilies(): Set<string> {
-  if (SCHEMA_PATH === null) return new Set();
-  const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8')) as {
-    properties?: Record<string, unknown>;
-  };
-  return new Set(Object.keys(schema.properties ?? {}));
-}
-
-/** `host-extensions.md` §"Canonical prefixes". */
-function isVendorKey(key: string): boolean {
-  return /^x-host-/.test(key) || /^(vendor|private)\./.test(key);
-}
-
-interface Finding {
-  readonly file: string;
-  readonly line: number;
-  readonly detail: string;
-}
-
-/** Every fenced json/jsonc example under `dir`, paired with its source line. */
-function fencedObjects(dir: string): { file: string; line: number; value: unknown }[] {
-  const out: { file: string; line: number; value: unknown }[] = [];
-  for (const name of readdirSync(dir).filter((f) => f.endsWith('.md')).sort()) {
-    const lines = readFileSync(join(dir, name), 'utf8').split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      if (!/^```(json|jsonc)\s*$/.test(lines[i]!.trim())) continue;
-      const body: string[] = [];
-      let j = i + 1;
-      while (j < lines.length && lines[j]!.trim() !== '```') body.push(lines[j++]!);
-      try {
-        out.push({ file: name, line: i + 2, value: JSON.parse(body.join('\n')) });
-      } catch {
-        // Unparseable blocks are RFC 0150 §D's problem, not this gate's.
-      }
-      i = j;
-    }
-  }
-  return out;
-}
-
-/** Canonical family names appearing anywhere beneath a vendor-namespaced key. */
-function shadowed(value: unknown, families: Set<string>, insideVendor: boolean): string[] {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return [];
-  const hits: string[] = [];
-  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
-    const nowInside = insideVendor || isVendorKey(key);
-    if (insideVendor && families.has(key)) hits.push(key);
-    hits.push(...shadowed(child, families, nowInside));
-  }
-  return hits;
-}
-
-/**
- * Credential detection runs on THREE axes with different failure modes, because
- * no one of them is complete and the ways they are incomplete do not overlap.
- *
- * A peer put the problem precisely: *a negative existence claim cannot be
- * established by grepping the vocabulary you would have chosen.* Axis 1 alone —
- * a hand-picked list of issuer prefixes — reports clean on every credential
- * format its author did not think of, and reports it in exactly the confident
- * tone of a real check. That is the vacuous-witness pattern wearing a different
- * hat: the gate is honest about what it observed and silent about what it
- * cannot see.
- *
- * None of the three closes the claim. Together they fail differently, which is
- * the most that can be said for them, and it is said here rather than implied by
- * a green run.
- */
-
-/** Axis 1 — known issuer prefixes. Blind to any format not listed. */
-const SECRET_PREFIX = [
-  /\bsk-[A-Za-z0-9]{16,}/,
-  /\bghp_[A-Za-z0-9]{20,}/,
-  /\bAKIA[0-9A-Z]{16}\b/,
-  /\bxox[baprs]-[A-Za-z0-9-]{10,}/,
-  /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/,
-  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/,
-];
-
-/** Axis 2 — the property NAME claims to hold a credential. Blind to odd names. */
-const CREDENTIAL_KEY = /secret|password|token|api_?key|credential|private_?key|bearer/i;
-
-/** An example is allowed to say `sk-…` or `<your-key>`; that is what examples are for. */
-function isPlaceholder(v: string): boolean {
-  if (v.length < 16) return true;
-  if (/^https?:\/\//.test(v)) return true;
-  return /\.\.\.|…|<|>|\bexample\b|\bplaceholder\b|\bredacted\b|\byour-|\bchangeme\b|x{4,}/i.test(v);
-}
-
-/**
- * Axis 3 — dense random-looking material regardless of issuer. Requires no
- * separators, mixed case, digits, and high Shannon entropy, which is what
- * distinguishes a credential body from a long dotted identifier or an SRI hash.
- * Blind to low-entropy secrets and to anything with word structure.
- */
-function isDenseToken(v: string): boolean {
-  if (!/^[A-Za-z0-9]{24,}$/.test(v)) return false;
-  if (!(/[a-z]/.test(v) && /[A-Z]/.test(v) && /[0-9]/.test(v))) return false;
-  const counts = new Map<string, number>();
-  for (const ch of v) counts.set(ch, (counts.get(ch) ?? 0) + 1);
-  let entropy = 0;
-  for (const c of counts.values()) {
-    const p = c / v.length;
-    entropy -= p * Math.log2(p);
-  }
-  return entropy >= 4.2;
-}
-
-function secrets(value: unknown): string[] {
-  const hits: string[] = [];
-  const walk = (v: unknown, key: string | null): void => {
-    if (typeof v === 'string') {
-      for (const re of SECRET_PREFIX) if (re.test(v)) hits.push(`${v.slice(0, 24)} [issuer-prefix]`);
-      if (key !== null && CREDENTIAL_KEY.test(key) && !isPlaceholder(v)) {
-        hits.push(`${key}=${v.slice(0, 24)} [credential-named]`);
-      }
-      if (isDenseToken(v)) hits.push(`${v.slice(0, 24)} [dense-token]`);
-      return;
-    }
-    if (Array.isArray(v)) return v.forEach((c) => walk(c, key));
-    if (v !== null && typeof v === 'object') {
-      for (const [k, c] of Object.entries(v)) walk(c, k);
-    }
-  };
-  walk(value, null);
-  return [...new Set(hits)];
-}
-
-describe.skipIf(V1_DIR === null)('RFC 0149 §E — canonical families are not shadowed', () => {
-  const v1Dir = V1_DIR as string;
-  const rfcsDir = V1_DIR === null ? '' : pathResolve(v1Dir, '..', '..', 'RFCS');
-
-  it('the canonical family list and the example corpus are both non-empty', () => {
-    // Guard: an empty family set or an empty scan makes both legs vacuous —
-    // the failure RFC 0148 exists to close.
-    expect(canonicalFamilies().size, 'capabilities.schema.json MUST declare families').toBeGreaterThan(50);
-    expect(fencedObjects(v1Dir).length, 'spec/v1 MUST contain parseable json examples').toBeGreaterThan(20);
-  });
-
-  it('no vendor-namespaced object re-declares a canonical family', () => {
-    const families = canonicalFamilies();
-    const findings: Finding[] = [];
-    for (const dir of [v1Dir, rfcsDir]) {
-      for (const { file, line, value } of fencedObjects(dir)) {
-        const hits = shadowed(value, families, false);
-        if (hits.length > 0) {
-          const rel = dir === v1Dir ? 'spec/v1' : 'RFCS';
-          findings.push({ file, line, detail: `${rel}/${file}:${line} → ${[...new Set(hits)].join(', ')}` });
-        }
-      }
-    }
-    expect(
-      findings.map((f) => f.detail),
-      'RFC 0149 §E: a canonical family name inside `x-host-*` / `vendor.*` / `private.*` shadows ' +
-        'the family a consumer negotiates on. `host-extensions.md` tells clients to treat ' +
-        'extension surface as opaque, but that binds the consumer — it does not stop a host from ' +
-        'publishing the collision, and the consumer that merges vendor over root before ' +
-        'negotiating is exactly the one the rule was meant to protect.\n  ' +
-        findings.map((f) => f.detail).join('\n  '),
-    ).toEqual([]);
-  });
-
-  it('no discovery example carries credential material', () => {
-    const findings: string[] = [];
-    for (const dir of [v1Dir, rfcsDir]) {
-      for (const { file, line, value } of fencedObjects(dir)) {
-        const hits = secrets(value);
-        if (hits.length > 0) {
-          const rel = dir === v1Dir ? 'spec/v1' : 'RFCS';
-          findings.push(`${rel}/${file}:${line} → ${hits.join(', ')}…`);
-        }
-      }
-    }
-    expect(
-      findings,
-      'RFC 0149 §E: discovery is served credential-free to anonymous callers, so a real-shaped ' +
-        'secret in an example sits in the most-copied, least-guarded artifact in the corpus. ' +
-        'Use an obvious placeholder.\n  ' + findings.join('\n  '),
-    ).toEqual([]);
-  });
-});

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

@@ -1,108 +0,0 @@
-/**
- * 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, V1_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');
-// S38 (2026-08-17): `spec/` is NOT in the published package (`files`), so a path built
-// from SCHEMAS_DIR/../spec ENOENTs for every npm consumer — five always-on legs reddened
-// MyndHyve's bundle for a reason that had nothing to do with the host. Prose legs are
-// repo-layout only: `null` in the published layout and skipped, never thrown.
-const CHAIN_DOC: string | null = V1_DIR === null ? null : join(V1_DIR, '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.skipIf(CHAIN_DOC === null)('the spec documents the no-`right` + required-`left` truthy/falsy semantics', () => {
-    const doc = readFileSync(CHAIN_DOC as string, '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);
-  });
-});

package/src/scenarios/effect-identity-composition.test.ts

@@ -1,129 +0,0 @@
-/**
- * RFC 0150 §B — the Layer-2 logical effect identity is stable across retries.
- *
- * `spec/v1/idempotency.md` contradicted itself. §"Idempotency key composition"
- * put `attempt` — documented one line later as the "zero-based retry attempt
- * counter" — inside the hash, while §"Composition: how the layers compose"
- * promised that when "the engine retries the OpenAI call internally (transient
- * 503), Layer 2's `invocationId` is identical, so the second call either
- * short-circuits (cache hit) or hits OpenAI's own idempotency cache".
- *
- * Both cannot hold. A retry counter in the key means every retry hashes to a
- * NEW key, so the invocation log never hits, the injected `Idempotency-Key`
- * differs, and the provider's own dedup is defeated too. The composition
- * guaranteed a duplicate side effect on precisely the path Layer 2 exists to
- * protect — a duplicate charge, a duplicate send, a duplicate completion.
- *
- * The defect was invisible to every gate in the corpus because both halves are
- * prose. Nothing parsed the formula, and nothing cross-read it against the
- * paragraph asserting the opposite.
- *
- * This gate reads the normative composition block and holds it to §B: domain
- * separation, tenant binding, a per-logical-invocation ordinal that is stable
- * across retries, and NO retry counter. `attempt` remains legitimate telemetry;
- * §B's requirement is that it MUST NOT participate in the identity.
- *
- * Server-free and always-on: it reads the corpus, never a host. `spec/v1/`
- * ships in the repository and NOT in the published tarball, so it self-skips
- * under the published layout — the asymmetry that has already produced three
- * defects here (the `CORPUS-STAMP` gate, the link-checker's filesystem walk,
- * and RFC 0146 leg A4).
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { V1_DIR } from '../lib/paths.js';
-
-const HEADING = '### Idempotency key composition';
-
-/**
- * The first fenced block under the composition heading. Returns null when the
- * heading or its fence is absent, so the guard leg can fail loudly rather than
- * letting every assertion below pass over an empty string.
- */
-function compositionBlock(doc: string): string | null {
-  const lines = doc.split('\n');
-  const start = lines.findIndex((l) => l.trim() === HEADING);
-  if (start === -1) return null;
-  const open = lines.findIndex((l, i) => i > start && /^```/.test(l.trim()));
-  if (open === -1) return null;
-  const body: string[] = [];
-  for (let i = open + 1; i < lines.length && lines[i]!.trim() !== '```'; i++) body.push(lines[i]!);
-  return body.length === 0 ? null : body.join('\n');
-}
-
-describe.skipIf(V1_DIR === null)('RFC 0150 §B — Layer-2 effect identity is retry-stable', () => {
-  const doc = V1_DIR === null ? '' : readFileSync(join(V1_DIR as string, 'idempotency.md'), 'utf8');
-
-  it('the normative composition block is found at all', () => {
-    // Guard: an extractor that matched nothing would make every leg below
-    // vacuously true. That is the exact failure RFC 0148 exists to close, and
-    // this gate must not become an instance of it.
-    expect(
-      compositionBlock(doc),
-      `spec/v1/idempotency.md MUST carry a fenced key composition under "${HEADING}"`,
-    ).not.toBeNull();
-  });
-
-  it('the retry counter does not participate in the identity', () => {
-    const block = compositionBlock(doc) ?? '';
-    expect(
-      /\battempt\b/.test(block),
-      'RFC 0150 §B: `attempt` is separate telemetry and MUST NOT participate in the logical ID. ' +
-        'A retry counter inside the hash gives every retry a different key, so the invocation ' +
-        'log never hits and the injected Idempotency-Key differs — the duplicate side effect ' +
-        'Layer 2 exists to prevent.\n' +
-        block,
-    ).toBe(false);
-  });
-
-  it('the identity is domain-separated and version-tagged', () => {
-    const block = compositionBlock(doc) ?? '';
-    expect(
-      block,
-      'RFC 0150 §B: the preimage MUST open with the `openwop:activity:v2` domain tag so a v1 ' +
-        'and a v2 identity for the same effect cannot collide.',
-    ).toContain('openwop:activity:v2');
-  });
-
-  it('the identity binds the tenant', () => {
-    const block = compositionBlock(doc) ?? '';
-    expect(
-      block,
-      'RFC 0150 §B: `tenantId` is part of the preimage. Without it two tenants that collide on ' +
-        '(runId, nodeId, providerKey) share an invocation-log entry, and one tenant reads the ' +
-        "other's cached provider response.",
-    ).toContain('tenantId');
-  });
-
-  it('the ordinal is documented as stable across retries', () => {
-    const block = compositionBlock(doc) ?? '';
-    expect(block, 'RFC 0150 §B: the preimage carries `logicalInvocationOrdinal`').toContain(
-      'logicalInvocationOrdinal',
-    );
-    // The ordinal only does its job if the prose pins it. An ordinal that a host
-    // is free to re-derive per attempt reintroduces the defect under a new name.
-    // Emphasis and code spans are stripped first so the assertion reads the
-    // requirement, not the markdown that happens to decorate it.
-    const plain = doc.replace(/[`*_]/g, '').replace(/\s+/g, ' ');
-    expect(
-      /logicalInvocationOrdinal MUST NOT change/.test(plain),
-      'RFC 0150 §B: `logicalInvocationOrdinal` MUST NOT change across transport/provider retries, ' +
-        'and the spec MUST say so — otherwise a host may re-derive it per attempt and the ' +
-        'retry-instability returns under a different field name.',
-    ).toBe(true);
-  });
-
-  it('the composition agrees with the claim that a retried call reuses the identity', () => {
-    // The two halves of the contradiction. This leg anchors the ones above to a
-    // real promise in the document rather than to the RFC alone: if the claim
-    // is ever deleted instead of the formula being fixed, this fails and says so.
-    expect(
-      /is identical/.test(doc),
-      'spec/v1/idempotency.md §"Composition: how the layers compose" MUST keep the guarantee ' +
-        'that an internally retried call reuses the same Layer-2 identity. It is the promise the ' +
-        'composition above has to honor.',
-    ).toBe(true);
-  });
-});

package/src/scenarios/effect-identity-cross-scope.test.ts

@@ -1,82 +0,0 @@
-/**
- * RFC 0150 §B — Layer-2 identity is run-scoped, and the spec has to say what
- * that costs.
- *
- * `runId` is in the §B preimage. An effect issued outside any run has no
- * `runId`, so the two identities can never collide, and Layer 2 cannot
- * deduplicate an in-run effect against the same logical effect issued through
- * an operator route, an admin action, or a scheduled job.
- *
- * §"Why this exists" already says implementations "MUST support layer 2 for any
- * node executor that performs an external side effect", and §"Layer 2" opens
- * "Inside a workflow run…". A host reading those literally uses the §B form for
- * the node path — correctly. If that same effect is *also* reachable outside a
- * run, the two paths issue two effects for one logical operation, which is
- * precisely the duplicate-effect class §B exists to kill, on the highest-stakes
- * path it touches.
- *
- * Reported by a tier-1 host from a shipped node pack, not a thought experiment:
- * `feature.commerce.nodes.refund-order` calls the same `refundOrder` that an
- * HTTP route, a connect-admin route, and a seeder call. They key it on business
- * identity rather than the §B form *deliberately*, because run-scoped identity
- * is the wrong scope for that effect — and §B says as much about itself in the
- * fork note, one face of the same limitation.
- *
- * The corpus was silent on this. Silence here reads as "the ordinal form is
- * sufficient", which for a cross-entry-point effect is false.
- *
- * Server-free; reads the corpus, never a host.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { V1_DIR } from '../lib/paths.js';
-
-describe.skipIf(V1_DIR === null)('RFC 0150 §B — cross-scope effect identity', () => {
-  const doc = V1_DIR === null ? '' : readFileSync(join(V1_DIR as string, 'idempotency.md'), 'utf8');
-  const plain = doc.replace(/[`*_]/g, '').replace(/\s+/g, ' ');
-
-  it('the Layer-2 section is found at all', () => {
-    // Guard: an empty read makes every leg below vacuously true.
-    expect(doc.length, 'idempotency.md MUST be readable').toBeGreaterThan(1000);
-    expect(plain, 'the Layer-2 section MUST exist').toContain('Layer 2: Activity-level idempotency');
-  });
-
-  it('the spec states that Layer-2 identity is run-scoped', () => {
-    expect(
-      /run-scoped/.test(plain),
-      'RFC 0150 §B: `runId` is in the preimage, so the identity is scoped to a run. Saying so ' +
-        'explicitly is what makes the next requirement follow rather than look arbitrary.',
-    ).toBe(true);
-  });
-
-  it('the spec requires a business identity when the effect escapes the run', () => {
-    expect(
-      /reachable outside any run/.test(plain),
-      'RFC 0150 §B: the spec MUST name the case — a node side effect that is ALSO reachable ' +
-        'outside any run (operator route, admin action, scheduled job).',
-    ).toBe(true);
-    expect(
-      /MUST additionally key/.test(plain),
-      'RFC 0150 §B: for such an effect the host MUST additionally key on an identity derived from ' +
-        'the business operation. Layer-2 identity alone cannot dedupe across the boundary, because ' +
-        'the out-of-run path has no `runId` to put in the preimage — so a host following the ' +
-        'ordinal form literally reintroduces the duplicate effect §B exists to prevent.',
-    ).toBe(true);
-  });
-
-  it('the run-scope cost is tied to the fork limitation it shares a cause with', () => {
-    // Both are the same fact seen from two sides: `runId` in the preimage. The
-    // spec already documented the fork face; documenting only that one taught
-    // half a limitation.
-    // Asserts the linkage, not a magic phrase: the cross-scope section must
-    // name the fork limitation as the same fact seen from another side.
-    expect(
-      /fork note[\s\S]{0,120}?(one face|other face|same)/.test(plain),
-      'RFC 0150 §B: the fork note and the cross-scope note are one limitation seen twice — ' +
-        '`runId` in the preimage. The cross-scope section MUST reference the fork note, or a ' +
-        'reader concludes the fork case is a special exception rather than an instance.',
-    ).toBe(true);
-  });
-});

package/src/scenarios/error-envelope-canonical-shape.test.ts

@@ -1,64 +0,0 @@
-/**
- * S22 (2026-08-16) — the HTTP error envelope is FLAT, and the suite reads it
- * through one helper.
- *
- * `rest-endpoints.md` §"Error response shape" and `schemas/error-envelope.schema.json`
- * lock `{ error: <string code>, message, details? }` with `additionalProperties:
- * false`. A nested `{ error: { code, retriable } }` shape had crept into three
- * code-list entries, four seam contracts and ~15 scenarios; this scenario pins
- * the decision at the three places it lives — the schema, the helper that every
- * HTTP-envelope leg now reads through, and the prose — so it cannot re-open
- * quietly. Server-free, always-on.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import Ajv2020 from 'ajv/dist/2020.js';
-import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
-import { readErrorCode, readRetriable, isCanonicalErrorEnvelope, isLegacyNestedEnvelope } from '../lib/error-envelope.js';
-
-export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: pins the flat error-envelope decision against the schema, the helper and the prose';
-
-describe('S22 — the canonical HTTP error envelope is flat', () => {
-  const schema = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'error-envelope.schema.json'), 'utf8')) as Record<string, unknown>;
-  const validate = new Ajv2020({ allErrors: true, strict: false }).compile(schema);
-
-  it('the schema says `error` is a string, requires `message`, and forbids other top-level keys', () => {
-    expect(validate({ error: 'runner_unavailable', message: 'no runner', details: { retriable: true } })).toBe(true);
-    expect(validate({ error: { code: 'runner_unavailable', retriable: true } })).toBe(false);
-    expect(validate({ error: 'x', message: 'y', retriable: true })).toBe(false); // top-level retriable is illegal
-    expect(validate({ error: 'x' })).toBe(false); // message required
-  });
-
-  it('readErrorCode / readRetriable read the canonical shape, and tolerate the legacy nested shape only as legacy', () => {
-    const flat = { error: 'interop_version_unsupported', message: 'peer offers 0.3', details: { retriable: false, protocol: 'a2a' } };
-    expect(readErrorCode(flat)).toBe('interop_version_unsupported');
-    expect(readRetriable(flat)).toBe(false);
-    expect(isCanonicalErrorEnvelope(flat)).toBe(true);
-    expect(isLegacyNestedEnvelope(flat)).toBe(false);
-    const nested = { error: { code: 'runner_unavailable', retriable: true } };
-    expect(readErrorCode(nested)).toBe('runner_unavailable');
-    expect(readRetriable(nested)).toBe(true);
-    expect(isCanonicalErrorEnvelope(nested)).toBe(false);
-    expect(isLegacyNestedEnvelope(nested)).toBe(true);
-    expect(readErrorCode({ message: 'no code' })).toBeUndefined();
-    expect(readErrorCode(null)).toBeUndefined();
-    expect(readRetriable({ error: 'x', message: 'y' })).toBeUndefined();
-  });
-
-  it.skipIf(V1_DIR === null)('rest-endpoints.md states the precedence, the details.retriable convention, and carries no nested code-list entry', () => {
-    const prose = readFileSync(join(V1_DIR as string, 'rest-endpoints.md'), 'utf8');
-    expect(prose).toContain('flat** shape above');
-    expect(prose).toContain('### `details.retriable` convention');
-    // the three formerly-nested code-list entries are flat now
-    for (const code of ['runner_unavailable', 'residency_unavailable', 'interop_version_unsupported']) {
-      const line = prose.split('\n').find((l) => l.startsWith('- `' + code + '`')) ?? '';
-      expect(line, code + ' code-list entry MUST exist').not.toBe('');
-      expect(line, code + ' MUST NOT be described with the nested envelope').not.toMatch(/\{\s*"error"\s*:\s*\{/);
-    }
-    // the seam catalog too
-    const seams = readFileSync(join(V1_DIR as string, 'host-sample-test-seams.md'), 'utf8');
-    expect(seams).not.toMatch(/"error":\s*\{\s*"code"/);
-  });
-});